net/base/network_change_notifier.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "net/base/network_change_notifier.h"
   6
   7 #include <limits>
   8
   9 #include "base/metrics/histogram.h"
  10 #include "base/synchronization/lock.h"
  11 #include "base/threading/thread_checker.h"
  12 #include "build/build_config.h"
  13 #include "net/base/net_util.h"
  14 #include "net/base/network_change_notifier_factory.h"
  15 #include "net/dns/dns_config_service.h"
  16 #include "net/url_request/url_request.h"
  17 #include "url/gurl.h"
  18
  19 #if defined(OS_ANDROID)
  20 #include "base/metrics/sparse_histogram.h"
  21 #include "base/strings/string_number_conversions.h"
  22 #include "net/android/network_library.h"
  23 #endif
  24
  25 #if defined(OS_WIN)
  26 #include "net/base/network_change_notifier_win.h"
  27 #elif defined(OS_LINUX) && !defined(OS_CHROMEOS)
  28 #include "net/base/network_change_notifier_linux.h"
  29 #elif defined(OS_MACOSX)
  30 #include "net/base/network_change_notifier_mac.h"
  31 #endif
  32
  33 namespace net {
  34
  35 namespace {
  36
  37 // The actual singleton notifier.  The class contract forbids usage of the API
  38 // in ways that would require us to place locks around access to this object.
  39 // (The prohibition on global non-POD objects makes it tricky to do such a thing
  40 // anyway.)
  41 NetworkChangeNotifier* g_network_change_notifier = NULL;
  42
  43 // Class factory singleton.
  44 NetworkChangeNotifierFactory* g_network_change_notifier_factory = NULL;
  45
  46 class MockNetworkChangeNotifier : public NetworkChangeNotifier {
  47  public:
  48   ConnectionType GetCurrentConnectionType() const override {
  49     return CONNECTION_UNKNOWN;
  50   }
  51 };
  52
  53 }  // namespace
  54
  55 // The main observer class that records UMAs for network events.
  56 class HistogramWatcher
  57     : public NetworkChangeNotifier::ConnectionTypeObserver,
  58       public NetworkChangeNotifier::IPAddressObserver,
  59       public NetworkChangeNotifier::DNSObserver,
  60       public NetworkChangeNotifier::NetworkChangeObserver {
  61  public:
  62   HistogramWatcher()
  63       : last_ip_address_change_(base::TimeTicks::Now()),
  64         last_connection_change_(base::TimeTicks::Now()),
  65         last_dns_change_(base::TimeTicks::Now()),
  66         last_network_change_(base::TimeTicks::Now()),
  67         last_connection_type_(NetworkChangeNotifier::CONNECTION_UNKNOWN),
  68         offline_packets_received_(0),
  69         bytes_read_since_last_connection_change_(0),
  70         peak_kbps_since_last_connection_change_(0) {}
  71
  72   // Registers our three Observer implementations.  This is called from the
  73   // network thread so that our Observer implementations are also called
  74   // from the network thread.  This avoids multi-threaded race conditions
  75   // because the only other interface, |NotifyDataReceived| is also
  76   // only called from the network thread.
  77   void Init() {
  78     DCHECK(thread_checker_.CalledOnValidThread());
  79     DCHECK(g_network_change_notifier);
  80     NetworkChangeNotifier::AddConnectionTypeObserver(this);
  81     NetworkChangeNotifier::AddIPAddressObserver(this);
  82     NetworkChangeNotifier::AddDNSObserver(this);
  83     NetworkChangeNotifier::AddNetworkChangeObserver(this);
  84   }
  85
  86   ~HistogramWatcher() override {
  87     DCHECK(thread_checker_.CalledOnValidThread());
  88     DCHECK(g_network_change_notifier);
  89     NetworkChangeNotifier::RemoveConnectionTypeObserver(this);
  90     NetworkChangeNotifier::RemoveIPAddressObserver(this);
  91     NetworkChangeNotifier::RemoveDNSObserver(this);
  92     NetworkChangeNotifier::RemoveNetworkChangeObserver(this);
  93   }
  94
  95   // NetworkChangeNotifier::IPAddressObserver implementation.
  96   void OnIPAddressChanged() override {
  97     DCHECK(thread_checker_.CalledOnValidThread());
  98     UMA_HISTOGRAM_MEDIUM_TIMES("NCN.IPAddressChange",
  99                                SinceLast(&last_ip_address_change_));
 100     UMA_HISTOGRAM_MEDIUM_TIMES(
 101         "NCN.ConnectionTypeChangeToIPAddressChange",
 102         last_ip_address_change_ - last_connection_change_);
 103   }
 104
 105   // NetworkChangeNotifier::ConnectionTypeObserver implementation.
 106   void OnConnectionTypeChanged(
 107       NetworkChangeNotifier::ConnectionType type) override {
 108     DCHECK(thread_checker_.CalledOnValidThread());
 109     base::TimeTicks now = base::TimeTicks::Now();
 110     int32 kilobytes_read = bytes_read_since_last_connection_change_ / 1000;
 111     base::TimeDelta state_duration = SinceLast(&last_connection_change_);
 112     if (bytes_read_since_last_connection_change_) {
 113       switch (last_connection_type_) {
 114         case NetworkChangeNotifier::CONNECTION_UNKNOWN:
 115           UMA_HISTOGRAM_TIMES("NCN.CM.FirstReadOnUnknown",
 116                               first_byte_after_connection_change_);
 117           UMA_HISTOGRAM_TIMES("NCN.CM.FastestRTTOnUnknown",
 118                               fastest_RTT_since_last_connection_change_);
 119           break;
 120         case NetworkChangeNotifier::CONNECTION_ETHERNET:
 121           UMA_HISTOGRAM_TIMES("NCN.CM.FirstReadOnEthernet",
 122                               first_byte_after_connection_change_);
 123           UMA_HISTOGRAM_TIMES("NCN.CM.FastestRTTOnEthernet",
 124                               fastest_RTT_since_last_connection_change_);
 125           break;
 126         case NetworkChangeNotifier::CONNECTION_WIFI:
 127           UMA_HISTOGRAM_TIMES("NCN.CM.FirstReadOnWifi",
 128                               first_byte_after_connection_change_);
 129           UMA_HISTOGRAM_TIMES("NCN.CM.FastestRTTOnWifi",
 130                               fastest_RTT_since_last_connection_change_);
 131           break;
 132         case NetworkChangeNotifier::CONNECTION_2G:
 133           UMA_HISTOGRAM_TIMES("NCN.CM.FirstReadOn2G",
 134                               first_byte_after_connection_change_);
 135           UMA_HISTOGRAM_TIMES("NCN.CM.FastestRTTOn2G",
 136                               fastest_RTT_since_last_connection_change_);
 137           break;
 138         case NetworkChangeNotifier::CONNECTION_3G:
 139           UMA_HISTOGRAM_TIMES("NCN.CM.FirstReadOn3G",
 140                               first_byte_after_connection_change_);
 141           UMA_HISTOGRAM_TIMES("NCN.CM.FastestRTTOn3G",
 142                               fastest_RTT_since_last_connection_change_);
 143           break;
 144         case NetworkChangeNotifier::CONNECTION_4G:
 145           UMA_HISTOGRAM_TIMES("NCN.CM.FirstReadOn4G",
 146                               first_byte_after_connection_change_);
 147           UMA_HISTOGRAM_TIMES("NCN.CM.FastestRTTOn4G",
 148                               fastest_RTT_since_last_connection_change_);
 149           break;
 150         case NetworkChangeNotifier::CONNECTION_NONE:
 151           UMA_HISTOGRAM_TIMES("NCN.CM.FirstReadOnNone",
 152                               first_byte_after_connection_change_);
 153           UMA_HISTOGRAM_TIMES("NCN.CM.FastestRTTOnNone",
 154                               fastest_RTT_since_last_connection_change_);
 155           break;
 156         case NetworkChangeNotifier::CONNECTION_BLUETOOTH:
 157           UMA_HISTOGRAM_TIMES("NCN.CM.FirstReadOnBluetooth",
 158                               first_byte_after_connection_change_);
 159           UMA_HISTOGRAM_TIMES("NCN.CM.FastestRTTOnBluetooth",
 160                               fastest_RTT_since_last_connection_change_);
 161       }
 162     }
 163     if (peak_kbps_since_last_connection_change_) {
 164       switch (last_connection_type_) {
 165         case NetworkChangeNotifier::CONNECTION_UNKNOWN:
 166           UMA_HISTOGRAM_COUNTS("NCN.CM.PeakKbpsOnUnknown",
 167                                peak_kbps_since_last_connection_change_);
 168           break;
 169         case NetworkChangeNotifier::CONNECTION_ETHERNET:
 170           UMA_HISTOGRAM_COUNTS("NCN.CM.PeakKbpsOnEthernet",
 171                                peak_kbps_since_last_connection_change_);
 172           break;
 173         case NetworkChangeNotifier::CONNECTION_WIFI:
 174           UMA_HISTOGRAM_COUNTS("NCN.CM.PeakKbpsOnWifi",
 175                                peak_kbps_since_last_connection_change_);
 176           break;
 177         case NetworkChangeNotifier::CONNECTION_2G:
 178           UMA_HISTOGRAM_COUNTS("NCN.CM.PeakKbpsOn2G",
 179                                peak_kbps_since_last_connection_change_);
 180           break;
 181         case NetworkChangeNotifier::CONNECTION_3G:
 182           UMA_HISTOGRAM_COUNTS("NCN.CM.PeakKbpsOn3G",
 183                                peak_kbps_since_last_connection_change_);
 184           break;
 185         case NetworkChangeNotifier::CONNECTION_4G:
 186           UMA_HISTOGRAM_COUNTS("NCN.CM.PeakKbpsOn4G",
 187                                peak_kbps_since_last_connection_change_);
 188           break;
 189         case NetworkChangeNotifier::CONNECTION_NONE:
 190           UMA_HISTOGRAM_COUNTS("NCN.CM.PeakKbpsOnNone",
 191                                peak_kbps_since_last_connection_change_);
 192           break;
 193         case NetworkChangeNotifier::CONNECTION_BLUETOOTH:
 194           UMA_HISTOGRAM_COUNTS("NCN.CM.PeakKbpsOnBluetooth",
 195                                peak_kbps_since_last_connection_change_);
 196           break;
 197       }
 198     }
 199     switch (last_connection_type_) {
 200       case NetworkChangeNotifier::CONNECTION_UNKNOWN:
 201         UMA_HISTOGRAM_LONG_TIMES("NCN.CM.TimeOnUnknown", state_duration);
 202         UMA_HISTOGRAM_COUNTS("NCN.CM.KBTransferedOnUnknown", kilobytes_read);
 203         break;
 204       case NetworkChangeNotifier::CONNECTION_ETHERNET:
 205         UMA_HISTOGRAM_LONG_TIMES("NCN.CM.TimeOnEthernet", state_duration);
 206         UMA_HISTOGRAM_COUNTS("NCN.CM.KBTransferedOnEthernet", kilobytes_read);
 207         break;
 208       case NetworkChangeNotifier::CONNECTION_WIFI:
 209         UMA_HISTOGRAM_LONG_TIMES("NCN.CM.TimeOnWifi", state_duration);
 210         UMA_HISTOGRAM_COUNTS("NCN.CM.KBTransferedOnWifi", kilobytes_read);
 211         break;
 212       case NetworkChangeNotifier::CONNECTION_2G:
 213         UMA_HISTOGRAM_LONG_TIMES("NCN.CM.TimeOn2G", state_duration);
 214         UMA_HISTOGRAM_COUNTS("NCN.CM.KBTransferedOn2G", kilobytes_read);
 215         break;
 216       case NetworkChangeNotifier::CONNECTION_3G:
 217         UMA_HISTOGRAM_LONG_TIMES("NCN.CM.TimeOn3G", state_duration);
 218         UMA_HISTOGRAM_COUNTS("NCN.CM.KBTransferedOn3G", kilobytes_read);
 219         break;
 220       case NetworkChangeNotifier::CONNECTION_4G:
 221         UMA_HISTOGRAM_LONG_TIMES("NCN.CM.TimeOn4G", state_duration);
 222         UMA_HISTOGRAM_COUNTS("NCN.CM.KBTransferedOn4G", kilobytes_read);
 223         break;
 224       case NetworkChangeNotifier::CONNECTION_NONE:
 225         UMA_HISTOGRAM_LONG_TIMES("NCN.CM.TimeOnNone", state_duration);
 226         UMA_HISTOGRAM_COUNTS("NCN.CM.KBTransferedOnNone", kilobytes_read);
 227         break;
 228       case NetworkChangeNotifier::CONNECTION_BLUETOOTH:
 229         UMA_HISTOGRAM_LONG_TIMES("NCN.CM.TimeOnBluetooth", state_duration);
 230         UMA_HISTOGRAM_COUNTS("NCN.CM.KBTransferedOnBluetooth", kilobytes_read);
 231         break;
 232     }
 233
 234     if (type != NetworkChangeNotifier::CONNECTION_NONE) {
 235       UMA_HISTOGRAM_MEDIUM_TIMES("NCN.OnlineChange", state_duration);
 236
 237       if (offline_packets_received_) {
 238         if ((now - last_offline_packet_received_) <
 239             base::TimeDelta::FromSeconds(5)) {
 240           // We can compare this sum with the sum of NCN.OfflineDataRecv.
 241           UMA_HISTOGRAM_COUNTS_10000(
 242               "NCN.OfflineDataRecvAny5sBeforeOnline",
 243               offline_packets_received_);
 244         }
 245
 246         UMA_HISTOGRAM_MEDIUM_TIMES("NCN.OfflineDataRecvUntilOnline",
 247                                    now - last_offline_packet_received_);
 248       }
 249     } else {
 250       UMA_HISTOGRAM_MEDIUM_TIMES("NCN.OfflineChange", state_duration);
 251     }
 252
 253     NetworkChangeNotifier::LogOperatorCodeHistogram(type);
 254
 255     UMA_HISTOGRAM_MEDIUM_TIMES(
 256         "NCN.IPAddressChangeToConnectionTypeChange",
 257         now - last_ip_address_change_);
 258
 259     offline_packets_received_ = 0;
 260     bytes_read_since_last_connection_change_ = 0;
 261     peak_kbps_since_last_connection_change_ = 0;
 262     last_connection_type_ = type;
 263     polling_interval_ = base::TimeDelta::FromSeconds(1);
 264   }
 265
 266   // NetworkChangeNotifier::DNSObserver implementation.
 267   void OnDNSChanged() override {
 268     DCHECK(thread_checker_.CalledOnValidThread());
 269     UMA_HISTOGRAM_MEDIUM_TIMES("NCN.DNSConfigChange",
 270                                SinceLast(&last_dns_change_));
 271   }
 272
 273   // NetworkChangeNotifier::NetworkChangeObserver implementation.
 274   void OnNetworkChanged(NetworkChangeNotifier::ConnectionType type) override {
 275     DCHECK(thread_checker_.CalledOnValidThread());
 276     if (type != NetworkChangeNotifier::CONNECTION_NONE) {
 277       UMA_HISTOGRAM_MEDIUM_TIMES("NCN.NetworkOnlineChange",
 278                                  SinceLast(&last_network_change_));
 279     } else {
 280       UMA_HISTOGRAM_MEDIUM_TIMES("NCN.NetworkOfflineChange",
 281                                  SinceLast(&last_network_change_));
 282     }
 283   }
 284
 285   // Record histogram data whenever we receive a packet. Should only be called
 286   // from the network thread.
 287   void NotifyDataReceived(const URLRequest& request, int bytes_read) {
 288     DCHECK(thread_checker_.CalledOnValidThread());
 289     if (IsLocalhost(request.url().host()) ||
 290         !request.url().SchemeIsHTTPOrHTTPS()) {
 291       return;
 292     }
 293
 294     base::TimeTicks now = base::TimeTicks::Now();
 295     base::TimeDelta request_duration = now - request.creation_time();
 296     if (bytes_read_since_last_connection_change_ == 0) {
 297       first_byte_after_connection_change_ = now - last_connection_change_;
 298       fastest_RTT_since_last_connection_change_ = request_duration;
 299     }
 300     bytes_read_since_last_connection_change_ += bytes_read;
 301     if (request_duration < fastest_RTT_since_last_connection_change_)
 302       fastest_RTT_since_last_connection_change_ = request_duration;
 303     // Ignore tiny transfers which will not produce accurate rates.
 304     // Ignore zero duration transfers which might cause divide by zero.
 305     if (bytes_read > 10000 &&
 306         request_duration > base::TimeDelta::FromMilliseconds(1) &&
 307         request.creation_time() > last_connection_change_) {
 308       int32 kbps = static_cast<int32>(
 309           bytes_read * 8 / request_duration.InMilliseconds());
 310       if (kbps > peak_kbps_since_last_connection_change_)
 311         peak_kbps_since_last_connection_change_ = kbps;
 312     }
 313
 314     if (last_connection_type_ != NetworkChangeNotifier::CONNECTION_NONE)
 315       return;
 316
 317     UMA_HISTOGRAM_MEDIUM_TIMES("NCN.OfflineDataRecv",
 318                                now - last_connection_change_);
 319     offline_packets_received_++;
 320     last_offline_packet_received_ = now;
 321
 322     if ((now - last_polled_connection_) > polling_interval_) {
 323       polling_interval_ *= 2;
 324       last_polled_connection_ = now;
 325       last_polled_connection_type_ =
 326           NetworkChangeNotifier::GetConnectionType();
 327     }
 328     if (last_polled_connection_type_ ==
 329         NetworkChangeNotifier::CONNECTION_NONE) {
 330       UMA_HISTOGRAM_MEDIUM_TIMES("NCN.PollingOfflineDataRecv",
 331                                  now - last_connection_change_);
 332     }
 333   }
 334
 335  private:
 336   static base::TimeDelta SinceLast(base::TimeTicks *last_time) {
 337     base::TimeTicks current_time = base::TimeTicks::Now();
 338     base::TimeDelta delta = current_time - *last_time;
 339     *last_time = current_time;
 340     return delta;
 341   }
 342
 343   base::TimeTicks last_ip_address_change_;
 344   base::TimeTicks last_connection_change_;
 345   base::TimeTicks last_dns_change_;
 346   base::TimeTicks last_network_change_;
 347   base::TimeTicks last_offline_packet_received_;
 348   base::TimeTicks last_polled_connection_;
 349   // |polling_interval_| is initialized by |OnConnectionTypeChanged| on our
 350   // first transition to offline and on subsequent transitions.  Once offline,
 351   // |polling_interval_| doubles as offline data is received and we poll
 352   // with |NetworkChangeNotifier::GetConnectionType| to verify the connection
 353   // state.
 354   base::TimeDelta polling_interval_;
 355   // |last_connection_type_| is the last value passed to
 356   // |OnConnectionTypeChanged|.
 357   NetworkChangeNotifier::ConnectionType last_connection_type_;
 358   // |last_polled_connection_type_| is last result from calling
 359   // |NetworkChangeNotifier::GetConnectionType| in |NotifyDataReceived|.
 360   NetworkChangeNotifier::ConnectionType last_polled_connection_type_;
 361   // Count of how many times NotifyDataReceived() has been called while the
 362   // NetworkChangeNotifier thought network connection was offline.
 363   int32 offline_packets_received_;
 364   // Number of bytes of network data received since last connectivity change.
 365   int32 bytes_read_since_last_connection_change_;
 366   // Fastest round-trip-time (RTT) since last connectivity change. RTT measured
 367   // from URLRequest creation until first byte received.
 368   base::TimeDelta fastest_RTT_since_last_connection_change_;
 369   // Time between connectivity change and first network data byte received.
 370   base::TimeDelta first_byte_after_connection_change_;
 371   // Rough measurement of peak KB/s witnessed since last connectivity change.
 372   // The accuracy is decreased by ignoring these factors:
 373   // 1) Multiple URLRequests can occur concurrently.
 374   // 2) NotifyDataReceived() may be called repeatedly for one URLRequest.
 375   // 3) The transfer time includes at least one RTT while no bytes are read.
 376   // Erring on the conservative side is hopefully offset by taking the maximum.
 377   int32 peak_kbps_since_last_connection_change_;
 378
 379   base::ThreadChecker thread_checker_;
 380
 381   DISALLOW_COPY_AND_ASSIGN(HistogramWatcher);
 382 };
 383
 384 // NetworkState is thread safe.
 385 class NetworkChangeNotifier::NetworkState {
 386  public:
 387   NetworkState() {}
 388   ~NetworkState() {}
 389
 390   void GetDnsConfig(DnsConfig* config) const {
 391     base::AutoLock lock(lock_);
 392     *config = dns_config_;
 393   }
 394
 395   void SetDnsConfig(const DnsConfig& dns_config) {
 396     base::AutoLock lock(lock_);
 397     dns_config_ = dns_config;
 398   }
 399
 400  private:
 401   mutable base::Lock lock_;
 402   DnsConfig dns_config_;
 403 };
 404
 405 NetworkChangeNotifier::NetworkChangeCalculatorParams::
 406     NetworkChangeCalculatorParams() {
 407 }
 408
 409 // Calculates NetworkChange signal from IPAddress and ConnectionType signals.
 410 class NetworkChangeNotifier::NetworkChangeCalculator
 411     : public ConnectionTypeObserver,
 412       public IPAddressObserver {
 413  public:
 414   NetworkChangeCalculator(const NetworkChangeCalculatorParams& params)
 415       : params_(params),
 416         have_announced_(false),
 417         last_announced_connection_type_(CONNECTION_NONE),
 418         pending_connection_type_(CONNECTION_NONE) {}
 419
 420   void Init() {
 421     DCHECK(thread_checker_.CalledOnValidThread());
 422     DCHECK(g_network_change_notifier);
 423     AddConnectionTypeObserver(this);
 424     AddIPAddressObserver(this);
 425   }
 426
 427   ~NetworkChangeCalculator() override {
 428     DCHECK(thread_checker_.CalledOnValidThread());
 429     DCHECK(g_network_change_notifier);
 430     RemoveConnectionTypeObserver(this);
 431     RemoveIPAddressObserver(this);
 432   }
 433
 434   // NetworkChangeNotifier::IPAddressObserver implementation.
 435   void OnIPAddressChanged() override {
 436     DCHECK(thread_checker_.CalledOnValidThread());
 437     base::TimeDelta delay = last_announced_connection_type_ == CONNECTION_NONE
 438         ? params_.ip_address_offline_delay_ : params_.ip_address_online_delay_;
 439     // Cancels any previous timer.
 440     timer_.Start(FROM_HERE, delay, this, &NetworkChangeCalculator::Notify);
 441   }
 442
 443   // NetworkChangeNotifier::ConnectionTypeObserver implementation.
 444   void OnConnectionTypeChanged(ConnectionType type) override {
 445     DCHECK(thread_checker_.CalledOnValidThread());
 446     pending_connection_type_ = type;
 447     base::TimeDelta delay = last_announced_connection_type_ == CONNECTION_NONE
 448         ? params_.connection_type_offline_delay_
 449         : params_.connection_type_online_delay_;
 450     // Cancels any previous timer.
 451     timer_.Start(FROM_HERE, delay, this, &NetworkChangeCalculator::Notify);
 452   }
 453
 454  private:
 455   void Notify() {
 456     DCHECK(thread_checker_.CalledOnValidThread());
 457     // Don't bother signaling about dead connections.
 458     if (have_announced_ &&
 459         (last_announced_connection_type_ == CONNECTION_NONE) &&
 460         (pending_connection_type_ == CONNECTION_NONE)) {
 461       return;
 462     }
 463     have_announced_ = true;
 464     last_announced_connection_type_ = pending_connection_type_;
 465     // Immediately before sending out an online signal, send out an offline
 466     // signal to perform any destructive actions before constructive actions.
 467     if (pending_connection_type_ != CONNECTION_NONE)
 468       NetworkChangeNotifier::NotifyObserversOfNetworkChange(CONNECTION_NONE);
 469     NetworkChangeNotifier::NotifyObserversOfNetworkChange(
 470         pending_connection_type_);
 471   }
 472
 473   const NetworkChangeCalculatorParams params_;
 474
 475   // Indicates if NotifyObserversOfNetworkChange has been called yet.
 476   bool have_announced_;
 477   // Last value passed to NotifyObserversOfNetworkChange.
 478   ConnectionType last_announced_connection_type_;
 479   // Value to pass to NotifyObserversOfNetworkChange when Notify is called.
 480   ConnectionType pending_connection_type_;
 481   // Used to delay notifications so duplicates can be combined.
 482   base::OneShotTimer<NetworkChangeCalculator> timer_;
 483
 484   base::ThreadChecker thread_checker_;
 485
 486   DISALLOW_COPY_AND_ASSIGN(NetworkChangeCalculator);
 487 };
 488
 489 NetworkChangeNotifier::~NetworkChangeNotifier() {
 490   network_change_calculator_.reset();
 491   DCHECK_EQ(this, g_network_change_notifier);
 492   g_network_change_notifier = NULL;
 493 }
 494
 495 // static
 496 void NetworkChangeNotifier::SetFactory(
 497     NetworkChangeNotifierFactory* factory) {
 498   CHECK(!g_network_change_notifier_factory);
 499   g_network_change_notifier_factory = factory;
 500 }
 501
 502 // static
 503 NetworkChangeNotifier* NetworkChangeNotifier::Create() {
 504   if (g_network_change_notifier_factory)
 505     return g_network_change_notifier_factory->CreateInstance();
 506
 507 #if defined(OS_WIN)
 508   NetworkChangeNotifierWin* network_change_notifier =
 509       new NetworkChangeNotifierWin();
 510   network_change_notifier->WatchForAddressChange();
 511   return network_change_notifier;
 512 #elif defined(OS_CHROMEOS) || defined(OS_ANDROID)
 513   // ChromeOS and Android builds MUST use their own class factory.
 514 #if !defined(OS_CHROMEOS)
 515   // TODO(oshima): ash_shell do not have access to chromeos'es
 516   // notifier yet. Re-enable this when chromeos'es notifier moved to
 517   // chromeos root directory. crbug.com/119298.
 518   CHECK(false);
 519 #endif
 520   return NULL;
 521 #elif defined(OS_LINUX)
 522   return NetworkChangeNotifierLinux::Create();
 523 #elif defined(OS_MACOSX)
 524   return new NetworkChangeNotifierMac();
 525 #else
 526   NOTIMPLEMENTED();
 527   return NULL;
 528 #endif
 529 }
 530
 531 // static
 532 NetworkChangeNotifier::ConnectionType
 533 NetworkChangeNotifier::GetConnectionType() {
 534   return g_network_change_notifier ?
 535       g_network_change_notifier->GetCurrentConnectionType() :
 536       CONNECTION_UNKNOWN;
 537 }
 538
 539 // static
 540 double NetworkChangeNotifier::GetMaxBandwidth() {
 541   return g_network_change_notifier ?
 542       g_network_change_notifier->GetCurrentMaxBandwidth() :
 543       std::numeric_limits<double>::infinity();
 544 }
 545
 546 // static
 547 void NetworkChangeNotifier::GetDnsConfig(DnsConfig* config) {
 548   if (!g_network_change_notifier) {
 549     *config = DnsConfig();
 550   } else {
 551     g_network_change_notifier->network_state_->GetDnsConfig(config);
 552   }
 553 }
 554
 555 // static
 556 const char* NetworkChangeNotifier::ConnectionTypeToString(
 557     ConnectionType type) {
 558   static const char* const kConnectionTypeNames[] = {
 559     "CONNECTION_UNKNOWN",
 560     "CONNECTION_ETHERNET",
 561     "CONNECTION_WIFI",
 562     "CONNECTION_2G",
 563     "CONNECTION_3G",
 564     "CONNECTION_4G",
 565     "CONNECTION_NONE",
 566     "CONNECTION_BLUETOOTH"
 567   };
 568   static_assert(arraysize(kConnectionTypeNames) ==
 569                     NetworkChangeNotifier::CONNECTION_LAST + 1,
 570                 "ConnectionType name count should match");
 571   if (type < CONNECTION_UNKNOWN || type > CONNECTION_LAST) {
 572     NOTREACHED();
 573     return "CONNECTION_INVALID";
 574   }
 575   return kConnectionTypeNames[type];
 576 }
 577
 578 // static
 579 void NetworkChangeNotifier::NotifyDataReceived(const URLRequest& request,
 580                                                int bytes_read) {
 581   if (!g_network_change_notifier ||
 582       !g_network_change_notifier->histogram_watcher_) {
 583     return;
 584   }
 585   g_network_change_notifier->histogram_watcher_->NotifyDataReceived(request,
 586                                                                     bytes_read);
 587 }
 588
 589 // static
 590 void NetworkChangeNotifier::InitHistogramWatcher() {
 591   if (!g_network_change_notifier)
 592     return;
 593   g_network_change_notifier->histogram_watcher_.reset(new HistogramWatcher());
 594   g_network_change_notifier->histogram_watcher_->Init();
 595 }
 596
 597 // static
 598 void NetworkChangeNotifier::ShutdownHistogramWatcher() {
 599   if (!g_network_change_notifier)
 600     return;
 601   g_network_change_notifier->histogram_watcher_.reset();
 602 }
 603
 604 // static
 605 void NetworkChangeNotifier::LogOperatorCodeHistogram(ConnectionType type) {
 606 #if defined(OS_ANDROID)
 607   // On a connection type change to 2/3/4G, log the network operator MCC/MNC.
 608   // Log zero in other cases.
 609   unsigned mcc_mnc = 0;
 610   if (type == NetworkChangeNotifier::CONNECTION_2G ||
 611       type == NetworkChangeNotifier::CONNECTION_3G ||
 612       type == NetworkChangeNotifier::CONNECTION_4G) {
 613     // Log zero if not perfectly converted.
 614     if (!base::StringToUint(
 615         net::android::GetTelephonyNetworkOperator(), &mcc_mnc)) {
 616       mcc_mnc = 0;
 617     }
 618   }
 619   UMA_HISTOGRAM_SPARSE_SLOWLY("NCN.NetworkOperatorMCCMNC", mcc_mnc);
 620 #endif
 621 }
 622
 623 #if defined(OS_LINUX)
 624 // static
 625 const internal::AddressTrackerLinux*
 626 NetworkChangeNotifier::GetAddressTracker() {
 627   return g_network_change_notifier ?
 628         g_network_change_notifier->GetAddressTrackerInternal() : NULL;
 629 }
 630 #endif
 631
 632 // static
 633 bool NetworkChangeNotifier::IsOffline() {
 634    return GetConnectionType() == CONNECTION_NONE;
 635 }
 636
 637 // static
 638 bool NetworkChangeNotifier::IsConnectionCellular(ConnectionType type) {
 639   bool is_cellular = false;
 640   switch (type) {
 641     case CONNECTION_2G:
 642     case CONNECTION_3G:
 643     case CONNECTION_4G:
 644       is_cellular =  true;
 645       break;
 646     case CONNECTION_UNKNOWN:
 647     case CONNECTION_ETHERNET:
 648     case CONNECTION_WIFI:
 649     case CONNECTION_NONE:
 650     case CONNECTION_BLUETOOTH:
 651       is_cellular = false;
 652       break;
 653   }
 654   return is_cellular;
 655 }
 656
 657 // static
 658 NetworkChangeNotifier::ConnectionType
 659 NetworkChangeNotifier::ConnectionTypeFromInterfaceList(
 660     const NetworkInterfaceList& interfaces) {
 661   bool first = true;
 662   ConnectionType result = CONNECTION_NONE;
 663   for (size_t i = 0; i < interfaces.size(); ++i) {
 664 #if defined(OS_WIN)
 665     if (interfaces[i].friendly_name == "Teredo Tunneling Pseudo-Interface")
 666       continue;
 667 #endif
 668     if (first) {
 669       first = false;
 670       result = interfaces[i].type;
 671     } else if (result != interfaces[i].type) {
 672       return CONNECTION_UNKNOWN;
 673     }
 674   }
 675   return result;
 676 }
 677
 678 // static
 679 NetworkChangeNotifier* NetworkChangeNotifier::CreateMock() {
 680   return new MockNetworkChangeNotifier();
 681 }
 682
 683 void NetworkChangeNotifier::AddIPAddressObserver(IPAddressObserver* observer) {
 684   if (g_network_change_notifier)
 685     g_network_change_notifier->ip_address_observer_list_->AddObserver(observer);
 686 }
 687
 688 void NetworkChangeNotifier::AddConnectionTypeObserver(
 689     ConnectionTypeObserver* observer) {
 690   if (g_network_change_notifier) {
 691     g_network_change_notifier->connection_type_observer_list_->AddObserver(
 692         observer);
 693   }
 694 }
 695
 696 void NetworkChangeNotifier::AddDNSObserver(DNSObserver* observer) {
 697   if (g_network_change_notifier) {
 698     g_network_change_notifier->resolver_state_observer_list_->AddObserver(
 699         observer);
 700   }
 701 }
 702
 703 void NetworkChangeNotifier::AddNetworkChangeObserver(
 704     NetworkChangeObserver* observer) {
 705   if (g_network_change_notifier) {
 706     g_network_change_notifier->network_change_observer_list_->AddObserver(
 707         observer);
 708   }
 709 }
 710
 711 void NetworkChangeNotifier::AddMaxBandwidthObserver(
 712     MaxBandwidthObserver* observer) {
 713   if (g_network_change_notifier) {
 714     g_network_change_notifier->max_bandwidth_observer_list_->AddObserver(
 715         observer);
 716   }
 717 }
 718
 719 void NetworkChangeNotifier::RemoveIPAddressObserver(
 720     IPAddressObserver* observer) {
 721   if (g_network_change_notifier) {
 722     g_network_change_notifier->ip_address_observer_list_->RemoveObserver(
 723         observer);
 724   }
 725 }
 726
 727 void NetworkChangeNotifier::RemoveConnectionTypeObserver(
 728     ConnectionTypeObserver* observer) {
 729   if (g_network_change_notifier) {
 730     g_network_change_notifier->connection_type_observer_list_->RemoveObserver(
 731         observer);
 732   }
 733 }
 734
 735 void NetworkChangeNotifier::RemoveDNSObserver(DNSObserver* observer) {
 736   if (g_network_change_notifier) {
 737     g_network_change_notifier->resolver_state_observer_list_->RemoveObserver(
 738         observer);
 739   }
 740 }
 741
 742 void NetworkChangeNotifier::RemoveNetworkChangeObserver(
 743     NetworkChangeObserver* observer) {
 744   if (g_network_change_notifier) {
 745     g_network_change_notifier->network_change_observer_list_->RemoveObserver(
 746         observer);
 747   }
 748 }
 749
 750 void NetworkChangeNotifier::RemoveMaxBandwidthObserver(
 751     MaxBandwidthObserver* observer) {
 752   if (g_network_change_notifier) {
 753     g_network_change_notifier->max_bandwidth_observer_list_->RemoveObserver(
 754         observer);
 755   }
 756 }
 757
 758 // static
 759 void NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests() {
 760   if (g_network_change_notifier)
 761     g_network_change_notifier->NotifyObserversOfIPAddressChangeImpl();
 762 }
 763
 764 // static
 765 void NetworkChangeNotifier::NotifyObserversOfConnectionTypeChangeForTests(
 766     ConnectionType type) {
 767   if (g_network_change_notifier)
 768     g_network_change_notifier->NotifyObserversOfConnectionTypeChangeImpl(type);
 769 }
 770
 771 // static
 772 void NetworkChangeNotifier::NotifyObserversOfNetworkChangeForTests(
 773     ConnectionType type) {
 774   if (g_network_change_notifier)
 775     g_network_change_notifier->NotifyObserversOfNetworkChangeImpl(type);
 776 }
 777
 778 // static
 779 void NetworkChangeNotifier::SetTestNotificationsOnly(bool test_only) {
 780   if (g_network_change_notifier)
 781     g_network_change_notifier->test_notifications_only_ = test_only;
 782 }
 783
 784 NetworkChangeNotifier::NetworkChangeNotifier(
 785     const NetworkChangeCalculatorParams& params
 786     /*= NetworkChangeCalculatorParams()*/)
 787     : ip_address_observer_list_(new ObserverListThreadSafe<IPAddressObserver>(
 788           ObserverListBase<IPAddressObserver>::NOTIFY_EXISTING_ONLY)),
 789       connection_type_observer_list_(
 790           new ObserverListThreadSafe<ConnectionTypeObserver>(
 791               ObserverListBase<ConnectionTypeObserver>::NOTIFY_EXISTING_ONLY)),
 792       resolver_state_observer_list_(new ObserverListThreadSafe<DNSObserver>(
 793           ObserverListBase<DNSObserver>::NOTIFY_EXISTING_ONLY)),
 794       network_change_observer_list_(
 795           new ObserverListThreadSafe<NetworkChangeObserver>(
 796               ObserverListBase<NetworkChangeObserver>::NOTIFY_EXISTING_ONLY)),
 797       max_bandwidth_observer_list_(
 798           new ObserverListThreadSafe<MaxBandwidthObserver>(
 799               ObserverListBase<MaxBandwidthObserver>::NOTIFY_EXISTING_ONLY)),
 800       network_state_(new NetworkState()),
 801       network_change_calculator_(new NetworkChangeCalculator(params)),
 802       test_notifications_only_(false) {
 803   DCHECK(!g_network_change_notifier);
 804   g_network_change_notifier = this;
 805   network_change_calculator_->Init();
 806 }
 807
 808 #if defined(OS_LINUX)
 809 const internal::AddressTrackerLinux*
 810 NetworkChangeNotifier::GetAddressTrackerInternal() const {
 811   return NULL;
 812 }
 813 #endif
 814
 815 double NetworkChangeNotifier::GetCurrentMaxBandwidth() const {
 816   // This default implementation conforms to the NetInfo V3 specification but
 817   // should be overridden to provide specific bandwidth data based on the
 818   // platform.
 819   if (GetCurrentConnectionType() == CONNECTION_NONE)
 820     return 0.0;
 821   return std::numeric_limits<double>::infinity();
 822 }
 823
 824 // static
 825 double NetworkChangeNotifier::GetMaxBandwidthForConnectionSubtype(
 826     ConnectionSubtype subtype) {
 827   switch (subtype) {
 828     case SUBTYPE_GSM:
 829       return 0.01;
 830     case SUBTYPE_IDEN:
 831       return 0.064;
 832     case SUBTYPE_CDMA:
 833       return 0.115;
 834     case SUBTYPE_1XRTT:
 835       return 0.153;
 836     case SUBTYPE_GPRS:
 837       return 0.237;
 838     case SUBTYPE_EDGE:
 839       return 0.384;
 840     case SUBTYPE_UMTS:
 841       return 2.0;
 842     case SUBTYPE_EVDO_REV_0:
 843       return 2.46;
 844     case SUBTYPE_EVDO_REV_A:
 845       return 3.1;
 846     case SUBTYPE_HSPA:
 847       return 3.6;
 848     case SUBTYPE_EVDO_REV_B:
 849       return 14.7;
 850     case SUBTYPE_HSDPA:
 851       return 14.3;
 852     case SUBTYPE_HSUPA:
 853       return 14.4;
 854     case SUBTYPE_EHRPD:
 855       return 21.0;
 856     case SUBTYPE_HSPAP:
 857       return 42.0;
 858     case SUBTYPE_LTE:
 859       return 100.0;
 860     case SUBTYPE_LTE_ADVANCED:
 861       return 100.0;
 862     case SUBTYPE_BLUETOOTH_1_2:
 863       return 1.0;
 864     case SUBTYPE_BLUETOOTH_2_1:
 865       return 3.0;
 866     case SUBTYPE_BLUETOOTH_3_0:
 867       return 24.0;
 868     case SUBTYPE_BLUETOOTH_4_0:
 869       return 1.0;
 870     case SUBTYPE_ETHERNET:
 871       return 10.0;
 872     case SUBTYPE_FAST_ETHERNET:
 873       return 100.0;
 874     case SUBTYPE_GIGABIT_ETHERNET:
 875       return 1000.0;
 876     case SUBTYPE_10_GIGABIT_ETHERNET:
 877       return 10000.0;
 878     case SUBTYPE_WIFI_B:
 879       return 11.0;
 880     case SUBTYPE_WIFI_G:
 881       return 54.0;
 882     case SUBTYPE_WIFI_N:
 883       return 600.0;
 884     case SUBTYPE_WIFI_AC:
 885       return 1300.0;
 886     case SUBTYPE_WIFI_AD:
 887       return 7000.0;
 888     case SUBTYPE_UNKNOWN:
 889       return std::numeric_limits<double>::infinity();
 890     case SUBTYPE_NONE:
 891       return 0.0;
 892     case SUBTYPE_OTHER:
 893       return std::numeric_limits<double>::infinity();
 894   }
 895   NOTREACHED();
 896   return std::numeric_limits<double>::infinity();
 897 }
 898
 899 // static
 900 void NetworkChangeNotifier::NotifyObserversOfIPAddressChange() {
 901   if (g_network_change_notifier &&
 902       !g_network_change_notifier->test_notifications_only_) {
 903     g_network_change_notifier->NotifyObserversOfIPAddressChangeImpl();
 904   }
 905 }
 906
 907 // static
 908 void NetworkChangeNotifier::NotifyObserversOfConnectionTypeChange() {
 909   if (g_network_change_notifier &&
 910       !g_network_change_notifier->test_notifications_only_) {
 911     g_network_change_notifier->NotifyObserversOfConnectionTypeChangeImpl(
 912         GetConnectionType());
 913   }
 914 }
 915
 916 // static
 917 void NetworkChangeNotifier::NotifyObserversOfNetworkChange(
 918     ConnectionType type) {
 919   if (g_network_change_notifier &&
 920       !g_network_change_notifier->test_notifications_only_) {
 921     g_network_change_notifier->NotifyObserversOfNetworkChangeImpl(type);
 922   }
 923 }
 924
 925 // static
 926 void NetworkChangeNotifier::NotifyObserversOfMaxBandwidthChange(
 927     double max_bandwidth_mbps) {
 928   if (g_network_change_notifier &&
 929       !g_network_change_notifier->test_notifications_only_) {
 930     g_network_change_notifier->NotifyObserversOfMaxBandwidthChangeImpl(
 931         max_bandwidth_mbps);
 932   }
 933 }
 934
 935 // static
 936 void NetworkChangeNotifier::NotifyObserversOfDNSChange() {
 937   if (g_network_change_notifier &&
 938       !g_network_change_notifier->test_notifications_only_) {
 939     g_network_change_notifier->NotifyObserversOfDNSChangeImpl();
 940   }
 941 }
 942
 943 // static
 944 void NetworkChangeNotifier::SetDnsConfig(const DnsConfig& config) {
 945   if (!g_network_change_notifier)
 946     return;
 947   g_network_change_notifier->network_state_->SetDnsConfig(config);
 948   NotifyObserversOfDNSChange();
 949 }
 950
 951 void NetworkChangeNotifier::NotifyObserversOfIPAddressChangeImpl() {
 952   ip_address_observer_list_->Notify(FROM_HERE,
 953                                     &IPAddressObserver::OnIPAddressChanged);
 954 }
 955
 956 void NetworkChangeNotifier::NotifyObserversOfConnectionTypeChangeImpl(
 957     ConnectionType type) {
 958   connection_type_observer_list_->Notify(
 959       FROM_HERE, &ConnectionTypeObserver::OnConnectionTypeChanged, type);
 960 }
 961
 962 void NetworkChangeNotifier::NotifyObserversOfNetworkChangeImpl(
 963     ConnectionType type) {
 964   network_change_observer_list_->Notify(
 965       FROM_HERE, &NetworkChangeObserver::OnNetworkChanged, type);
 966 }
 967
 968 void NetworkChangeNotifier::NotifyObserversOfDNSChangeImpl() {
 969   resolver_state_observer_list_->Notify(FROM_HERE, &DNSObserver::OnDNSChanged);
 970 }
 971
 972 void NetworkChangeNotifier::NotifyObserversOfMaxBandwidthChangeImpl(
 973     double max_bandwidth_mbps) {
 974   max_bandwidth_observer_list_->Notify(
 975       FROM_HERE, &MaxBandwidthObserver::OnMaxBandwidthChanged,
 976       max_bandwidth_mbps);
 977 }
 978
 979 NetworkChangeNotifier::DisableForTest::DisableForTest()
 980     : network_change_notifier_(g_network_change_notifier) {
 981   DCHECK(g_network_change_notifier);
 982   g_network_change_notifier = NULL;
 983 }
 984
 985 NetworkChangeNotifier::DisableForTest::~DisableForTest() {
 986   DCHECK(!g_network_change_notifier);
 987   g_network_change_notifier = network_change_notifier_;
 988 }
 989
 990 }  // namespace net