| // Copyright 2014 The Chromium Authors. All rights reserved. | |
| // Use of this source code is governed by a BSD-style license that can be | |
| // found in the LICENSE file. | |
| syntax = "proto2"; | |
| option optimize_for = LITE_RUNTIME; | |
| option java_outer_classname = "SystemProfileProtos"; | |
| option java_package = "org.chromium.components.metrics"; | |
| package metrics; | |
| import "extension_install.proto"; | |
| // Stores information about the user's brower and system configuration. | |
| // The system configuration fields are recorded once per client session. | |
| // Next tag: 28 | |
| message SystemProfileProto { | |
| // The time when the client was compiled/linked, in seconds since the epoch. | |
| optional int64 build_timestamp = 1; | |
| // A version number string for the application. | |
| // Most commonly this is the browser version number found in a user agent | |
| // string, and is typically a 4-tuple of numbers separated by periods. In | |
| // cases where the user agent version might be ambiguous (example: Linux 64- | |
| // bit build, rather than 32-bit build, or a Windows version used in some | |
| // special context, such as ChromeFrame running in IE), then this may include | |
| // some additional postfix to provide clarification not available in the UA | |
| // string. | |
| // | |
| // An example of a browser version 4-tuple is "5.0.322.0". Currently used | |
| // postfixes are: | |
| // | |
| // "-64": a 64-bit build | |
| // "-F": Chrome is running under control of ChromeFrame | |
| // "-devel": this is not an official build of Chrome | |
| // | |
| // A full version number string could look similar to: | |
| // "5.0.322.0-F-devel". | |
| // | |
| // This value, when available, is more trustworthy than the UA string | |
| // associated with the request; and including the postfix, may be more | |
| // specific. | |
| optional string app_version = 2; | |
| // The brand code or distribution tag assigned to a partner, if available. | |
| // Brand codes are only available on Windows. Not every Windows install | |
| // though will have a brand code. | |
| optional string brand_code = 12; | |
| // The possible channels for an installation, from least to most stable. | |
| enum Channel { | |
| CHANNEL_UNKNOWN = 0; // Unknown channel -- perhaps an unofficial build? | |
| CHANNEL_CANARY = 1; | |
| CHANNEL_DEV = 2; | |
| CHANNEL_BETA = 3; | |
| CHANNEL_STABLE = 4; | |
| } | |
| optional Channel channel = 10; | |
| // True if Chrome build is ASan-instrumented. | |
| optional bool is_asan_build = 20 [default = false]; | |
| // The date the user enabled UMA, in seconds since the epoch. | |
| // If the user has toggled the UMA enabled state multiple times, this will | |
| // be the most recent date on which UMA was enabled. | |
| // For privacy, this is rounded to the nearest hour (M30+). | |
| optional int64 uma_enabled_date = 3; | |
| // The time when the client was installed, in seconds since the epoch. | |
| // For privacy, this is rounded to the nearest hour. | |
| optional int64 install_date = 16; | |
| // The user's selected application locale, i.e. the user interface language. | |
| // The locale includes a language code and, possibly, also a country code, | |
| // e.g. "en-US". | |
| optional string application_locale = 4; | |
| // Information on the user's operating system. | |
| // Next tag: 7 | |
| message OS { | |
| // The user's operating system. This should be one of: | |
| // - Android | |
| // - Windows NT | |
| // - Linux (includes ChromeOS) | |
| // - iOS (iOS versions >= 9) | |
| // - iPhone OS (iOS versions <= 8) | |
| // - Mac OS X | |
| optional string name = 1; | |
| // The version of the OS. The meaning of this field is OS-dependent. | |
| optional string version = 2; | |
| // The fingerprint of the build. This field is used only on Android. | |
| optional string build_fingerprint = 3; | |
| // Whether the version of iOS appears to be "jailbroken". This field is | |
| // used only on iOS. Chrome for iOS detects whether device contains a | |
| // DynamicLibraries/ directory. It's a necessary but insufficient indicator | |
| // of whether the operating system has been jailbroken. | |
| optional bool is_jailbroken = 4; | |
| // The version of the kernel. Linux based operating systems, such as | |
| // ChromeOS and Android, have a kernel version that the OS release version | |
| // was built with that differs from the version field above. | |
| optional string kernel_version = 6; | |
| } | |
| optional OS os = 5; | |
| // Information on the user's hardware. | |
| // Next tag: 19 | |
| message Hardware { | |
| // The CPU architecture (x86, PowerPC, x86_64, ...) | |
| optional string cpu_architecture = 1; | |
| // The amount of RAM present on the system, in megabytes. | |
| optional int64 system_ram_mb = 2; | |
| // The base memory address that chrome.dll was loaded at. | |
| // (Logged only on Windows.) | |
| optional int64 dll_base = 3; | |
| // The hardware_class describes the current machine model, e.g. "MacPro1,1" | |
| // on Mac, "iPhone9,3" on iOS or "Nexus 5" on Android. Implemented on OS X, | |
| // iOS, Android, Chrome OS. | |
| // | |
| // The iOS device hardware class was added in Chrome M60 release. Prior | |
| // to that, device hardware class was incorrectly recorded in | |
| // cpu_architecture field. | |
| // | |
| // For Chrome OS, prior to M68, this field had the value that is | |
| // currently in |full_hardware_class| field. In M68+, this contains the | |
| // board name only. E.G. "CELES", "VEYRON_MINNIE". | |
| optional string hardware_class = 4; | |
| // This field is only sent on Chrome OS. The full hardware class is a unique | |
| // string associated with each Chrome OS device product revision generally | |
| // assigned at hardware qualification time. The hardware class effectively | |
| // identifies the configured system components such as CPU, WiFi adapter, | |
| // etc. | |
| // | |
| // An example of such a hardware class is "IEC MARIO PONY 6101". An | |
| // internal database associates this hardware class with the qualified | |
| // device specifications including OEM information, schematics, hardware | |
| // qualification reports, test device tags, etc. | |
| optional string full_hardware_class = 18; | |
| // The number of physical screens. | |
| optional int32 screen_count = 5; | |
| // The screen dimensions of the primary screen, in pixels. | |
| optional int32 primary_screen_width = 6; | |
| optional int32 primary_screen_height = 7; | |
| // The device scale factor of the primary screen. | |
| optional float primary_screen_scale_factor = 12; | |
| // Max DPI for any attached screen. (Windows only) | |
| optional float max_dpi_x = 9; | |
| optional float max_dpi_y = 10; | |
| // Information on the CPU obtained by CPUID. | |
| message CPU { | |
| // A 12 character string naming the vendor, e.g. "GeniuneIntel". | |
| optional string vendor_name = 1; | |
| // The signature reported by CPUID (from EAX). | |
| optional uint32 signature = 2; | |
| // Number of logical processors/cores on the current machine, which | |
| // includes hyperthreaded cores. | |
| optional uint32 num_cores = 3; | |
| } | |
| optional CPU cpu = 13; | |
| // Information on the GPU | |
| message Graphics { | |
| // The GPU manufacturer's vendor id. | |
| optional uint32 vendor_id = 1; | |
| // The GPU manufacturer's device id for the chip set. | |
| optional uint32 device_id = 2; | |
| // The driver version on the GPU. | |
| optional string driver_version = 3; | |
| // The driver date on the GPU. | |
| optional string driver_date = 4; | |
| // The GL_VENDOR string. An example of a gl_vendor string is | |
| // "Imagination Technologies". "" if we are not using OpenGL. | |
| optional string gl_vendor = 6; | |
| // The GL_RENDERER string. An example of a gl_renderer string is | |
| // "PowerVR SGX 540". "" if we are not using OpenGL. | |
| optional string gl_renderer = 7; | |
| } | |
| optional Graphics gpu = 8; | |
| // Information about Bluetooth devices paired with the system. | |
| message Bluetooth { | |
| // Whether Bluetooth is present on this system. | |
| optional bool is_present = 1; | |
| // Whether Bluetooth is enabled on this system. | |
| optional bool is_enabled = 2; | |
| // Describes a paired device. | |
| message PairedDevice { | |
| // Assigned class of the device. This is a bitfield according to the | |
| // Bluetooth specification available at the following URL: | |
| // https://www.bluetooth.org/en-us/specification/assigned-numbers-overview/baseband | |
| optional uint32 bluetooth_class = 1; | |
| // Decoded device type. | |
| enum Type { | |
| DEVICE_UNKNOWN = 0; | |
| DEVICE_COMPUTER = 1; | |
| DEVICE_PHONE = 2; | |
| DEVICE_MODEM = 3; | |
| DEVICE_AUDIO = 4; | |
| DEVICE_CAR_AUDIO = 5; | |
| DEVICE_VIDEO = 6; | |
| DEVICE_PERIPHERAL = 7; | |
| DEVICE_JOYSTICK = 8; | |
| DEVICE_GAMEPAD = 9; | |
| DEVICE_KEYBOARD = 10; | |
| DEVICE_MOUSE = 11; | |
| DEVICE_TABLET = 12; | |
| DEVICE_KEYBOARD_MOUSE_COMBO = 13; | |
| } | |
| optional Type type = 2; | |
| // Vendor prefix of the Bluetooth address, these are OUI registered by | |
| // the IEEE and are encoded with the first byte in bits 16-23, the | |
| // second byte in bits 8-15 and the third byte in bits 0-7. | |
| // | |
| // ie. Google's OUI (00:1A:11) is encoded as 0x00001A11 | |
| optional uint32 vendor_prefix = 4; | |
| // The Vendor ID of a device, returned in vendor_id below, can be | |
| // either allocated by the Bluetooth SIG or USB IF, providing two | |
| // completely overlapping namespaces for identifiers. | |
| // | |
| // This field should be read along with vendor_id to correctly | |
| // identify the vendor. For example Google is identified by either | |
| // vendor_id_source = VENDOR_ID_BLUETOOTH, vendor_id = 0x00E0 or | |
| // vendor_id_source = VENDOR_ID_USB, vendor_id = 0x18D1. | |
| // | |
| // If the device does not support the Device ID specification the | |
| // unknown value will be set. | |
| enum VendorIDSource { | |
| VENDOR_ID_UNKNOWN = 0; | |
| VENDOR_ID_BLUETOOTH = 1; | |
| VENDOR_ID_USB = 2; | |
| } | |
| optional VendorIDSource vendor_id_source = 8; | |
| // Vendor ID of the device, where available. | |
| optional uint32 vendor_id = 5; | |
| // Product ID of the device, where available. | |
| optional uint32 product_id = 6; | |
| // Device ID of the device, generally the release or version number in | |
| // BCD format, where available. | |
| optional uint32 device_id = 7; | |
| } | |
| repeated PairedDevice paired_device = 3; | |
| } | |
| optional Bluetooth bluetooth = 11; | |
| // Whether the internal display produces touch events. Omitted if unknown. | |
| // Logged on ChromeOS only. | |
| optional bool internal_display_supports_touch = 14; | |
| // Vendor ids and product ids of external touchscreens. | |
| // Deprecated as of 8/11/2017. | |
| message DeprecatedTouchScreen { | |
| // Touch screen vendor id. | |
| optional uint32 vendor_id = 1; | |
| // Touch screen product id. | |
| optional uint32 product_id = 2; | |
| } | |
| // Lists vendor and product ids of external touchscreens. | |
| // Logged on ChromeOS only. | |
| // Deprecated as of 8/11/2017. | |
| repeated DeprecatedTouchScreen deprecated_external_touchscreen = 15 | |
| [deprecated = true]; | |
| // Drive messages are currently logged on Windows 7+, iOS, and Android. | |
| message Drive { | |
| // Whether this drive incurs a time penalty when randomly accessed. This | |
| // should be true for spinning disks but false for SSDs or other | |
| // flash-based drives. | |
| optional bool has_seek_penalty = 1; | |
| } | |
| // The drive that the application executable was loaded from. | |
| optional Drive app_drive = 16; | |
| // The drive that the current user data directory was loaded from. | |
| optional Drive user_data_drive = 17; | |
| } | |
| optional Hardware hardware = 6; | |
| // Information about the network connection. | |
| // Next tag: 9 | |
| message Network { | |
| // Set to true if connection_type changed during the lifetime of the log. | |
| optional bool connection_type_is_ambiguous = 1; | |
| // Derived from net::NetworkChangeNotifier::ConnectionType translated | |
| // through NetworkMetricsProvider::GetConnectionType. | |
| enum ConnectionType { | |
| CONNECTION_UNKNOWN = 0; | |
| CONNECTION_ETHERNET = 1; | |
| CONNECTION_WIFI = 2; | |
| CONNECTION_2G = 3; | |
| CONNECTION_3G = 4; | |
| CONNECTION_4G = 5; | |
| CONNECTION_BLUETOOTH = 6; | |
| CONNECTION_NONE = 7; | |
| // As an alternative to connection_type_is_ambiguous above, | |
| // CONNECTION_AMBIGUOUS can be used for connection_type instead. This is | |
| // to be used in logs processing as a more convenient way to manage the | |
| // ambiguous case when breaking down stats by connection_type. | |
| CONNECTION_AMBIGUOUS = 8; | |
| } | |
| // The connection type according to NetworkChangeNotifier. | |
| optional ConnectionType connection_type = 2; | |
| // Set to true if wifi_phy_layer_protocol changed during the lifetime of the | |
| // log. | |
| optional bool wifi_phy_layer_protocol_is_ambiguous = 3; | |
| // See net::WifiPHYLayerProtocol. | |
| enum WifiPHYLayerProtocol { | |
| WIFI_PHY_LAYER_PROTOCOL_NONE = 0; | |
| WIFI_PHY_LAYER_PROTOCOL_ANCIENT = 1; | |
| WIFI_PHY_LAYER_PROTOCOL_A = 2; | |
| WIFI_PHY_LAYER_PROTOCOL_B = 3; | |
| WIFI_PHY_LAYER_PROTOCOL_G = 4; | |
| WIFI_PHY_LAYER_PROTOCOL_N = 5; | |
| WIFI_PHY_LAYER_PROTOCOL_UNKNOWN = 6; | |
| } | |
| // The physical layer mode of the associated wifi access point, if any. | |
| optional WifiPHYLayerProtocol wifi_phy_layer_protocol = 4; | |
| // Describe wifi access point information. | |
| message WifiAccessPoint { | |
| // Vendor prefix of the access point's BSSID. These are OUIs | |
| // (Organizationally Unique Identifiers) registered by | |
| // the IEEE and are encoded with the first byte in bits 16-23, the | |
| // second byte in bits 8-15 and the third byte in bits 0-7. | |
| optional uint32 vendor_prefix = 1; | |
| // Access point security mode definitions. | |
| enum SecurityMode { | |
| SECURITY_UNKNOWN = 0; | |
| SECURITY_WPA = 1; | |
| SECURITY_WEP = 2; | |
| SECURITY_RSN = 3; | |
| SECURITY_802_1X = 4; | |
| SECURITY_PSK = 5; | |
| SECURITY_NONE = 6; | |
| } | |
| // The security mode of the access point. | |
| optional SecurityMode security_mode = 2; | |
| // Vendor specific information. | |
| message VendorInformation { | |
| // The model number, for example "0". | |
| optional string model_number = 1; | |
| // The model name (sometimes the same as the model_number), | |
| // for example "WZR-HP-AG300H". | |
| optional string model_name = 2; | |
| // The device name (sometimes the same as the model_number), | |
| // for example "Dummynet". | |
| optional string device_name = 3; | |
| // The list of vendor-specific OUIs (Organziationally Unqiue | |
| // Identifiers). These are provided by the vendor through WPS | |
| // (Wireless Provisioning Service) information elements, which | |
| // identifies the content of the element. | |
| repeated uint32 element_identifier = 4; | |
| } | |
| // The wireless access point vendor information. | |
| optional VendorInformation vendor_info = 3; | |
| } | |
| // Information of the wireless access point that device is connected to. | |
| optional WifiAccessPoint access_point_info = 5; | |
| // Derived from net::NetworkQualityEstimator::EffectiveConnectionType | |
| // translated through NetworkMetricsProvider::GetConnectionType. | |
| enum EffectiveConnectionType { | |
| EFFECTIVE_CONNECTION_TYPE_UNKNOWN = 0; | |
| // Deprecated: Specifies that the connection_type changed during the | |
| // lifetime of the log. | |
| DEPRECATED_EFFECTIVE_CONNECTION_TYPE_AMBIGUOUS = 1 [deprecated = true]; | |
| EFFECTIVE_CONNECTION_TYPE_OFFLINE = 2; | |
| EFFECTIVE_CONNECTION_TYPE_SLOW_2G = 3; | |
| EFFECTIVE_CONNECTION_TYPE_2G = 4; | |
| EFFECTIVE_CONNECTION_TYPE_3G = 5; | |
| EFFECTIVE_CONNECTION_TYPE_4G = 6; | |
| } | |
| // Deprecated: The connection type according to | |
| // net::NetworkQualityEstimator. EffectiveConnectionType is the connection | |
| // type whose typical performance is most similar to the measured | |
| // performance of the network in use. In many cases, the "effective" | |
| // connection type and the actual type of connection in use are the same, | |
| // but often a network connection performs significantly differently, | |
| // usually worse, from its expected capabilities. | |
| optional EffectiveConnectionType deprecated_effective_connection_type = 6 | |
| [deprecated = true]; | |
| // The minimum and maximum values of the effective connection type enum | |
| // during the lifetime of the log according to net::NetworkQualityEstimator. | |
| // EffectiveConnectionType is the connection type whose typical performance | |
| // is most similar to the measured performance of the network in use. In | |
| // many cases, the "effective" connection type and the actual type of | |
| // connection in use are the same, but often a network connection performs | |
| // significantly differently, usually worse, from its expected capabilities. | |
| optional EffectiveConnectionType min_effective_connection_type = 7; | |
| optional EffectiveConnectionType max_effective_connection_type = 8; | |
| } | |
| optional Network network = 13; | |
| // Information on the Google Update install that is managing this client. | |
| message GoogleUpdate { | |
| // Whether the Google Update install is system-level or user-level. | |
| optional bool is_system_install = 1; | |
| // The date at which Google Update last started performing an automatic | |
| // update check, in seconds since the Unix epoch. | |
| optional int64 last_automatic_start_timestamp = 2; | |
| // The date at which Google Update last successfully sent an update check | |
| // and received an intact response from the server, in seconds since the | |
| // Unix epoch. (The updates don't need to be successfully installed.) | |
| optional int64 last_update_check_timestamp = 3; | |
| // Describes a product being managed by Google Update. (This can also | |
| // describe Google Update itself.) | |
| message ProductInfo { | |
| // The current version of the product that is installed. | |
| optional string version = 1; | |
| // The date at which Google Update successfully updated this product, | |
| // stored in seconds since the Unix epoch. This is updated when an update | |
| // is successfully applied, or if the server reports that no update | |
| // is available. | |
| optional int64 last_update_success_timestamp = 2; | |
| // The result reported by the product updater on its last run. | |
| enum InstallResult { | |
| INSTALL_RESULT_SUCCESS = 0; | |
| INSTALL_RESULT_FAILED_CUSTOM_ERROR = 1; | |
| INSTALL_RESULT_FAILED_MSI_ERROR = 2; | |
| INSTALL_RESULT_FAILED_SYSTEM_ERROR = 3; | |
| INSTALL_RESULT_EXIT_CODE = 4; | |
| } | |
| optional InstallResult last_result = 3; | |
| // The error code reported by the product updater on its last run. This | |
| // will typically be a error code specific to the product installer. | |
| optional int32 last_error = 4; | |
| // The extra error code reported by the product updater on its last run. | |
| // This will typically be a Win32 error code. | |
| optional int32 last_extra_error = 5; | |
| } | |
| optional ProductInfo google_update_status = 4; | |
| optional ProductInfo client_status = 5; | |
| } | |
| optional GoogleUpdate google_update = 11; | |
| // Information on all installed plugins. | |
| message Plugin { | |
| // The plugin's self-reported name and filename (without path). | |
| optional string name = 1; | |
| optional string filename = 2; | |
| // The plugin's version. | |
| optional string version = 3; | |
| // True if the plugin is disabled. | |
| // If a client has multiple local Chrome user accounts, this is logged based | |
| // on the first user account launched during the current session. | |
| optional bool is_disabled = 4; | |
| // True if the plugin is PPAPI. | |
| optional bool is_pepper = 5; | |
| } | |
| repeated Plugin plugin = 7; | |
| // Figures that can be used to generate application stability metrics. | |
| // All values are counts of events since the last time that these | |
| // values were reported. | |
| // Next tag: 29 | |
| message Stability { | |
| // Total amount of time that the program was running, in seconds, | |
| // since the last time a log was recorded, as measured using a client-side | |
| // clock implemented via TimeTicks, which guarantees that it is monotonic | |
| // and does not jump if the user changes their clock. The TimeTicks | |
| // implementation also makes the clock not count time the computer is | |
| // suspended. | |
| optional int64 incremental_uptime_sec = 1; | |
| // Total amount of time that the program was running, in seconds, | |
| // since startup, as measured using a client-side clock implemented | |
| // via TimeTicks, which guarantees that it is monotonic and does not | |
| // jump if the user changes their clock. The TimeTicks implementation | |
| // also makes the clock not count time the computer is suspended. | |
| // This field was added for M-35. | |
| optional int64 uptime_sec = 23; | |
| // Page loads along with renderer launches, crashes, hangs and failed | |
| // launches, since page load count roughly corresponds to usage. | |
| optional int32 page_load_count = 2; | |
| optional int32 renderer_crash_count = 3; | |
| optional int32 renderer_hang_count = 4; | |
| optional int32 renderer_failed_launch_count = 24; | |
| optional int32 renderer_launch_count = 26; | |
| // Number of renderer launches, crashes and failed launches that were for | |
| // extensions. These are not counted in the renderer counts above. | |
| optional int32 extension_renderer_crash_count = 5; | |
| optional int32 extension_renderer_failed_launch_count = 25; | |
| optional int32 extension_renderer_launch_count = 27; | |
| // Number of non-renderer child process crashes. | |
| optional int32 child_process_crash_count = 6; | |
| // Number of times the browser has crashed while logged in as the "other | |
| // user" (guest) account. | |
| // Logged on ChromeOS only. | |
| optional int32 other_user_crash_count = 7; | |
| // Number of times the kernel has crashed. | |
| // Logged on ChromeOS only. | |
| optional int32 kernel_crash_count = 8; | |
| // Number of times the system has shut down uncleanly. | |
| // Logged on ChromeOS only. | |
| optional int32 unclean_system_shutdown_count = 9; | |
| // | |
| // All the remaining fields in the Stability are recorded at most once per | |
| // client session. | |
| // | |
| // The number of times the program was launched. | |
| // This will typically be equal to 1. However, it is possible that Chrome | |
| // was unable to upload stability metrics for previous launches (e.g. due to | |
| // crashing early during startup), and hence this value might be greater | |
| // than 1. | |
| optional int32 launch_count = 15; | |
| // The number of times that it didn't exit cleanly (which we assume to be | |
| // mostly crashes). | |
| optional int32 crash_count = 16; | |
| // Android only. The number of times Chrome didn't exit cleanly and the GMS | |
| // Core version had not changed from the last session. This is a subset of | |
| // |crash_count| where we exclude unclean exits that are likely caused by | |
| // GMS Core updates. | |
| optional int32 crash_count_without_gms_core_update = 28; | |
| // The number of times the program began, but did not complete, the shutdown | |
| // process. (For example, this may occur when Windows is shutting down, and | |
| // it only gives the process a few seconds to clean up.) | |
| optional int32 incomplete_shutdown_count = 17; | |
| // The number of times the program was able register with breakpad crash | |
| // services. | |
| optional int32 breakpad_registration_success_count = 18; | |
| // The number of times the program failed to register with breakpad crash | |
| // services. If crash registration fails then when the program crashes no | |
| // crash report will be generated. | |
| optional int32 breakpad_registration_failure_count = 19; | |
| // The number of times the program has run under a debugger. This should | |
| // be an exceptional condition. Running under a debugger prevents crash | |
| // dumps from being generated. | |
| optional int32 debugger_present_count = 20; | |
| // The number of times the program has run without a debugger attached. | |
| // This should be most common scenario and should be very close to | |
| // |launch_count|. | |
| optional int32 debugger_not_present_count = 21; | |
| // Stability information for all installed plugins. | |
| message PluginStability { | |
| // The relevant plugin's information (name, etc.) | |
| optional Plugin plugin = 1; | |
| // The number of times this plugin's process was launched. | |
| optional int32 launch_count = 2; | |
| // The number of times this plugin was instantiated on a web page. | |
| // This will be >= |launch_count|. | |
| // (A page load with multiple sections drawn by this plugin will | |
| // increase this count multiple times.) | |
| optional int32 instance_count = 3; | |
| // The number of times this plugin process crashed. | |
| // This value will be <= |launch_count|. | |
| optional int32 crash_count = 4; | |
| // The number of times this plugin could not be loaded. | |
| optional int32 loading_error_count = 5; | |
| } | |
| repeated PluginStability plugin_stability = 22; | |
| } | |
| optional Stability stability = 8; | |
| // Description of a field trial or experiment that the user is currently | |
| // enrolled in. | |
| // All metrics reported in this upload can potentially be influenced by the | |
| // field trial. | |
| message FieldTrial { | |
| // The name of the field trial, as a 32-bit identifier. | |
| // Currently, the identifier is a hash of the field trial's name. | |
| optional fixed32 name_id = 1; | |
| // The user's group within the field trial, as a 32-bit identifier. | |
| // Currently, the identifier is a hash of the group's name. | |
| optional fixed32 group_id = 2; | |
| } | |
| repeated FieldTrial field_trial = 9; | |
| // Information about the A/V output device(s) (typically just a TV). | |
| // However, a configuration may have one or more intermediate A/V devices | |
| // between the source device and the TV (e.g. an A/V receiver, video | |
| // processor, etc.). | |
| message ExternalAudioVideoDevice { | |
| // The manufacturer name (possibly encoded as a 3-letter code, e.g. "YMH" | |
| // for Yamaha). | |
| optional string manufacturer_name = 1; | |
| // The model name (e.g. "RX-V1900"). Some devices may report generic names | |
| // like "receiver" or use the full manufacturer name (e.g "PHILIPS"). | |
| optional string model_name = 2; | |
| // The product code (e.g. "0218"). | |
| optional string product_code = 3; | |
| // The device types. A single device can have multiple types (e.g. a set-top | |
| // box could be both a tuner and a player). The same type may even be | |
| // repeated (e.g a device that reports two tuners). | |
| enum AVDeviceType { | |
| AV_DEVICE_TYPE_UNKNOWN = 0; | |
| AV_DEVICE_TYPE_TV = 1; | |
| AV_DEVICE_TYPE_RECORDER = 2; | |
| AV_DEVICE_TYPE_TUNER = 3; | |
| AV_DEVICE_TYPE_PLAYER = 4; | |
| AV_DEVICE_TYPE_AUDIO_SYSTEM = 5; | |
| } | |
| repeated AVDeviceType av_device_type = 4; | |
| // The year of manufacture. | |
| optional int32 manufacture_year = 5; | |
| // The week of manufacture. | |
| // Note: per the Wikipedia EDID article, numbering for this field may not | |
| // be consistent between manufacturers. | |
| optional int32 manufacture_week = 6; | |
| // Selected horizontal resolution in pixels. | |
| optional int32 horizontal_resolution = 7; | |
| // Selected vertical resolution in pixels. | |
| optional int32 vertical_resolution = 8; | |
| // Audio capabilities of the device. | |
| // Ref: http://en.wikipedia.org/wiki/Extended_display_identification_data | |
| // Next tag: 7 | |
| message AudioDescription { | |
| // Audio format | |
| enum AudioFormat { | |
| AUDIO_FORMAT_UNKNOWN = 0; | |
| AUDIO_FORMAT_LPCM = 1; | |
| AUDIO_FORMAT_AC_3 = 2; | |
| AUDIO_FORMAT_MPEG1 = 3; | |
| AUDIO_FORMAT_MP3 = 4; | |
| AUDIO_FORMAT_MPEG2 = 5; | |
| AUDIO_FORMAT_AAC = 6; | |
| AUDIO_FORMAT_DTS = 7; | |
| AUDIO_FORMAT_ATRAC = 8; | |
| AUDIO_FORMAT_ONE_BIT = 9; | |
| AUDIO_FORMAT_DD_PLUS = 10; | |
| AUDIO_FORMAT_DTS_HD = 11; | |
| AUDIO_FORMAT_MLP_DOLBY_TRUEHD = 12; | |
| AUDIO_FORMAT_DST_AUDIO = 13; | |
| AUDIO_FORMAT_MICROSOFT_WMA_PRO = 14; | |
| } | |
| optional AudioFormat audio_format = 1; | |
| // Number of channels (e.g. 1, 2, 8, etc.). | |
| optional int32 num_channels = 2; | |
| // Supported sample frequencies in Hz (e.g. 32000, 44100, etc.). | |
| // Multiple frequencies may be specified. | |
| repeated int32 sample_frequency_hz = 3; | |
| // Maximum bit rate in bits/s. | |
| optional int32 max_bit_rate_per_second = 4; | |
| // Bit depth (e.g. 16, 20, 24, etc.). | |
| optional int32 bit_depth = 5; | |
| // Output mode: analog vs digital. | |
| enum OutputMode { | |
| ANALOG = 0; | |
| DIGITAL = 1; | |
| } | |
| optional OutputMode output_mode = 6; | |
| } | |
| repeated AudioDescription audio_description = 9; | |
| // The position in AV setup. | |
| // A value of 0 means this device is the TV. | |
| // A value of 1 means this device is directly connected to one of | |
| // the TV's inputs. | |
| // Values > 1 indicate there are 1 or more devices between this device | |
| // and the TV. | |
| optional int32 position_in_setup = 10; | |
| // Whether this device is in the path to the TV. | |
| optional bool is_in_path_to_tv = 11; | |
| // The CEC version the device supports. | |
| // CEC stands for Consumer Electronics Control, a part of the HDMI | |
| // specification. Not all HDMI devices support CEC. | |
| // Only devices that support CEC will report a value here. | |
| optional int32 cec_version = 12; | |
| // This message reports CEC commands seen by a device. | |
| // After each log is sent, this information is cleared and gathered again. | |
| // By collecting CEC status information by opcode we can determine | |
| // which CEC features can be supported. | |
| message CECCommand { | |
| // The CEC command opcode. CEC supports up to 256 opcodes. | |
| // We add only one CECCommand message per unique opcode. Only opcodes | |
| // seen by the device will be reported. The remainder of the message | |
| // accumulates status for this opcode (and device). | |
| optional int32 opcode = 1; | |
| // The total number of commands received from the external device. | |
| optional int32 num_received_direct = 2; | |
| // The number of commands received from the external device as part of a | |
| // broadcast message. | |
| optional int32 num_received_broadcast = 3; | |
| // The total number of commands sent to the external device. | |
| optional int32 num_sent_direct = 4; | |
| // The number of commands sent to the external device as part of a | |
| // broadcast message. | |
| optional int32 num_sent_broadcast = 5; | |
| // The number of aborted commands for unknown reasons. | |
| optional int32 num_aborted_unknown_reason = 6; | |
| // The number of aborted commands because of an unrecognized opcode. | |
| optional int32 num_aborted_unrecognized = 7; | |
| } | |
| repeated CECCommand cec_command = 13; | |
| // Selected Frame rate | |
| optional int32 frame_rate = 14; | |
| // Selected color encoding. | |
| enum ColorEncoding { | |
| COLOR_ENCODING_UNKNOWN = 0; | |
| COLOR_ENCODING_RGB = 1; | |
| COLOR_ENCODING_YUV444 = 2; | |
| COLOR_ENCODING_YUV422 = 3; | |
| COLOR_ENCODING_YUV420 = 4; | |
| } | |
| optional ColorEncoding color_encoding = 15; | |
| // Selected bit-depth. | |
| optional int32 bit_depth = 16; | |
| // Devices's max TMDS char rate. | |
| optional int32 tmds = 17; | |
| // HDR10 support. | |
| optional bool hdr10_support = 18; | |
| // Dolby vision support. | |
| optional bool dolby_vision_support = 19; | |
| // Supported EOTF's. | |
| // EOTF support according to the spec: | |
| // eotf_support & 0x1 -> SDR supported | |
| // (eotf_support > 1) & 0x1 -> traditional HDR supported | |
| // (eotf_support > 2) & 0x1 -> ST2084 supported | |
| optional int32 eotf_support = 20; | |
| // Supports YUV. | |
| optional bool yuv_support = 21; | |
| // Supports YUV_420. | |
| optional bool yuv_420_support = 22; | |
| // The maximum HDCP version supported by the sink. | |
| optional int32 maximum_supported_hdcp_version = 23; | |
| // The current HDCP version negotiated with the sink. | |
| optional int32 current_hdcp_version = 24; | |
| } | |
| repeated ExternalAudioVideoDevice external_audio_video_device = 14; | |
| // Information about the current wireless access point. Collected directly | |
| // from the wireless access point via standard apis if the device is | |
| // connected to the Internet wirelessly. Introduced for Chrome on TV devices | |
| // but also can be collected by ChromeOS, Android or other clients. | |
| message ExternalAccessPoint { | |
| // The manufacturer name, for example "ASUSTeK Computer Inc.". | |
| optional string manufacturer = 1; | |
| // The model name, for example "Wi-Fi Protected Setup Router". | |
| optional string model_name = 2; | |
| // The model number, for example "RT-N16". | |
| optional string model_number = 3; | |
| // The device name (sometime same as model_number), for example "RT-N16". | |
| optional string device_name = 4; | |
| // The organizationally unique identifier, for example "08:9E:08". | |
| // OUI is the highest three bytes of MAC address | |
| // Google's OUI (08:9E:08) is encoded as 0x00089E08 | |
| // Never recorded server side, but some old clients may send values with | |
| // this tag. | |
| reserved 5; | |
| } | |
| optional ExternalAccessPoint external_access_point = 15; | |
| // Number of users currently signed into a multiprofile session. | |
| // A zero value indicates that the user count changed while the log is open. | |
| // Logged only on ChromeOS. | |
| optional uint32 multi_profile_user_count = 17; | |
| // Information about extensions that are installed, masked to provide better | |
| // privacy. Only extensions from a single profile are reported; this will | |
| // generally be the profile used when the browser is started. The profile | |
| // reported on will remain consistent at least until the browser is | |
| // relaunched (or the profile is deleted by the user). | |
| // | |
| // Each client first picks a value for client_key derived from its UMA | |
| // client_id: | |
| // client_key = client_id % 4096 | |
| // Then, each installed extension is mapped into a hash bucket according to | |
| // bucket = CityHash64(StringPrintf("%d:%s", | |
| // client_key, extension_id)) % 1024 | |
| // The client reports the set of hash buckets occupied by all installed | |
| // extensions. If multiple extensions map to the same bucket, that bucket is | |
| // still only reported once. | |
| repeated int32 occupied_extension_bucket = 18; | |
| // The state of loaded extensions for this system. The system can have either | |
| // no applicable extensions, extensions only from the webstore and verified by | |
| // the webstore, extensions only from the webstore but not verified, or | |
| // extensions not from the store. If there is a single off-store extension, | |
| // then HAS_OFFSTORE is reported. This should be kept in sync with the | |
| // corresponding enum in chrome/browser/metrics/extensions_metrics_provider.cc | |
| enum ExtensionsState { | |
| NO_EXTENSIONS = 0; | |
| NO_OFFSTORE_VERIFIED = 1; | |
| NO_OFFSTORE_UNVERIFIED = 2; | |
| HAS_OFFSTORE = 3; | |
| } | |
| optional ExtensionsState offstore_extensions_state = 19; | |
| // The nature of the choice the user was given concerning metrics recording. | |
| // Specifically, whether the enable metrics/crash reporting checkbox that was | |
| // shown on first run was checked or unchecked by default. | |
| // This state is recorded on first run, and uploaded in every UMA log. | |
| // Consequently this should only be defined for clients that were installed | |
| // after the recording code was implemented. | |
| enum UmaDefaultState { | |
| // The enable checkbox was unchecked by default. | |
| OPT_IN = 0; | |
| // The enable checkbox was checked by default. | |
| OPT_OUT = 1; | |
| // Policy mandated that UMA be enabled, the user had no choice. | |
| POLICY_FORCED_ENABLED = 2; | |
| } | |
| optional UmaDefaultState uma_default_state = 22; | |
| enum AntiVirusState { | |
| // The security product software is turned on and protecting the user. | |
| STATE_ON = 0; | |
| // The security product software is turned off and protection is disabled. | |
| STATE_OFF = 1; | |
| // The security product software is in the snoozed state, temporarily off, | |
| // and not actively protecting the computer. | |
| STATE_SNOOZED = 2; | |
| // The security product software has expired and is no longer actively | |
| // protecting the computer. | |
| STATE_EXPIRED = 3; | |
| } | |
| // Information about AntiVirus products installed. | |
| // Next Tag: 6 | |
| message AntiVirusProduct { | |
| // The product name e.g. "System Center Endpoint Protection". This might not | |
| // be recorded, see ShouldReportFullNames() in | |
| // chrome/browser/metrics/antivirus_metrics_provider_win.cc. | |
| optional string product_name = 1; | |
| // The hash of the product name. | |
| optional fixed32 product_name_hash = 2; | |
| // The version of the product, as read from the file information. This might | |
| // not be recorded, see ShouldReportFullNames() in | |
| // chrome/browser/metrics/antivirus_metrics_provider_win.cc. | |
| optional string product_version = 3; | |
| // The hash of the product version. Might not be set if the product version | |
| // could not be obtained from the disk. | |
| optional fixed32 product_version_hash = 4; | |
| // The current state of the product. | |
| optional AntiVirusState product_state = 5; | |
| } | |
| repeated AntiVirusProduct antivirus_product = 23; | |
| enum ComponentId { | |
| // The client transmitted a component ID the server does not recognize. | |
| UNKNOWN = 1; | |
| // All the following are various components. | |
| FILE_TYPE_POLICIES = 2; | |
| ORIGIN_TRIALS = 3; | |
| PEPPER_FLASH = 4; | |
| PEPPER_FLASH_CHROMEOS = 5; | |
| PNACL = 6; | |
| RECOVERY = 7; | |
| SSL_ERROR_ASSISTANT = 8; | |
| STH_SET = 9; | |
| CRL_SET = 10; | |
| SUBRESOURCE_FILTER = 11; | |
| SW_REPORTER = 12; | |
| WIDEVINE_CDM = 13; | |
| EPSON_INKJET_PRINTER_ESCPR = 14; | |
| CROS_TERMINA = 15; | |
| STAR_CUPS_DRIVER = 16; | |
| SPEECH_SYNTHESIS_SV_SE = 17; | |
| OPTIMIZATION_HINTS = 18; | |
| DOWNLOADABLE_STRINGS = 19; | |
| VR_ASSETS = 20; | |
| RTANALYTICS_LIGHT = 21; | |
| RTANALYTICS_FULL = 22; | |
| CELLULAR = 23; | |
| DEMO_MODE_RESOURCES = 24; | |
| } | |
| // Information about what Chrome components are registered and at which | |
| // version. | |
| // Next Tag: 4 | |
| message ChromeComponent { | |
| // Which component this information is for. | |
| optional ComponentId component_id = 1 [default = UNKNOWN]; | |
| // Human-readable dotted-quad representation of the currently-installed | |
| // version of the component, e.g. "1.2.3.4". | |
| optional string version = 2; | |
| // The first 32 bits of the Omaha-style fingerprint of the installed | |
| // component, discarding any bits that describe the fingerprint format. In | |
| // practice this is the first 32 bits of the SHA256 hash of the package that | |
| // was installed as the component. It is a stronger version number that can | |
| // vary across platform, architecture, or branches of an A/B component test. | |
| optional fixed32 omaha_fingerprint = 3; | |
| } | |
| repeated ChromeComponent chrome_component = 24; | |
| // Information about the user's installed extensions. This will include | |
| // extensions from all fully-initialized profiles. If a single extension is | |
| // installed in multiple profiles, it will be recorded multiple times. | |
| repeated ExtensionInstallProto extension_install = 25; | |
| // The Chrome package name on Android, if it's different from | |
| // "com.android.chrome". | |
| optional string app_package_name = 26; | |
| } |