Switch from OnIPAddressChanged and OnConnectionTypeChange to OnNetworkChanged

net/base/network_change_notifier.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/base/network_change_notifier.h"
 
 #include "base/metrics/histogram.h"
 #include "base/synchronization/lock.h"
 #include "build/build_config.h"
 #include "googleurl/src/gurl.h"
@@ skipping 25 matching lines @@
 class MockNetworkChangeNotifier : public NetworkChangeNotifier {
  public:
   virtual ConnectionType GetCurrentConnectionType() const OVERRIDE {
     return CONNECTION_UNKNOWN;
   }
 };
 
 }  // namespace
 
 // The main observer class that records UMAs for network events.
-class HistogramWatcher
-    : public NetworkChangeNotifier::ConnectionTypeObserver,
-      public NetworkChangeNotifier::IPAddressObserver,
-      public NetworkChangeNotifier::DNSObserver,
-      public NetworkChangeNotifier::NetworkChangeObserver {
+class NetworkChangeNotifier::HistogramWatcher
+    : public ConnectionTypeObserver,
+      public IPAddressObserver,
+      public DNSObserver,
+      public NetworkChangeObserver {
  public:
   HistogramWatcher()
       : last_ip_address_change_(base::TimeTicks::Now()),
         last_connection_change_(base::TimeTicks::Now()),
         last_dns_change_(base::TimeTicks::Now()),
         last_network_change_(base::TimeTicks::Now()),
-        last_connection_type_(NetworkChangeNotifier::CONNECTION_UNKNOWN),
+        last_connection_type_(CONNECTION_UNKNOWN),
         offline_packets_received_(0) {}
 
   // Registers our three Observer implementations.  This is called from the
   // network thread so that our Observer implementations are also called
   // from the network thread.  This avoids multi-threaded race conditions
   // because the only other interface, |NotifyDataReceived| is also
   // only called from the network thread.
   void Init() {
-    NetworkChangeNotifier::AddConnectionTypeObserver(this);
-    NetworkChangeNotifier::AddIPAddressObserver(this);
-    NetworkChangeNotifier::AddDNSObserver(this);
-    NetworkChangeNotifier::AddNetworkChangeObserver(this);
+    Deprecated::AddConnectionTypeObserver(this);
+    Deprecated::AddIPAddressObserver(this);
+    AddDNSObserver(this);
+    AddNetworkChangeObserver(this);
   }
 
   virtual ~HistogramWatcher() {}
 
-  // NetworkChangeNotifier::IPAddressObserver implementation.
+  // IPAddressObserver implementation.
   virtual void OnIPAddressChanged() OVERRIDE {
     UMA_HISTOGRAM_MEDIUM_TIMES("NCN.IPAddressChange",
                                SinceLast(&last_ip_address_change_));
     UMA_HISTOGRAM_MEDIUM_TIMES(
         "NCN.ConnectionTypeChangeToIPAddressChange",
         last_ip_address_change_ - last_connection_change_);
   }
 
-  // NetworkChangeNotifier::ConnectionTypeObserver implementation.
-  virtual void OnConnectionTypeChanged(
-      NetworkChangeNotifier::ConnectionType type) OVERRIDE {
-    if (type != NetworkChangeNotifier::CONNECTION_NONE) {
+  // ConnectionTypeObserver implementation.
+  virtual void OnConnectionTypeChanged(ConnectionType type) OVERRIDE {
+    if (type != CONNECTION_NONE) {
       UMA_HISTOGRAM_MEDIUM_TIMES("NCN.OnlineChange",
                                  SinceLast(&last_connection_change_));
 
       if (offline_packets_received_) {
         if ((last_connection_change_ - last_offline_packet_received_) <
             base::TimeDelta::FromSeconds(5)) {
           // We can compare this sum with the sum of NCN.OfflineDataRecv.
           UMA_HISTOGRAM_COUNTS_10000(
               "NCN.OfflineDataRecvAny5sBeforeOnline",
               offline_packets_received_);
         }
 
         UMA_HISTOGRAM_MEDIUM_TIMES("NCN.OfflineDataRecvUntilOnline",
                                    last_connection_change_ -
                                        last_offline_packet_received_);
       }
     } else {
       UMA_HISTOGRAM_MEDIUM_TIMES("NCN.OfflineChange",
                                  SinceLast(&last_connection_change_));
     }
     UMA_HISTOGRAM_MEDIUM_TIMES(
         "NCN.IPAddressChangeToConnectionTypeChange",
         last_connection_change_ - last_ip_address_change_);
 
     offline_packets_received_ = 0;
     last_connection_type_ = type;
     polling_interval_ = base::TimeDelta::FromSeconds(1);
   }
 
-  // NetworkChangeNotifier::DNSObserver implementation.
+  // DNSObserver implementation.
   virtual void OnDNSChanged() OVERRIDE {
     UMA_HISTOGRAM_MEDIUM_TIMES("NCN.DNSConfigChange",
                                SinceLast(&last_dns_change_));
   }
 
-  // NetworkChangeNotifier::NetworkChangeObserver implementation.
-  virtual void OnNetworkChanged(
-      NetworkChangeNotifier::ConnectionType type) OVERRIDE {
-    if (type != NetworkChangeNotifier::CONNECTION_NONE) {
+  // NetworkChangeObserver implementation.
+  virtual void OnNetworkChanged(ConnectionType type) OVERRIDE {
+    if (type != CONNECTION_NONE) {
       UMA_HISTOGRAM_MEDIUM_TIMES("NCN.NetworkOnlineChange",
                                  SinceLast(&last_network_change_));
     } else {
       UMA_HISTOGRAM_MEDIUM_TIMES("NCN.NetworkOfflineChange",
                                  SinceLast(&last_network_change_));
     }
   }
 
   // Record histogram data whenever we receive a packet but think we're
   // offline.  Should only be called from the network thread.
   void NotifyDataReceived(const GURL& source) {
-    if (last_connection_type_ != NetworkChangeNotifier::CONNECTION_NONE ||
+    if (last_connection_type_ != CONNECTION_NONE ||
         IsLocalhost(source.host()) ||
         !(source.SchemeIs("http") || source.SchemeIs("https"))) {
       return;
     }
 
     base::TimeTicks current_time = base::TimeTicks::Now();
     UMA_HISTOGRAM_MEDIUM_TIMES("NCN.OfflineDataRecv",
                                current_time - last_connection_change_);
     offline_packets_received_++;
     last_offline_packet_received_ = current_time;
 
     if ((current_time - last_polled_connection_) > polling_interval_) {
       polling_interval_ *= 2;
       last_polled_connection_ = current_time;
       base::TimeTicks started_get_connection_type = base::TimeTicks::Now();
-      last_polled_connection_type_ =
-          NetworkChangeNotifier::GetConnectionType();
+      last_polled_connection_type_ = GetConnectionType();
       UMA_HISTOGRAM_TIMES("NCN.GetConnectionTypeTime",
                           base::TimeTicks::Now() -
                           started_get_connection_type);
     }
-    if (last_polled_connection_type_ ==
-        NetworkChangeNotifier::CONNECTION_NONE) {
+    if (last_polled_connection_type_ == CONNECTION_NONE) {
       UMA_HISTOGRAM_MEDIUM_TIMES("NCN.PollingOfflineDataRecv",
                                  current_time - last_connection_change_);
     }
   }
 
  private:
   static base::TimeDelta SinceLast(base::TimeTicks *last_time) {
     base::TimeTicks current_time = base::TimeTicks::Now();
     base::TimeDelta delta = current_time - *last_time;
     *last_time = current_time;
     return delta;
   }
 
   base::TimeTicks last_ip_address_change_;
   base::TimeTicks last_connection_change_;
   base::TimeTicks last_dns_change_;
   base::TimeTicks last_network_change_;
   base::TimeTicks last_offline_packet_received_;
   base::TimeTicks last_polled_connection_;
   // |polling_interval_| is initialized by |OnConnectionTypeChanged| on our
   // first transition to offline and on subsequent transitions.  Once offline,
   // |polling_interval_| doubles as offline data is received and we poll
-  // with |NetworkChangeNotifier::GetConnectionType| to verify the connection
+  // with |GetConnectionType| to verify the connection
   // state.
   base::TimeDelta polling_interval_;
   // |last_connection_type_| is the last value passed to
   // |OnConnectionTypeChanged|.
-  NetworkChangeNotifier::ConnectionType last_connection_type_;
+  ConnectionType last_connection_type_;
   // |last_polled_connection_type_| is last result from calling
-  // |NetworkChangeNotifier::GetConnectionType| in |NotifyDataReceived|.
-  NetworkChangeNotifier::ConnectionType last_polled_connection_type_;
+  // |GetConnectionType| in |NotifyDataReceived|.
+  ConnectionType last_polled_connection_type_;
   int32 offline_packets_received_;
 
   DISALLOW_COPY_AND_ASSIGN(HistogramWatcher);
 };
 
 // NetworkState is thread safe.
 class NetworkChangeNotifier::NetworkState {
  public:
   NetworkState() {}
   ~NetworkState() {}
@@ skipping 19 matching lines @@
 
 // Calculates NetworkChange signal from IPAddress and ConnectionType signals.
 class NetworkChangeNotifier::NetworkChangeCalculator
     : public ConnectionTypeObserver,
       public IPAddressObserver {
  public:
   NetworkChangeCalculator(const NetworkChangeCalculatorParams& params)
       : params_(params),
         have_announced_(false),
         last_announced_connection_type_(CONNECTION_NONE),
-        pending_connection_type_(CONNECTION_NONE) {}
+        pending_connection_type_initialized_(false) {}
 
   void Init() {
-    AddConnectionTypeObserver(this);
-    AddIPAddressObserver(this);
+    Deprecated::AddConnectionTypeObserver(this);
+    Deprecated::AddIPAddressObserver(this);
   }
 
   virtual ~NetworkChangeCalculator() {
     RemoveConnectionTypeObserver(this);
     RemoveIPAddressObserver(this);
   }
 
   // NetworkChangeNotifier::IPAddressObserver implementation.
   virtual void OnIPAddressChanged() OVERRIDE {
+    if (!pending_connection_type_initialized_) {
+      pending_connection_type_initialized_ = true;
+      pending_connection_type_ = GetConnectionType();
+    }
     base::TimeDelta delay = last_announced_connection_type_ == CONNECTION_NONE
         ? params_.ip_address_offline_delay_ : params_.ip_address_online_delay_;
     // Cancels any previous timer.
     timer_.Start(FROM_HERE, delay, this, &NetworkChangeCalculator::Notify);
   }
 
   // NetworkChangeNotifier::ConnectionTypeObserver implementation.
   virtual void OnConnectionTypeChanged(ConnectionType type) OVERRIDE {
+    pending_connection_type_initialized_ = true;
     pending_connection_type_ = type;
     base::TimeDelta delay = last_announced_connection_type_ == CONNECTION_NONE
         ? params_.connection_type_offline_delay_
         : params_.connection_type_online_delay_;
     // Cancels any previous timer.
     timer_.Start(FROM_HERE, delay, this, &NetworkChangeCalculator::Notify);
   }
 
  private:
   void Notify() {
+    DCHECK(pending_connection_type_initialized_);
     // Don't bother signaling about dead connections.
     if (have_announced_ &&
         (last_announced_connection_type_ == CONNECTION_NONE) &&
         (pending_connection_type_ == CONNECTION_NONE)) {
       return;
     }
     have_announced_ = true;
     last_announced_connection_type_ = pending_connection_type_;
     // Immediately before sending out an online signal, send out an offline
     // signal to perform any destructive actions before constructive actions.
     if (pending_connection_type_ != CONNECTION_NONE)
       NetworkChangeNotifier::NotifyObserversOfNetworkChange(CONNECTION_NONE);
     NetworkChangeNotifier::NotifyObserversOfNetworkChange(
         pending_connection_type_);
   }
 
   const NetworkChangeCalculatorParams params_;
 
   // Indicates if NotifyObserversOfNetworkChange has been called yet.
   bool have_announced_;
   // Last value passed to NotifyObserversOfNetworkChange.
   ConnectionType last_announced_connection_type_;
   // Value to pass to NotifyObserversOfNetworkChange when Notify is called.
   ConnectionType pending_connection_type_;
+  // Indicates if pending_connection_type_ has been initialized.
+  bool pending_connection_type_initialized_;
   // Used to delay notifications so duplicates can be combined.
   base::OneShotTimer<NetworkChangeCalculator> timer_;
 };
 
 NetworkChangeNotifier::~NetworkChangeNotifier() {
   DCHECK_EQ(this, g_network_change_notifier);
   g_network_change_notifier = NULL;
 }
 
 // static
@@ skipping 117 matching lines @@
       break;
   }
   return is_cellular;
 }
 
 // static
 NetworkChangeNotifier* NetworkChangeNotifier::CreateMock() {
   return new MockNetworkChangeNotifier();
 }
 
-void NetworkChangeNotifier::AddIPAddressObserver(IPAddressObserver* observer) {
+void NetworkChangeNotifier::Deprecated::AddIPAddressObserver(
+    IPAddressObserver* observer) {
   if (g_network_change_notifier)
     g_network_change_notifier->ip_address_observer_list_->AddObserver(observer);
 }
 
-void NetworkChangeNotifier::AddConnectionTypeObserver(
+void NetworkChangeNotifier::Deprecated::AddConnectionTypeObserver(
     ConnectionTypeObserver* observer) {
   if (g_network_change_notifier) {
+    // AddObserver does nothing without a valid MessageLoop
+    DCHECK(MessageLoop::current());
     g_network_change_notifier->connection_type_observer_list_->AddObserver(
         observer);
   }
 }
 
 void NetworkChangeNotifier::AddDNSObserver(DNSObserver* observer) {
   if (g_network_change_notifier) {
+    // AddObserver does nothing without a valid MessageLoop
+    DCHECK(MessageLoop::current());
     g_network_change_notifier->resolver_state_observer_list_->AddObserver(
         observer);
   }
 }
 
 void NetworkChangeNotifier::AddNetworkChangeObserver(
     NetworkChangeObserver* observer) {
   if (g_network_change_notifier) {
+    // AddObserver does nothing without a valid MessageLoop
+    DCHECK(MessageLoop::current());
     g_network_change_notifier->network_change_observer_list_->AddObserver(
         observer);
   }
 }
 
 void NetworkChangeNotifier::RemoveIPAddressObserver(
     IPAddressObserver* observer) {
   if (g_network_change_notifier) {
     g_network_change_notifier->ip_address_observer_list_->RemoveObserver(
         observer);
@@ skipping 98 matching lines @@
     : network_change_notifier_(g_network_change_notifier) {
   DCHECK(g_network_change_notifier);
   g_network_change_notifier = NULL;
 }
 
 NetworkChangeNotifier::DisableForTest::~DisableForTest() {
   DCHECK(!g_network_change_notifier);
   g_network_change_notifier = network_change_notifier_;
 }
 
+void NetworkChangeNotifier::ResetNetworkChangeCalculatorParamsForTest(
+    NetworkChangeCalculatorParams params) {
+  network_change_calculator_.reset(new NetworkChangeCalculator(params));

[szym, 2013/01/20 06:52:08]

How thread-safe is this? It seems that this has to be called on the thread where
the NCN constructor was called. You should probably enforce that.

+  network_change_calculator_->Init();
+}
+
 }  // namespace net