xref: /system/core/metricsd/uploader/proto/system_profile.proto

/*
 * Copyright (C) 2015 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
//
// Stores information about the user's brower and system configuration.
// The system configuration fields are recorded once per client session.

syntax = "proto2";

option optimize_for = LITE_RUNTIME;
option java_outer_classname = "SystemProfileProtos";
option java_package = "org.chromium.components.metrics";

package metrics;

// Next tag: 21
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.
  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;

  message BrilloDeviceData {
    optional string product_id = 1;
  }
  optional BrilloDeviceData brillo = 21;

  // Information on the user's operating system.
  message OS {
    // The user's operating system. This should be one of:
    // - Android
    // - Windows NT
    // - Linux (includes ChromeOS)
    // - iPhone OS
    // - 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 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;
  }
  optional OS os = 5;

  // Next tag for Hardware: 18
  // Information on the user's hardware.
  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 Chrome OS device hardware class ID 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 hardware_class = 4;

    // 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.
      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.
    message TouchScreen {
      // 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.
    repeated TouchScreen external_touchscreen = 15;

    // 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.
  message Network {
    // Set to true if connection_type changed during the lifetime of the log.
    optional bool connection_type_is_ambiguous = 1;

    // See net::NetworkChangeNotifier::ConnectionType.
    enum ConnectionType {
      CONNECTION_UNKNOWN = 0;
      CONNECTION_ETHERNET = 1;
      CONNECTION_WIFI = 2;
      CONNECTION_2G = 3;
      CONNECTION_3G = 4;
      CONNECTION_4G = 5;
      CONNECTION_BLUETOOTH = 6;
    }
    // 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 seurity 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 AP that device is connected to.
    optional WifiAccessPoint access_point_info = 5;
  }
  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 recieved 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: 24
  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 his/her 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 his/her 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 crashes and hangs, 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;

    // Number of renderer crashes that were for extensions. These crashes are
    // not counted in renderer_crash_count.
    optional int32 extension_renderer_crash_count = 5;

    // 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;

    // 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;

    // Max horizontal resolution in pixels.
    optional int32 horizontal_resolution = 7;

    // Max vertical resolution in pixels.
    optional int32 vertical_resolution = 8;

    // Audio capabilities of the device.
    // Ref: http://en.wikipedia.org/wiki/Extended_display_identification_data
    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;
    }
    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;
  }
  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;
  }
  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;
}