Home | History | Annotate | Download | only in shill 
      1 //
      2 // Copyright (C) 2012 The Android Open Source Project
      3 //
      4 // Licensed under the Apache License, Version 2.0 (the "License");
      5 // you may not use this file except in compliance with the License.
      6 // You may obtain a copy of the License at
      7 //
      8 //      http://www.apache.org/licenses/LICENSE-2.0
      9 //
     10 // Unless required by applicable law or agreed to in writing, software
     11 // distributed under the License is distributed on an "AS IS" BASIS,
     12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13 // See the License for the specific language governing permissions and
     14 // limitations under the License.
     15 //
     16 
     17 #ifndef SHILL_METRICS_H_
     18 #define SHILL_METRICS_H_
     19 
     20 #include <list>
     21 #include <map>
     22 #include <memory>
     23 #include <string>
     24 
     25 #include <base/memory/scoped_vector.h>
     26 #include <metrics/metrics_library.h>
     27 #include <metrics/timer.h>
     28 
     29 #include "shill/connectivity_trial.h"
     30 #include "shill/event_dispatcher.h"
     31 #include "shill/portal_detector.h"
     32 #include "shill/power_manager.h"
     33 #include "shill/refptr_types.h"
     34 #include "shill/service.h"
     35 
     36 #if !defined(DISABLE_WIFI)
     37 #include "shill/net/ieee80211.h"
     38 #include "shill/wifi/wake_on_wifi.h"
     39 #endif  // DISABLE_WIFI
     40 
     41 namespace shill {
     42 
     43 class Metrics {
     44  public:
     45   enum WiFiChannel {
     46     kWiFiChannelUndef = 0,
     47     kWiFiChannel2412 = 1,
     48     kWiFiChannel2417 = 2,
     49     kWiFiChannel2422 = 3,
     50     kWiFiChannel2427 = 4,
     51     kWiFiChannel2432 = 5,
     52     kWiFiChannel2437 = 6,
     53     kWiFiChannel2442 = 7,
     54     kWiFiChannel2447 = 8,
     55     kWiFiChannel2452 = 9,
     56     kWiFiChannel2457 = 10,
     57     kWiFiChannel2462 = 11,
     58     kWiFiChannel2467 = 12,
     59     kWiFiChannel2472 = 13,
     60     kWiFiChannel2484 = 14,
     61 
     62     kWiFiChannel5180 = 15,
     63     kWiFiChannel5200 = 16,
     64     kWiFiChannel5220 = 17,
     65     kWiFiChannel5240 = 18,
     66     kWiFiChannel5260 = 19,
     67     kWiFiChannel5280 = 20,
     68     kWiFiChannel5300 = 21,
     69     kWiFiChannel5320 = 22,
     70 
     71     kWiFiChannel5500 = 23,
     72     kWiFiChannel5520 = 24,
     73     kWiFiChannel5540 = 25,
     74     kWiFiChannel5560 = 26,
     75     kWiFiChannel5580 = 27,
     76     kWiFiChannel5600 = 28,
     77     kWiFiChannel5620 = 29,
     78     kWiFiChannel5640 = 30,
     79     kWiFiChannel5660 = 31,
     80     kWiFiChannel5680 = 32,
     81     kWiFiChannel5700 = 33,
     82 
     83     kWiFiChannel5745 = 34,
     84     kWiFiChannel5765 = 35,
     85     kWiFiChannel5785 = 36,
     86     kWiFiChannel5805 = 37,
     87     kWiFiChannel5825 = 38,
     88 
     89     kWiFiChannel5170 = 39,
     90     kWiFiChannel5190 = 40,
     91     kWiFiChannel5210 = 41,
     92     kWiFiChannel5230 = 42,
     93 
     94     /* NB: ignore old 11b bands 2312..2372 and 2512..2532 */
     95     /* NB: ignore regulated bands 4920..4980 and 5020..5160 */
     96     kWiFiChannelMax
     97   };
     98 
     99   enum WiFiNetworkPhyMode {
    100     kWiFiNetworkPhyModeUndef = 0,    // Unknown/undefined
    101     kWiFiNetworkPhyMode11a = 1,      // 802.11a
    102     kWiFiNetworkPhyMode11b = 2,      // 802.11b
    103     kWiFiNetworkPhyMode11g = 3,      // 802.11g
    104     kWiFiNetworkPhyMode11n = 4,      // 802.11n
    105     kWiFiNetworkPhyModeHalf = 5,     // PSB Half-width
    106     kWiFiNetworkPhyModeQuarter = 6,  // PSB Quarter-width
    107     kWiFiNetworkPhyMode11ac = 7,     // 802.11ac
    108 
    109     kWiFiNetworkPhyModeMax
    110   };
    111 
    112   enum EapOuterProtocol {
    113     kEapOuterProtocolUnknown = 0,
    114     kEapOuterProtocolLeap = 1,
    115     kEapOuterProtocolPeap = 2,
    116     kEapOuterProtocolTls = 3,
    117     kEapOuterProtocolTtls = 4,
    118 
    119     kEapOuterProtocolMax
    120   };
    121 
    122   enum EapInnerProtocol {
    123     kEapInnerProtocolUnknown = 0,
    124     kEapInnerProtocolNone = 1,
    125     kEapInnerProtocolPeapMd5 = 2,
    126     kEapInnerProtocolPeapMschapv2 = 3,
    127     kEapInnerProtocolTtlsEapMd5 = 4,
    128     kEapInnerProtocolTtlsEapMschapv2 = 5,
    129     kEapInnerProtocolTtlsMschapv2 = 6,
    130     kEapInnerProtocolTtlsMschap = 7,
    131     kEapInnerProtocolTtlsPap = 8,
    132     kEapInnerProtocolTtlsChap = 9,
    133 
    134     kEapInnerProtocolMax
    135   };
    136 
    137   enum WiFiSecurity {
    138     kWiFiSecurityUnknown = 0,
    139     kWiFiSecurityNone = 1,
    140     kWiFiSecurityWep = 2,
    141     kWiFiSecurityWpa = 3,
    142     kWiFiSecurityRsn = 4,
    143     kWiFiSecurity8021x = 5,
    144     kWiFiSecurityPsk = 6,
    145 
    146     kWiFiSecurityMax
    147   };
    148 
    149   enum WiFiApMode {
    150     kWiFiApModeUnknown = 0,
    151     kWiFiApModeManaged = 1,
    152     kWiFiApModeAdHoc = 2,
    153 
    154     kWiFiApModeMax
    155   };
    156 
    157   enum PortalResult {
    158     kPortalResultSuccess = 0,
    159     kPortalResultDNSFailure = 1,
    160     kPortalResultDNSTimeout = 2,
    161     kPortalResultConnectionFailure = 3,
    162     kPortalResultConnectionTimeout = 4,
    163     kPortalResultHTTPFailure = 5,
    164     kPortalResultHTTPTimeout = 6,
    165     kPortalResultContentFailure = 7,
    166     kPortalResultContentTimeout = 8,
    167     kPortalResultUnknown = 9,
    168 
    169     kPortalResultMax
    170   };
    171 
    172   enum LinkMonitorFailure {
    173     kLinkMonitorMacAddressNotFound = 0,
    174     kLinkMonitorClientStartFailure = 1,
    175     kLinkMonitorTransmitFailure = 2,
    176     kLinkMonitorFailureThresholdReached = 3,
    177 
    178     kLinkMonitorFailureMax
    179   };
    180 
    181   enum WiFiStatusType {
    182     kStatusCodeTypeByAp,
    183     kStatusCodeTypeByClient,
    184     kStatusCodeTypeByUser,
    185     kStatusCodeTypeConsideredDead,
    186     kStatusCodeTypeMax
    187   };
    188 
    189   enum WiFiDisconnectByWhom {
    190     kDisconnectedByAp,
    191     kDisconnectedNotByAp
    192   };
    193 
    194   enum WiFiScanResult {
    195     kScanResultProgressiveConnected,
    196     kScanResultProgressiveErrorAndFullFoundNothing,
    197     kScanResultProgressiveErrorButFullConnected,
    198     kScanResultProgressiveAndFullFoundNothing,
    199     kScanResultProgressiveAndFullConnected,
    200     kScanResultFullScanFoundNothing,
    201     kScanResultFullScanConnected,
    202     kScanResultInternalError,
    203     kScanResultMax
    204   };
    205 
    206   enum ServiceFixupProfileType {
    207     kMetricServiceFixupDefaultProfile,
    208     kMetricServiceFixupUserProfile,
    209     kMetricServiceFixupMax
    210   };
    211 
    212   enum TerminationActionResult {
    213     kTerminationActionResultSuccess,
    214     kTerminationActionResultFailure,
    215     kTerminationActionResultMax
    216   };
    217 
    218   enum SuspendActionResult {
    219     kSuspendActionResultSuccess,
    220     kSuspendActionResultFailure,
    221     kSuspendActionResultMax
    222   };
    223 
    224   enum DarkResumeActionResult {
    225     kDarkResumeActionResultSuccess,
    226     kDarkResumeActionResultFailure,
    227     kDarkResumeActionResultMax
    228   };
    229 
    230   enum DarkResumeUnmatchedScanResultReceived {
    231     kDarkResumeUnmatchedScanResultsReceivedFalse = 0,
    232     kDarkResumeUnmatchedScanResultsReceivedTrue = 1,
    233     kDarkResumeUnmatchedScanResultsReceivedMax
    234   };
    235 
    236   enum VerifyWakeOnWiFiSettingsResult {
    237     kVerifyWakeOnWiFiSettingsResultSuccess,
    238     kVerifyWakeOnWiFiSettingsResultFailure,
    239     kVerifyWakeOnWiFiSettingsResultMax
    240   };
    241 
    242   enum WiFiConnectionStatusAfterWake {
    243     kWiFiConnetionStatusAfterWakeOnWiFiEnabledWakeConnected = 0,
    244     kWiFiConnetionStatusAfterWakeOnWiFiEnabledWakeNotConnected = 1,
    245     kWiFiConnetionStatusAfterWakeOnWiFiDisabledWakeConnected = 2,
    246     kWiFiConnetionStatusAfterWakeOnWiFiDisabledWakeNotConnected = 3,
    247     kWiFiConnetionStatusAfterWakeMax
    248   };
    249 
    250   enum Cellular3GPPRegistrationDelayedDrop {
    251     kCellular3GPPRegistrationDelayedDropPosted = 0,
    252     kCellular3GPPRegistrationDelayedDropCanceled = 1,
    253     kCellular3GPPRegistrationDelayedDropMax
    254   };
    255 
    256   enum CellularDropTechnology {
    257     kCellularDropTechnology1Xrtt = 0,
    258     kCellularDropTechnologyEdge = 1,
    259     kCellularDropTechnologyEvdo = 2,
    260     kCellularDropTechnologyGprs = 3,
    261     kCellularDropTechnologyGsm = 4,
    262     kCellularDropTechnologyHspa = 5,
    263     kCellularDropTechnologyHspaPlus = 6,
    264     kCellularDropTechnologyLte = 7,
    265     kCellularDropTechnologyUmts = 8,
    266     kCellularDropTechnologyUnknown = 9,
    267     kCellularDropTechnologyMax
    268   };
    269 
    270   enum CellularOutOfCreditsReason {
    271     kCellularOutOfCreditsReasonConnectDisconnectLoop = 0,
    272     kCellularOutOfCreditsReasonTxCongested = 1,
    273     kCellularOutOfCreditsReasonElongatedTimeWait = 2,
    274     kCellularOutOfCreditsReasonMax
    275   };
    276 
    277   enum CorruptedProfile {
    278     kCorruptedProfile = 1,
    279     kCorruptedProfileMax
    280   };
    281 
    282   enum ConnectionDiagnosticsIssue {
    283     kConnectionDiagnosticsIssueIPCollision = 0,
    284     kConnectionDiagnosticsIssueRouting = 1,
    285     kConnectionDiagnosticsIssueHTTPBrokenPortal = 2,
    286     kConnectionDiagnosticsIssueDNSServerMisconfig = 3,
    287     kConnectionDiagnosticsIssueDNSServerNoResponse = 4,
    288     kConnectionDiagnosticsIssueNoDNSServersConfigured = 5,
    289     kConnectionDiagnosticsIssueDNSServersInvalid = 6,
    290     kConnectionDiagnosticsIssueNone = 7,
    291     kConnectionDiagnosticsIssueCaptivePortal = 8,
    292     kConnectionDiagnosticsIssueGatewayUpstream = 9,
    293     kConnectionDiagnosticsIssueGatewayNotResponding = 10,
    294     kConnectionDiagnosticsIssueServerNotResponding = 11,
    295     kConnectionDiagnosticsIssueGatewayArpFailed = 12,
    296     kConnectionDiagnosticsIssueServerArpFailed = 13,
    297     kConnectionDiagnosticsIssueInternalError = 14,
    298     kConnectionDiagnosticsIssueGatewayNoNeighborEntry = 15,
    299     kConnectionDiagnosticsIssueServerNoNeighborEntry = 16,
    300     kConnectionDiagnosticsIssueGatewayNeighborEntryNotConnected = 17,
    301     kConnectionDiagnosticsIssueServerNeighborEntryNotConnected = 18,
    302     kConnectionDiagnosticsIssuePlaceholder1 = 19,
    303     kConnectionDiagnosticsIssuePlaceholder2 = 20,
    304     kConnectionDiagnosticsIssuePlaceholder3 = 21,
    305     kConnectionDiagnosticsIssuePlaceholder4 = 22,
    306     kConnectionDiagnosticsIssueMax
    307   };
    308 
    309   enum VpnDriver {
    310     kVpnDriverOpenVpn = 0,
    311     kVpnDriverL2tpIpsec = 1,
    312     kVpnDriverMax
    313   };
    314 
    315   enum VpnRemoteAuthenticationType {
    316     kVpnRemoteAuthenticationTypeOpenVpnDefault = 0,
    317     kVpnRemoteAuthenticationTypeOpenVpnCertificate = 1,
    318     kVpnRemoteAuthenticationTypeL2tpIpsecDefault = 2,
    319     kVpnRemoteAuthenticationTypeL2tpIpsecCertificate = 3,
    320     kVpnRemoteAuthenticationTypeL2tpIpsecPsk = 4,
    321     kVpnRemoteAuthenticationTypeMax
    322   };
    323 
    324   enum VpnUserAuthenticationType {
    325     kVpnUserAuthenticationTypeOpenVpnNone = 0,
    326     kVpnUserAuthenticationTypeOpenVpnCertificate = 1,
    327     kVpnUserAuthenticationTypeOpenVpnUsernamePassword = 2,
    328     kVpnUserAuthenticationTypeOpenVpnUsernamePasswordOtp = 3,
    329     kVpnUserAuthenticationTypeOpenVpnUsernameToken = 7,
    330     kVpnUserAuthenticationTypeL2tpIpsecNone = 4,
    331     kVpnUserAuthenticationTypeL2tpIpsecCertificate = 5,
    332     kVpnUserAuthenticationTypeL2tpIpsecUsernamePassword = 6,
    333     kVpnUserAuthenticationTypeMax
    334   };
    335 
    336   enum UserInitiatedEvent {
    337     kUserInitiatedEventWifiScan = 0,
    338     kUserInitiatedEventReserved,
    339     kUserInitiatedEventMax
    340   };
    341 
    342   enum UserInitiatedConnectionResult {
    343     kUserInitiatedConnectionResultSuccess = 0,
    344     kUserInitiatedConnectionResultFailure = 1,
    345     kUserInitiatedConnectionResultAborted = 2,
    346     kUserInitiatedConnectionResultMax
    347   };
    348 
    349   enum DNSTestResult {
    350     kFallbackDNSTestResultSuccess = 0,
    351     kFallbackDNSTestResultFailure,
    352     kFallbackDNSTestResultMax
    353   };
    354 
    355   // Network problem detected by traffic monitor.
    356   enum NetworkProblem {
    357     kNetworkProblemCongestedTCPTxQueue = 0,
    358     kNetworkProblemDNSFailure,
    359     kNetworkProblemMax
    360   };
    361 
    362   // Device's connection status.
    363   enum ConnectionStatus {
    364     kConnectionStatusOffline = 0,
    365     kConnectionStatusConnected = 1,
    366     kConnectionStatusOnline = 2,
    367     kConnectionStatusMax
    368   };
    369 
    370   enum UserInitiatedConnectionFailureReason {
    371     kUserInitiatedConnectionFailureReasonUnknown = 0,
    372     kUserInitiatedConnectionFailureReasonBadPassphrase = 1,
    373     kUserInitiatedConnectionFailureReasonBadWEPKey = 2,
    374     kUserInitiatedConnectionFailureReasonConnect = 3,
    375     kUserInitiatedConnectionFailureReasonDHCP = 4,
    376     kUserInitiatedConnectionFailureReasonDNSLookup = 5,
    377     kUserInitiatedConnectionFailureReasonEAPAuthentication = 6,
    378     kUserInitiatedConnectionFailureReasonEAPLocalTLS = 7,
    379     kUserInitiatedConnectionFailureReasonEAPRemoteTLS = 8,
    380     kUserInitiatedConnectionFailureReasonOutOfRange = 9,
    381     kUserInitiatedConnectionFailureReasonPinMissing = 10,
    382     kUserInitiatedConnectionFailureReasonMax
    383   };
    384 
    385   enum DhcpClientStatus {
    386     kDhcpClientStatusArpGateway = 0,
    387     kDhcpClientStatusArpSelf = 1,
    388     kDhcpClientStatusBound = 2,
    389     kDhcpClientStatusDiscover = 3,
    390     kDhcpClientStatusIgnoreAdditionalOffer = 4,
    391     kDhcpClientStatusIgnoreFailedOffer = 5,
    392     kDhcpClientStatusIgnoreInvalidOffer = 6,
    393     kDhcpClientStatusIgnoreNonOffer = 7,
    394     kDhcpClientStatusInform = 8,
    395     kDhcpClientStatusInit = 9,
    396     kDhcpClientStatusNakDefer = 10,
    397     kDhcpClientStatusRebind = 11,
    398     kDhcpClientStatusReboot = 12,
    399     kDhcpClientStatusRelease = 13,
    400     kDhcpClientStatusRenew = 14,
    401     kDhcpClientStatusRequest = 15,
    402     kDhcpClientStatusMax
    403   };
    404 
    405   enum NetworkConnectionIPType {
    406     kNetworkConnectionIPTypeIPv4 = 0,
    407     kNetworkConnectionIPTypeIPv6 = 1,
    408     kNetworkConnectionIPTypeMax
    409   };
    410 
    411   enum IPv6ConnectivityStatus {
    412     kIPv6ConnectivityStatusNo = 0,
    413     kIPv6ConnectivityStatusYes = 1,
    414     kIPv6ConnectivityStatusMax
    415   };
    416 
    417   enum DevicePresenceStatus {
    418     kDevicePresenceStatusNo = 0,
    419     kDevicePresenceStatusYes = 1,
    420     kDevicePresenceStatusMax
    421   };
    422 
    423   enum DeviceTechnologyType {
    424     kDeviceTechnologyTypeUnknown = 0,
    425     kDeviceTechnologyTypeEthernet = 1,
    426     kDeviceTechnologyTypeWifi = 2,
    427     kDeviceTechnologyTypeWimax = 3,
    428     kDeviceTechnologyTypeCellular = 4,
    429     kDeviceTechnologyTypeMax
    430   };
    431 
    432   enum NetworkServiceError {
    433     kNetworkServiceErrorUnknown = 0,
    434     kNetworkServiceErrorAAA = 1,
    435     kNetworkServiceErrorActivation = 2,
    436     kNetworkServiceErrorBadPassphrase = 3,
    437     kNetworkServiceErrorBadWEPKey = 4,
    438     kNetworkServiceErrorConnect = 5,
    439     kNetworkServiceErrorDHCP = 6,
    440     kNetworkServiceErrorDNSLookup = 7,
    441     kNetworkServiceErrorEAPAuthentication = 8,
    442     kNetworkServiceErrorEAPLocalTLS = 9,
    443     kNetworkServiceErrorEAPRemoteTLS = 10,
    444     kNetworkServiceErrorHTTPGet = 11,
    445     kNetworkServiceErrorIPSecCertAuth = 12,
    446     kNetworkServiceErrorIPSecPSKAuth = 13,
    447     kNetworkServiceErrorInternal = 14,
    448     kNetworkServiceErrorNeedEVDO = 15,
    449     kNetworkServiceErrorNeedHomeNetwork = 16,
    450     kNetworkServiceErrorOTASP = 17,
    451     kNetworkServiceErrorOutOfRange = 18,
    452     kNetworkServiceErrorPPPAuth = 19,
    453     kNetworkServiceErrorPinMissing = 20,
    454     kNetworkServiceErrorMax
    455   };
    456 
    457   enum WakeOnWiFiFeaturesEnabledState {
    458     kWakeOnWiFiFeaturesEnabledStateNone = 0,
    459     kWakeOnWiFiFeaturesEnabledStatePacket = 1,
    460     kWakeOnWiFiFeaturesEnabledStateDarkConnect = 2,
    461     kWakeOnWiFiFeaturesEnabledStatePacketDarkConnect = 3,
    462     kWakeOnWiFiFeaturesEnabledStateMax
    463   };
    464 
    465   enum WakeOnWiFiThrottled {
    466     kWakeOnWiFiThrottledFalse = 0,
    467     kWakeOnWiFiThrottledTrue = 1,
    468     kWakeOnWiFiThrottledMax
    469   };
    470 
    471   enum WakeReasonReceivedBeforeOnDarkResume {
    472     kWakeReasonReceivedBeforeOnDarkResumeFalse = 0,
    473     kWakeReasonReceivedBeforeOnDarkResumeTrue = 1,
    474     kWakeReasonReceivedBeforeOnDarkResumeMax
    475   };
    476 
    477   enum DarkResumeWakeReason {
    478     kDarkResumeWakeReasonUnsupported = 0,
    479     kDarkResumeWakeReasonPattern = 1,
    480     kDarkResumeWakeReasonDisconnect = 2,
    481     kDarkResumeWakeReasonSSID = 3,
    482     kDarkResumeWakeReasonMax
    483   };
    484 
    485   enum DarkResumeScanType {
    486     kDarkResumeScanTypeActive = 0,
    487     kDarkResumeScanTypePassive = 1,
    488     kDarkResumeScanTypeMax
    489   };
    490 
    491   enum DarkResumeScanRetryResult {
    492     kDarkResumeScanRetryResultNotConnected = 0,
    493     kDarkResumeScanRetryResultConnected = 1,
    494     kDarkResumeScanRetryResultMax
    495   };
    496 
    497   static const char kMetricDisconnectSuffix[];
    498   static const int kMetricDisconnectMax;
    499   static const int kMetricDisconnectMin;
    500   static const int kMetricDisconnectNumBuckets;
    501   static const char kMetricSignalAtDisconnectSuffix[];
    502   static const int kMetricSignalAtDisconnectMin;
    503   static const int kMetricSignalAtDisconnectMax;
    504   static const int kMetricSignalAtDisconnectNumBuckets;
    505   static const char kMetricNetworkApModeSuffix[];
    506   static const char kMetricNetworkChannelSuffix[];
    507   static const int kMetricNetworkChannelMax;
    508   static const char kMetricNetworkEapInnerProtocolSuffix[];
    509   static const int kMetricNetworkEapInnerProtocolMax;
    510   static const char kMetricNetworkEapOuterProtocolSuffix[];
    511   static const int kMetricNetworkEapOuterProtocolMax;
    512   static const char kMetricNetworkPhyModeSuffix[];
    513   static const int kMetricNetworkPhyModeMax;
    514   static const char kMetricNetworkSecuritySuffix[];
    515   static const int kMetricNetworkSecurityMax;
    516   static const char kMetricNetworkServiceErrors[];
    517   static const char kMetricNetworkSignalStrengthSuffix[];
    518   static const int kMetricNetworkSignalStrengthMin;
    519   static const int kMetricNetworkSignalStrengthMax;
    520   static const int kMetricNetworkSignalStrengthNumBuckets;
    521   // Histogram parameters for next two are the same as for
    522   // kMetricRememberedWiFiNetworkCount. Must be constexpr, for static
    523   // checking of format string. Must be defined inline, for constexpr.
    524   static constexpr char
    525       kMetricRememberedSystemWiFiNetworkCountBySecurityModeFormat[] =
    526       "Network.Shill.WiFi.RememberedSystemNetworkCount.%s";
    527   static constexpr char
    528       kMetricRememberedUserWiFiNetworkCountBySecurityModeFormat[] =
    529       "Network.Shill.WiFi.RememberedUserNetworkCount.%s";
    530   static const char kMetricRememberedWiFiNetworkCount[];
    531   static const int kMetricRememberedWiFiNetworkCountMin;
    532   static const int kMetricRememberedWiFiNetworkCountMax;
    533   static const int kMetricRememberedWiFiNetworkCountNumBuckets;
    534   static const char kMetricTimeOnlineSecondsSuffix[];
    535   static const int kMetricTimeOnlineSecondsMax;
    536   static const int kMetricTimeOnlineSecondsMin;
    537   static const int kMetricTimeOnlineSecondsNumBuckets;
    538   static const char kMetricTimeResumeToReadyMillisecondsSuffix[];
    539   static const char kMetricTimeToConfigMillisecondsSuffix[];
    540   static const char kMetricTimeToConnectMillisecondsSuffix[];
    541   static const int kMetricTimeToConnectMillisecondsMax;
    542   static const int kMetricTimeToConnectMillisecondsMin;
    543   static const int kMetricTimeToConnectMillisecondsNumBuckets;
    544   static const char kMetricTimeToScanAndConnectMillisecondsSuffix[];
    545   static const char kMetricTimeToDropSeconds[];
    546   static const int kMetricTimeToDropSecondsMax;
    547   static const int kMetricTimeToDropSecondsMin;
    548   static const char kMetricTimeToDisableMillisecondsSuffix[];
    549   static const int kMetricTimeToDisableMillisecondsMax;
    550   static const int kMetricTimeToDisableMillisecondsMin;
    551   static const int kMetricTimeToDisableMillisecondsNumBuckets;
    552   static const char kMetricTimeToEnableMillisecondsSuffix[];
    553   static const int kMetricTimeToEnableMillisecondsMax;
    554   static const int kMetricTimeToEnableMillisecondsMin;
    555   static const int kMetricTimeToEnableMillisecondsNumBuckets;
    556   static const char kMetricTimeToInitializeMillisecondsSuffix[];
    557   static const int kMetricTimeToInitializeMillisecondsMax;
    558   static const int kMetricTimeToInitializeMillisecondsMin;
    559   static const int kMetricTimeToInitializeMillisecondsNumBuckets;
    560   static const char kMetricTimeToJoinMillisecondsSuffix[];
    561   static const char kMetricTimeToOnlineMillisecondsSuffix[];
    562   static const char kMetricTimeToPortalMillisecondsSuffix[];
    563   static const char kMetricTimeToScanMillisecondsSuffix[];
    564   static const int kMetricTimeToScanMillisecondsMax;
    565   static const int kMetricTimeToScanMillisecondsMin;
    566   static const int kMetricTimeToScanMillisecondsNumBuckets;
    567   static const int kTimerHistogramMillisecondsMax;
    568   static const int kTimerHistogramMillisecondsMin;
    569   static const int kTimerHistogramNumBuckets;
    570 
    571   // The number of portal detections attempted for each pass.
    572   // This includes both failure/timeout attempts and successful attempt
    573   // (if any).
    574   static const char kMetricPortalAttemptsSuffix[];
    575   static const int kMetricPortalAttemptsMax;
    576   static const int kMetricPortalAttemptsMin;
    577   static const int kMetricPortalAttemptsNumBuckets;
    578 
    579   // The total number of portal detections attempted between the Connected
    580   // state and the Online state.  This includes both failure/timeout attempts
    581   // and the final successful attempt.
    582   static const char kMetricPortalAttemptsToOnlineSuffix[];
    583   static const int kMetricPortalAttemptsToOnlineMax;
    584   static const int kMetricPortalAttemptsToOnlineMin;
    585   static const int kMetricPortalAttemptsToOnlineNumBuckets;
    586 
    587   // The result of the portal detection.
    588   static const char kMetricPortalResultSuffix[];
    589 
    590   // Wifi connection frequencies.
    591   static const char kMetricFrequenciesConnectedEver[];
    592   static const int kMetricFrequenciesConnectedMax;
    593   static const int kMetricFrequenciesConnectedMin;
    594   static const int kMetricFrequenciesConnectedNumBuckets;
    595 
    596   static const char kMetricScanResult[];
    597   static const char kMetricWiFiScanTimeInEbusyMilliseconds[];
    598 
    599   static const char kMetricPowerManagerKey[];
    600 
    601   // LinkMonitor statistics.
    602   static const char kMetricLinkMonitorFailureSuffix[];
    603   static const char kMetricLinkMonitorResponseTimeSampleSuffix[];
    604   static const int kMetricLinkMonitorResponseTimeSampleMin;
    605   static const int kMetricLinkMonitorResponseTimeSampleMax;
    606   static const int kMetricLinkMonitorResponseTimeSampleNumBuckets;
    607   static const char kMetricLinkMonitorSecondsToFailureSuffix[];
    608   static const int kMetricLinkMonitorSecondsToFailureMin;
    609   static const int kMetricLinkMonitorSecondsToFailureMax;
    610   static const int kMetricLinkMonitorSecondsToFailureNumBuckets;
    611   static const char kMetricLinkMonitorBroadcastErrorsAtFailureSuffix[];
    612   static const char kMetricLinkMonitorUnicastErrorsAtFailureSuffix[];
    613   static const int kMetricLinkMonitorErrorCountMin;
    614   static const int kMetricLinkMonitorErrorCountMax;
    615   static const int kMetricLinkMonitorErrorCountNumBuckets;
    616 
    617   // Signal strength when link becomes unreliable (multiple link monitor
    618   // failures in short period of time).
    619   static const char kMetricUnreliableLinkSignalStrengthSuffix[];
    620   static const int kMetricSerivceSignalStrengthMin;
    621   static const int kMetricServiceSignalStrengthMax;
    622   static const int kMetricServiceSignalStrengthNumBuckets;
    623 
    624   static const char kMetricLinkClientDisconnectReason[];
    625   static const char kMetricLinkApDisconnectReason[];
    626   static const char kMetricLinkClientDisconnectType[];
    627   static const char kMetricLinkApDisconnectType[];
    628 
    629   // Shill termination action statistics.
    630   static const char kMetricTerminationActionTimeTaken[];
    631   static const char kMetricTerminationActionResult[];
    632   static const int kMetricTerminationActionTimeTakenMillisecondsMax;
    633   static const int kMetricTerminationActionTimeTakenMillisecondsMin;
    634 
    635   // Shill suspend action statistics.
    636   static const char kMetricSuspendActionTimeTaken[];
    637   static const char kMetricSuspendActionResult[];
    638   static const int kMetricSuspendActionTimeTakenMillisecondsMax;
    639   static const int kMetricSuspendActionTimeTakenMillisecondsMin;
    640 
    641   // Shill dark resume action statistics.
    642   static const char kMetricDarkResumeActionTimeTaken[];
    643   static const char kMetricDarkResumeActionResult[];
    644   static const int kMetricDarkResumeActionTimeTakenMillisecondsMax;
    645   static const int kMetricDarkResumeActionTimeTakenMillisecondsMin;
    646   static const char kMetricDarkResumeUnmatchedScanResultReceived[];
    647 
    648   // Shill wake on WiFi feature state statistics.
    649   static const char kMetricWakeOnWiFiFeaturesEnabledState[];
    650   // The result of NIC wake on WiFi settings verification.
    651   static const char kMetricVerifyWakeOnWiFiSettingsResult[];
    652   static const char kMetricWiFiConnectionStatusAfterWake[];
    653   // Whether or not wake on WiFi was throttled during the last suspend.
    654   static const char kMetricWakeOnWiFiThrottled[];
    655   // Whether or not a wakeup reason was received before WakeOnWiFi::OnDarkResume
    656   // executes.
    657   static const char kMetricWakeReasonReceivedBeforeOnDarkResume[];
    658   static const char kMetricDarkResumeWakeReason[];
    659   static const char kMetricDarkResumeScanType[];
    660   static const char kMetricDarkResumeScanRetryResult[];
    661   static const char kMetricDarkResumeScanNumRetries[];
    662   static const int kMetricDarkResumeScanNumRetriesMax;
    663   static const int kMetricDarkResumeScanNumRetriesMin;
    664 
    665   // WiFiService Entry Fixup.
    666   static const char kMetricServiceFixupEntriesSuffix[];
    667 
    668   // Cellular specific statistics.
    669   static const char kMetricCellular3GPPRegistrationDelayedDrop[];
    670   static const char kMetricCellularAutoConnectTries[];
    671   static const int kMetricCellularAutoConnectTriesMax;
    672   static const int kMetricCellularAutoConnectTriesMin;
    673   static const int kMetricCellularAutoConnectTriesNumBuckets;
    674   static const char kMetricCellularAutoConnectTotalTime[];
    675   static const int kMetricCellularAutoConnectTotalTimeMax;
    676   static const int kMetricCellularAutoConnectTotalTimeMin;
    677   static const int kMetricCellularAutoConnectTotalTimeNumBuckets;
    678   static const char kMetricCellularDrop[];
    679   static const char kMetricCellularDropsPerHour[];
    680   static const int kMetricCellularDropsPerHourMax;
    681   static const int kMetricCellularDropsPerHourMin;
    682   static const int kMetricCellularDropsPerHourNumBuckets;
    683   static const char kMetricCellularFailure[];
    684   static const int kMetricCellularConnectionFailure;
    685   static const int kMetricCellularDisconnectionFailure;
    686   static const int kMetricCellularMaxFailure;
    687   static const char kMetricCellularOutOfCreditsReason[];
    688   static const char kMetricCellularSignalStrengthBeforeDrop[];
    689   static const int kMetricCellularSignalStrengthBeforeDropMax;
    690   static const int kMetricCellularSignalStrengthBeforeDropMin;
    691   static const int kMetricCellularSignalStrengthBeforeDropNumBuckets;
    692 
    693   // Profile statistics.
    694   static const char kMetricCorruptedProfile[];
    695 
    696   // VPN connection statistics.
    697   static const char kMetricVpnDriver[];
    698   static const int kMetricVpnDriverMax;
    699   static const char kMetricVpnRemoteAuthenticationType[];
    700   static const int kMetricVpnRemoteAuthenticationTypeMax;
    701   static const char kMetricVpnUserAuthenticationType[];
    702   static const int kMetricVpnUserAuthenticationTypeMax;
    703 
    704   // The length in seconds of a lease that has expired while the DHCP
    705   // client was attempting to renew the lease..
    706   static const char kMetricExpiredLeaseLengthSecondsSuffix[];
    707   static const int kMetricExpiredLeaseLengthSecondsMax;
    708   static const int kMetricExpiredLeaseLengthSecondsMin;
    709   static const int kMetricExpiredLeaseLengthSecondsNumBuckets;
    710 
    711   // Number of wifi services available when auto-connect is initiated.
    712   static const char kMetricWifiAutoConnectableServices[];
    713   static const int kMetricWifiAutoConnectableServicesMax;
    714   static const int kMetricWifiAutoConnectableServicesMin;
    715   static const int kMetricWifiAutoConnectableServicesNumBuckets;
    716 
    717   // Number of BSSes available for a wifi service when we attempt to connect
    718   // to that service.
    719   static const char kMetricWifiAvailableBSSes[];
    720   static const int kMetricWifiAvailableBSSesMax;
    721   static const int kMetricWifiAvailableBSSesMin;
    722   static const int kMetricWifiAvailableBSSesNumBuckets;
    723 
    724   // Reason that the mac80211 TX queue is stopped.
    725   static const char kMetricWifiStoppedTxQueueReason[];
    726 
    727   // Maximal queue length amongst all stopped mac80211 TX queues.
    728   static const char kMetricWifiStoppedTxQueueLength[];
    729   static const int kMetricWifiStoppedTxQueueLengthMax;
    730   static const int kMetricWifiStoppedTxQueueLengthMin;
    731   static const int kMetricWifiStoppedTxQueueLengthNumBuckets;
    732 
    733   // Number of services associated with currently connected network.
    734   static const char kMetricServicesOnSameNetwork[];
    735   static const int kMetricServicesOnSameNetworkMax;
    736   static const int kMetricServicesOnSameNetworkMin;
    737   static const int kMetricServicesOnSameNetworkNumBuckets;
    738 
    739   // Metric for user-initiated events.
    740   static const char kMetricUserInitiatedEvents[];
    741 
    742   // Wifi TX bitrate in Mbps.
    743   static const char kMetricWifiTxBitrate[];
    744   static const int kMetricWifiTxBitrateMax;
    745   static const int kMetricWifiTxBitrateMin;
    746   static const int kMetricWifiTxBitrateNumBuckets;
    747 
    748   // User-initiated wifi connection attempt result.
    749   static const char kMetricWifiUserInitiatedConnectionResult[];
    750 
    751   // The reason of failed user-initiated wifi connection attempt.
    752   static const char kMetricWifiUserInitiatedConnectionFailureReason[];
    753 
    754   // DNS test result.
    755   static const char kMetricFallbackDNSTestResultSuffix[];
    756 
    757   // Network problem detected by traffic monitor
    758   static const char kMetricNetworkProblemDetectedSuffix[];
    759 
    760   // Device's connection status.
    761   static const char kMetricDeviceConnectionStatus[];
    762 
    763   // DHCP client status.
    764   static const char kMetricDhcpClientStatus[];
    765 
    766   // Assigned MTU values, both from DHCP and PPP.
    767   static const char kMetricDhcpClientMTUValue[];
    768   static const char kMetricPPPMTUValue[];
    769 
    770   // Network connection IP type.
    771   static const char kMetricNetworkConnectionIPTypeSuffix[];
    772 
    773   // IPv6 connectivity status.
    774   static const char kMetricIPv6ConnectivityStatusSuffix[];
    775 
    776   // Device presence.
    777   static const char kMetricDevicePresenceStatusSuffix[];
    778 
    779   // Device removal event.
    780   static const char kMetricDeviceRemovedEvent[];
    781 
    782   // Connection diagnostics issue.
    783   static const char kMetricConnectionDiagnosticsIssue[];
    784 
    785   explicit Metrics(EventDispatcher* dispatcher);
    786   virtual ~Metrics();
    787 
    788   // Converts the WiFi frequency into the associated UMA channel enumerator.
    789   static WiFiChannel WiFiFrequencyToChannel(uint16_t frequency);
    790 
    791   // Converts a flimflam security string into its UMA security enumerator.
    792   static WiFiSecurity WiFiSecurityStringToEnum(const std::string& security);
    793 
    794   // Converts a flimflam AP mode string into its UMA AP mode enumerator.
    795   static WiFiApMode WiFiApModeStringToEnum(const std::string& ap_mode);
    796 
    797   // Converts a flimflam EAP outer protocol string into its UMA enumerator.
    798   static EapOuterProtocol EapOuterProtocolStringToEnum(
    799       const std::string& outer);
    800 
    801   // Converts a flimflam EAP inner protocol string into its UMA enumerator.
    802   static EapInnerProtocol EapInnerProtocolStringToEnum(
    803       const std::string& inner);
    804 
    805   // Converts portal detection result to UMA portal result enumerator.
    806   static PortalResult PortalDetectionResultToEnum(
    807       const PortalDetector::Result& result);
    808 
    809   // Starts this object.  Call this during initialization.
    810   virtual void Start();
    811 
    812   // Stops this object.  Call this during cleanup.
    813   virtual void Stop();
    814 
    815   // Registers a service with this object so it can use the timers to track
    816   // state transition metrics.
    817   void RegisterService(const Service& service);
    818 
    819   // Deregisters the service from this class.  All state transition timers
    820   // will be removed.
    821   void DeregisterService(const Service& service);
    822 
    823   // Tracks the time it takes |service| to go from |start_state| to
    824   // |stop_state|.  When |stop_state| is reached, the time is sent to UMA.
    825   virtual void AddServiceStateTransitionTimer(
    826       const Service& service, const std::string& histogram_name,
    827       Service::ConnectState start_state, Service::ConnectState stop_state);
    828 
    829   // Specializes |metric_suffix| for the specified |technology_id|.
    830   std::string GetFullMetricName(const char* metric_suffix,
    831                                 Technology::Identifier technology_id);
    832 
    833   // Notifies this object that the default service has changed.
    834   // |service| is the new default service.
    835   virtual void NotifyDefaultServiceChanged(const Service* service);
    836 
    837   // Notifies this object that |service| state has changed.
    838   virtual void NotifyServiceStateChanged(const Service& service,
    839                                          Service::ConnectState new_state);
    840 
    841   // Notifies this object that |service| has been disconnected.
    842   void NotifyServiceDisconnect(const Service& service);
    843 
    844   // Notifies this object of power at disconnect.
    845   void NotifySignalAtDisconnect(const Service& service,
    846                                 int16_t signal_strength);
    847 
    848   // Notifies this object of the end of a suspend attempt.
    849   void NotifySuspendDone();
    850 
    851   // Notifies this object of the current wake on WiFi features enabled
    852   // represented by the WakeOnWiFiFeaturesEnabledState |state|.
    853   void NotifyWakeOnWiFiFeaturesEnabledState(
    854       WakeOnWiFiFeaturesEnabledState state);
    855 
    856   // Notifies this object of the result of NIC wake on WiFi settings
    857   // verification.
    858   virtual void NotifyVerifyWakeOnWiFiSettingsResult(
    859       VerifyWakeOnWiFiSettingsResult result);
    860 
    861   // Notifies this object of whether or not the WiFi device is connected to a
    862   // service after waking from suspend.
    863   virtual void NotifyConnectedToServiceAfterWake(
    864       WiFiConnectionStatusAfterWake status);
    865 
    866   // Notifies this object that termination actions started executing.
    867   void NotifyTerminationActionsStarted();
    868 
    869   // Notifies this object that termination actions have been completed.
    870   // |success| is true, if the termination actions completed successfully.
    871   void NotifyTerminationActionsCompleted(bool success);
    872 
    873   // Notifies this object that suspend actions started executing.
    874   void NotifySuspendActionsStarted();
    875 
    876   // Notifies this object that suspend actions have been completed.
    877   // |success| is true, if the suspend actions completed successfully.
    878   void NotifySuspendActionsCompleted(bool success);
    879 
    880   // Notifies this object that dark resume actions started executing.
    881   void NotifyDarkResumeActionsStarted();
    882 
    883   // Notifies this object that dark resume actions have been completed.
    884   // |success| is true, if the dark resume actions completed successfully.
    885   void NotifyDarkResumeActionsCompleted(bool success);
    886 
    887   // Notifies this object that a scan has been initiated by shill while in dark
    888   // resume.
    889   virtual void NotifyDarkResumeInitiateScan();
    890 
    891   // Notifies this object that a scan results have been received in dark resume.
    892   void NotifyDarkResumeScanResultsReceived();
    893 
    894   // Notifies this object of a failure in LinkMonitor.
    895   void NotifyLinkMonitorFailure(
    896       Technology::Identifier technology,
    897       LinkMonitorFailure failure,
    898       int seconds_to_failure,
    899       int broadcast_error_count,
    900       int unicast_error_count);
    901 
    902   // Notifies this object that LinkMonitor has added a response time sample
    903   // for |connection| with a value of |response_time_milliseconds|.
    904   void NotifyLinkMonitorResponseTimeSampleAdded(
    905       Technology::Identifier technology,
    906       int response_time_milliseconds);
    907 
    908 #if !defined(DISABLE_WIFI)
    909   // Notifies this object of WiFi disconnect.
    910   virtual void Notify80211Disconnect(WiFiDisconnectByWhom by_whom,
    911                                      IEEE_80211::WiFiReasonCode reason);
    912 #endif  // DISABLE_WIFI
    913 
    914   // Registers a device with this object so the device can use the timers to
    915   // track state transition metrics.
    916   void RegisterDevice(int interface_index,
    917                       Technology::Identifier technology);
    918 
    919   // Checks to see if the device has already been registered.
    920   bool IsDeviceRegistered(int interface_index,
    921                           Technology::Identifier technology);
    922 
    923   // Deregisters the device from this class.  All state transition timers
    924   // will be removed.
    925   virtual void DeregisterDevice(int interface_index);
    926 
    927   // Notifies this object that a device has been initialized.
    928   void NotifyDeviceInitialized(int interface_index);
    929 
    930   // Notifies this object that a device has started the enable process.
    931   void NotifyDeviceEnableStarted(int interface_index);
    932 
    933   // Notifies this object that a device has completed the enable process.
    934   void NotifyDeviceEnableFinished(int interface_index);
    935 
    936   // Notifies this object that a device has started the disable process.
    937   void NotifyDeviceDisableStarted(int interface_index);
    938 
    939   // Notifies this object that a device has completed the disable process.
    940   void NotifyDeviceDisableFinished(int interface_index);
    941 
    942   // Notifies this object that a device has started the scanning process.
    943   virtual void NotifyDeviceScanStarted(int interface_index);
    944 
    945   // Notifies this object that a device has completed the scanning process.
    946   virtual void NotifyDeviceScanFinished(int interface_index);
    947 
    948   // Terminates an underway scan (does nothing if a scan wasn't underway).
    949   virtual void ResetScanTimer(int interface_index);
    950 
    951   // Notifies this object that a device has started the connect process.
    952   virtual void NotifyDeviceConnectStarted(int interface_index,
    953                                           bool is_auto_connecting);
    954 
    955   // Notifies this object that a device has completed the connect process.
    956   virtual void NotifyDeviceConnectFinished(int interface_index);
    957 
    958   // Resets both the connect_timer and the scan_connect_timer the timer (the
    959   // latter so that a future connect will not erroneously be associated with
    960   // the previous scan).
    961   virtual void ResetConnectTimer(int interface_index);
    962 
    963   // Notifies this object that a cellular device has been dropped by the
    964   // network.
    965   void NotifyCellularDeviceDrop(const std::string& network_technology,
    966                                 uint16_t signal_strength);
    967 
    968   // Notifies this object about 3GPP registration drop events.
    969   virtual void Notify3GPPRegistrationDelayedDropPosted();
    970   virtual void Notify3GPPRegistrationDelayedDropCanceled();
    971 
    972   // Notifies this object about a cellular connection failure.
    973   void NotifyCellularDeviceConnectionFailure();
    974 
    975   // Notifies this object about a cellular disconnection failure.
    976   void NotifyCellularDeviceDisconnectionFailure();
    977 
    978   // Notifies this object that a cellular service has been marked as
    979   // out-of-credits.
    980   void NotifyCellularOutOfCredits(Metrics::CellularOutOfCreditsReason reason);
    981 
    982   // Notifies this object about number of wifi services available for auto
    983   // connect when auto-connect is initiated.
    984   virtual void NotifyWifiAutoConnectableServices(int num_services);
    985 
    986   // Notifies this object about number of BSSes available for a wifi service
    987   // when attempt to connect to that service.
    988   virtual void NotifyWifiAvailableBSSes(int num_services);
    989 
    990   // Notifies this object about number of services associated to the
    991   // currently connected network.
    992   virtual void NotifyServicesOnSameNetwork(int num_services);
    993 
    994   // Notifies this object about WIFI TX bitrate in Mbps.
    995   virtual void NotifyWifiTxBitrate(int bitrate);
    996 
    997   // Notifies this object about the result of user-initiated connection
    998   // attempt.
    999   virtual void NotifyUserInitiatedConnectionResult(const std::string& name,
   1000                                                    int result);
   1001 
   1002   // Notifies this object about the reason of failed user-initiated connection
   1003   // attempt.
   1004   virtual void NotifyUserInitiatedConnectionFailureReason(
   1005       const std::string& name, const Service::ConnectFailure failure);
   1006 
   1007   // Notifies this object about a corrupted profile.
   1008   virtual void NotifyCorruptedProfile();
   1009 
   1010   // Notifies this object about user-initiated event.
   1011   virtual void NotifyUserInitiatedEvent(int event);
   1012 
   1013   // Notifies this object about the result of the fallback DNS test.
   1014   virtual void NotifyFallbackDNSTestResult(Technology::Identifier technology_id,
   1015                                            int result);
   1016 
   1017   // Notifies this object about a network problem detected on the currently
   1018   // connected network.
   1019   virtual void NotifyNetworkProblemDetected(
   1020       Technology::Identifier technology_id, int reason);
   1021 
   1022   // Notifies this object about current connection status (online vs offline).
   1023   virtual void NotifyDeviceConnectionStatus(Metrics::ConnectionStatus status);
   1024 
   1025   // Notifies this object about the DHCP client status.
   1026   virtual void NotifyDhcpClientStatus(Metrics::DhcpClientStatus status);
   1027 
   1028   // Notifies this object about the IP type of the current network connection.
   1029   virtual void NotifyNetworkConnectionIPType(
   1030       Technology::Identifier technology_id, NetworkConnectionIPType type);
   1031 
   1032   // Notifies this object about the IPv6 connectivity status.
   1033   virtual void NotifyIPv6ConnectivityStatus(
   1034       Technology::Identifier technology_id, bool status);
   1035 
   1036   // Notifies this object about the presence of given technology type device.
   1037   virtual void NotifyDevicePresenceStatus(Technology::Identifier technology_id,
   1038                                           bool status);
   1039 
   1040   // Notifies this object about the signal strength when link is unreliable.
   1041   virtual void NotifyUnreliableLinkSignalStrength(
   1042       Technology::Identifier technology_id, int signal_strength);
   1043 
   1044   // Sends linear histogram data to UMA.
   1045   virtual bool SendEnumToUMA(const std::string& name, int sample, int max);
   1046 
   1047   // Send histogram data to UMA.
   1048   virtual bool SendToUMA(const std::string& name, int sample, int min,
   1049                          int max, int num_buckets);
   1050 
   1051   // Sends sparse histogram data to UMA.
   1052   virtual bool SendSparseToUMA(const std::string& name, int sample);
   1053 
   1054   // Notifies this object that wake on WiFi has been disabled because of
   1055   // excessive dark resume wakes.
   1056   virtual void NotifyWakeOnWiFiThrottled();
   1057 
   1058   // Notifies this object that shill has resumed from a period of suspension
   1059   // where wake on WiFi functionality was enabled on the NIC.
   1060   virtual void NotifySuspendWithWakeOnWiFiEnabledDone();
   1061 
   1062   // Notifies this object that a wakeup reason has been received.
   1063   virtual void NotifyWakeupReasonReceived();
   1064 
   1065 #if !defined(DISABLE_WIFI)
   1066   // Notifies this object that WakeOnWiFi::OnDarkResume has begun executing,
   1067   // and that the dark resume was caused by |reason|.
   1068   virtual void NotifyWakeOnWiFiOnDarkResume(
   1069       WakeOnWiFi::WakeOnWiFiTrigger reason);
   1070 #endif  // DISABLE_WIFI
   1071 
   1072   // Notifies this object that a scan was started in dark resume. If
   1073   // |is_active_scan| is true, the scan started was an active scan. Otherwise
   1074   // the scan started was a passive scan.
   1075   // Note: Metrics::NotifyDarkResumeInitiateScan is called when shill initiates
   1076   // a scan in dark resume, while Metrics::NotifyScanStartedInDarkResume is
   1077   // called when the kernel notifies shill that a scan (shill-initiated or not)
   1078   // has actually started.
   1079   virtual void NotifyScanStartedInDarkResume(bool is_active_scan);
   1080 
   1081   // Notifies this object that a dark resume scan retry was launched.
   1082   virtual void NotifyDarkResumeScanRetry();
   1083 
   1084   // Notifies this object that shill is about to suspend and is executing
   1085   // WakeOnWiFi::BeforeSuspendActions. |is_connected| indicates whether shill
   1086   // was connected before suspending, and |in_dark_resume| indicates whether
   1087   // shill is current in dark resume.
   1088   // Note: this will only be called if wake on WiFi is supported and enabled.
   1089   virtual void NotifyBeforeSuspendActions(bool is_connected,
   1090                                           bool in_dark_resume);
   1091 
   1092   // Notifies this object that connection diagnostics have been performed, and
   1093   // the connection issue that was diagnosed is |issue|.
   1094   virtual void NotifyConnectionDiagnosticsIssue(
   1095       const std::string& issue);
   1096 
   1097  private:
   1098   friend class MetricsTest;
   1099   FRIEND_TEST(MetricsTest, CellularDropsPerHour);
   1100   FRIEND_TEST(MetricsTest, FrequencyToChannel);
   1101   FRIEND_TEST(MetricsTest, ResetConnectTimer);
   1102   FRIEND_TEST(MetricsTest, ServiceFailure);
   1103   FRIEND_TEST(MetricsTest, TimeOnlineTimeToDrop);
   1104   FRIEND_TEST(MetricsTest, TimeToConfig);
   1105   FRIEND_TEST(MetricsTest, TimeToOnline);
   1106   FRIEND_TEST(MetricsTest, TimeToPortal);
   1107   FRIEND_TEST(MetricsTest, TimeToScanIgnore);
   1108   FRIEND_TEST(MetricsTest, WiFiServiceChannel);
   1109   FRIEND_TEST(MetricsTest, WiFiServicePostReady);
   1110   FRIEND_TEST(MetricsTest, NotifySuspendWithWakeOnWiFiEnabledDone);
   1111   FRIEND_TEST(MetricsTest, NotifyWakeOnWiFiThrottled);
   1112   FRIEND_TEST(MetricsTest, NotifySuspendActionsCompleted_Success);
   1113   FRIEND_TEST(MetricsTest, NotifySuspendActionsCompleted_Failure);
   1114   FRIEND_TEST(MetricsTest, NotifyDarkResumeActionsCompleted_Success);
   1115   FRIEND_TEST(MetricsTest, NotifyDarkResumeActionsCompleted_Failure);
   1116   FRIEND_TEST(MetricsTest, NotifySuspendActionsStarted);
   1117   FRIEND_TEST(MetricsTest, NotifyDarkResumeActionsStarted);
   1118   FRIEND_TEST(MetricsTest, NotifyDarkResumeInitiateScan);
   1119   FRIEND_TEST(MetricsTest, NotifyDarkResumeScanResultsReceived);
   1120   FRIEND_TEST(MetricsTest, NotifyDarkResumeScanRetry);
   1121   FRIEND_TEST(MetricsTest, NotifyBeforeSuspendActions_InDarkResume);
   1122   FRIEND_TEST(MetricsTest, NotifyBeforeSuspendActions_NotInDarkResume);
   1123   FRIEND_TEST(WiFiMainTest, GetGeolocationObjects);
   1124 
   1125   typedef ScopedVector<chromeos_metrics::TimerReporter> TimerReporters;
   1126   typedef std::list<chromeos_metrics::TimerReporter*> TimerReportersList;
   1127   typedef std::map<Service::ConnectState, TimerReportersList>
   1128       TimerReportersByState;
   1129   struct ServiceMetrics {
   1130     // All TimerReporter objects are stored in |timers| which owns the objects.
   1131     // |start_on_state| and |stop_on_state| contain pointers to the
   1132     // TimerReporter objects and control when to start and stop the timers.
   1133     TimerReporters timers;
   1134     TimerReportersByState start_on_state;
   1135     TimerReportersByState stop_on_state;
   1136   };
   1137   typedef std::map<const Service*, std::shared_ptr<ServiceMetrics>>
   1138       ServiceMetricsLookupMap;
   1139 
   1140   struct DeviceMetrics {
   1141     DeviceMetrics() : auto_connect_tries(0) {}
   1142     Technology::Identifier technology;
   1143     std::unique_ptr<chromeos_metrics::TimerReporter> initialization_timer;
   1144     std::unique_ptr<chromeos_metrics::TimerReporter> enable_timer;
   1145     std::unique_ptr<chromeos_metrics::TimerReporter> disable_timer;
   1146     std::unique_ptr<chromeos_metrics::TimerReporter> scan_timer;
   1147     std::unique_ptr<chromeos_metrics::TimerReporter> connect_timer;
   1148     std::unique_ptr<chromeos_metrics::TimerReporter> scan_connect_timer;
   1149     std::unique_ptr<chromeos_metrics::TimerReporter> auto_connect_timer;
   1150     int auto_connect_tries;
   1151   };
   1152   typedef std::map<const int, std::shared_ptr<DeviceMetrics>>
   1153       DeviceMetricsLookupMap;
   1154 
   1155   static const uint16_t kWiFiBandwidth5MHz;
   1156   static const uint16_t kWiFiBandwidth20MHz;
   1157   static const uint16_t kWiFiFrequency2412;
   1158   static const uint16_t kWiFiFrequency2472;
   1159   static const uint16_t kWiFiFrequency2484;
   1160   static const uint16_t kWiFiFrequency5170;
   1161   static const uint16_t kWiFiFrequency5180;
   1162   static const uint16_t kWiFiFrequency5230;
   1163   static const uint16_t kWiFiFrequency5240;
   1164   static const uint16_t kWiFiFrequency5320;
   1165   static const uint16_t kWiFiFrequency5500;
   1166   static const uint16_t kWiFiFrequency5700;
   1167   static const uint16_t kWiFiFrequency5745;
   1168   static const uint16_t kWiFiFrequency5825;
   1169 
   1170   void InitializeCommonServiceMetrics(const Service& service);
   1171   void UpdateServiceStateTransitionMetrics(ServiceMetrics* service_metrics,
   1172                                            Service::ConnectState new_state);
   1173   void SendServiceFailure(const Service& service);
   1174 
   1175   DeviceMetrics* GetDeviceMetrics(int interface_index) const;
   1176   void AutoConnectMetricsReset(DeviceMetrics* device_metrics);
   1177 
   1178   // Notifies this object about the removal/resetting of a device with given
   1179   // technology type.
   1180   void NotifyDeviceRemovedEvent(Technology::Identifier technology_id);
   1181 
   1182   // For unit test purposes.
   1183   void set_library(MetricsLibraryInterface* library);
   1184   void set_time_online_timer(chromeos_metrics::Timer* timer) {
   1185     time_online_timer_.reset(timer);  // Passes ownership
   1186   }
   1187   void set_time_to_drop_timer(chromeos_metrics::Timer* timer) {
   1188     time_to_drop_timer_.reset(timer);  // Passes ownership
   1189   }
   1190   void set_time_resume_to_ready_timer(chromeos_metrics::Timer* timer) {
   1191     time_resume_to_ready_timer_.reset(timer);  // Passes ownership
   1192   }
   1193   void set_time_termination_actions_timer(
   1194     chromeos_metrics::Timer* timer) {
   1195     time_termination_actions_timer.reset(timer);  // Passes ownership
   1196   }
   1197   void set_time_suspend_actions_timer(
   1198     chromeos_metrics::Timer* timer) {
   1199     time_suspend_actions_timer.reset(timer);  // Passes ownership
   1200   }
   1201   void set_time_dark_resume_actions_timer(
   1202     chromeos_metrics::Timer* timer) {
   1203     time_dark_resume_actions_timer.reset(timer);  // Passes ownership
   1204   }
   1205   void set_time_to_scan_timer(int interface_index,
   1206                               chromeos_metrics::TimerReporter* timer) {
   1207     DeviceMetrics* device_metrics = GetDeviceMetrics(interface_index);
   1208     device_metrics->scan_timer.reset(timer);  // Passes ownership
   1209   }
   1210   void set_time_to_connect_timer(int interface_index,
   1211                                  chromeos_metrics::TimerReporter* timer) {
   1212     DeviceMetrics* device_metrics = GetDeviceMetrics(interface_index);
   1213     device_metrics->connect_timer.reset(timer);  // Passes ownership
   1214   }
   1215   void set_time_to_scan_connect_timer(int interface_index,
   1216                                       chromeos_metrics::TimerReporter* timer) {
   1217     DeviceMetrics* device_metrics = GetDeviceMetrics(interface_index);
   1218     device_metrics->scan_connect_timer.reset(timer);  // Passes ownership
   1219   }
   1220 
   1221   // |library_| points to |metrics_library_| when shill runs normally.
   1222   // However, in order to allow for unit testing, we point |library_| to a
   1223   // MetricsLibraryMock object instead.
   1224   EventDispatcher* dispatcher_;
   1225   MetricsLibrary metrics_library_;
   1226   MetricsLibraryInterface* library_;
   1227   ServiceMetricsLookupMap services_metrics_;
   1228   Technology::Identifier last_default_technology_;
   1229   bool was_online_;
   1230   std::unique_ptr<chromeos_metrics::Timer> time_online_timer_;
   1231   std::unique_ptr<chromeos_metrics::Timer> time_to_drop_timer_;
   1232   std::unique_ptr<chromeos_metrics::Timer> time_resume_to_ready_timer_;
   1233   std::unique_ptr<chromeos_metrics::Timer> time_termination_actions_timer;
   1234   std::unique_ptr<chromeos_metrics::Timer> time_suspend_actions_timer;
   1235   std::unique_ptr<chromeos_metrics::Timer> time_dark_resume_actions_timer;
   1236   bool collect_bootstats_;
   1237   DeviceMetricsLookupMap devices_metrics_;
   1238   int num_scan_results_expected_in_dark_resume_;
   1239   bool wake_on_wifi_throttled_;
   1240   bool wake_reason_received_;
   1241   int dark_resume_scan_retries_;
   1242 
   1243   DISALLOW_COPY_AND_ASSIGN(Metrics);
   1244 };
   1245 
   1246 }  // namespace shill
   1247 
   1248 #endif  // SHILL_METRICS_H_
   1249