Remove a race around NetworkChangeNotifier::test_notifications_only_

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 <limits>
 
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_util.h"
@@ skipping 35 matching lines @@
 
 class MockNetworkChangeNotifier : public NetworkChangeNotifier {
  public:
   ConnectionType GetCurrentConnectionType() const override {
     return CONNECTION_UNKNOWN;
   }
 };
 
 }  // namespace
 
+// static
+bool NetworkChangeNotifier::test_notifications_only_ = false;
+
 // The main observer class that records UMAs for network events.
 class HistogramWatcher
     : public NetworkChangeNotifier::ConnectionTypeObserver,
       public NetworkChangeNotifier::IPAddressObserver,
       public NetworkChangeNotifier::DNSObserver,
       public NetworkChangeNotifier::NetworkChangeObserver {
  public:
   HistogramWatcher()
       : last_ip_address_change_(base::TimeTicks::Now()),
         last_connection_change_(base::TimeTicks::Now()),
@@ skipping 716 matching lines @@
 }
 
 // static
 void NetworkChangeNotifier::NotifyObserversOfInitialDNSConfigReadForTests() {
   if (g_network_change_notifier)
     g_network_change_notifier->NotifyObserversOfInitialDNSConfigReadImpl();
 }
 
 // static
 void NetworkChangeNotifier::SetTestNotificationsOnly(bool test_only) {
-  if (g_network_change_notifier)
-    g_network_change_notifier->test_notifications_only_ = test_only;
+  DCHECK(!g_network_change_notifier);
+  NetworkChangeNotifier::test_notifications_only_ = test_only;
 }
 
 NetworkChangeNotifier::NetworkChangeNotifier(
     const NetworkChangeCalculatorParams& params
     /*= NetworkChangeCalculatorParams()*/)
     : ip_address_observer_list_(
           new base::ObserverListThreadSafe<IPAddressObserver>(
               base::ObserverListBase<IPAddressObserver>::NOTIFY_EXISTING_ONLY)),
       connection_type_observer_list_(
           new base::ObserverListThreadSafe<ConnectionTypeObserver>(
               base::ObserverListBase<
                   ConnectionTypeObserver>::NOTIFY_EXISTING_ONLY)),
       resolver_state_observer_list_(
           new base::ObserverListThreadSafe<DNSObserver>(
               base::ObserverListBase<DNSObserver>::NOTIFY_EXISTING_ONLY)),
       network_change_observer_list_(new base::ObserverListThreadSafe<
-          NetworkChangeObserver>(
+                                    NetworkChangeObserver>(
           base::ObserverListBase<NetworkChangeObserver>::NOTIFY_EXISTING_ONLY)),
       max_bandwidth_observer_list_(new base::ObserverListThreadSafe<
-          MaxBandwidthObserver>(
+                                   MaxBandwidthObserver>(
           base::ObserverListBase<MaxBandwidthObserver>::NOTIFY_EXISTING_ONLY)),
       network_state_(new NetworkState()),
-      network_change_calculator_(new NetworkChangeCalculator(params)),
-      test_notifications_only_(false) {
+      network_change_calculator_(new NetworkChangeCalculator(params)) {
   DCHECK(!g_network_change_notifier);
   g_network_change_notifier = this;
   network_change_calculator_->Init();
 }
 
 #if defined(OS_LINUX)
 const internal::AddressTrackerLinux*
 NetworkChangeNotifier::GetAddressTrackerInternal() const {
   return NULL;
 }
@@ skipping 79 matching lines @@
     case SUBTYPE_OTHER:
       return std::numeric_limits<double>::infinity();
   }
   NOTREACHED();
   return std::numeric_limits<double>::infinity();
 }
 
 // static
 void NetworkChangeNotifier::NotifyObserversOfIPAddressChange() {
   if (g_network_change_notifier &&
-      !g_network_change_notifier->test_notifications_only_) {
+      !NetworkChangeNotifier::test_notifications_only_) {
     g_network_change_notifier->NotifyObserversOfIPAddressChangeImpl();
   }
 }
 
 // static
 void NetworkChangeNotifier::NotifyObserversOfConnectionTypeChange() {
   if (g_network_change_notifier &&
-      !g_network_change_notifier->test_notifications_only_) {
+      !NetworkChangeNotifier::test_notifications_only_) {
     g_network_change_notifier->NotifyObserversOfConnectionTypeChangeImpl(
         GetConnectionType());
   }
 }
 
 // static
 void NetworkChangeNotifier::NotifyObserversOfNetworkChange(
     ConnectionType type) {
   if (g_network_change_notifier &&
-      !g_network_change_notifier->test_notifications_only_) {
+      !NetworkChangeNotifier::test_notifications_only_) {
     g_network_change_notifier->NotifyObserversOfNetworkChangeImpl(type);
   }
 }
 
 // static
 void NetworkChangeNotifier::NotifyObserversOfMaxBandwidthChange(
     double max_bandwidth_mbps) {
   if (g_network_change_notifier &&
-      !g_network_change_notifier->test_notifications_only_) {
+      !NetworkChangeNotifier::test_notifications_only_) {
     g_network_change_notifier->NotifyObserversOfMaxBandwidthChangeImpl(
         max_bandwidth_mbps);
   }
 }
 
 // static
 void NetworkChangeNotifier::NotifyObserversOfDNSChange() {
   if (g_network_change_notifier &&
-      !g_network_change_notifier->test_notifications_only_) {
+      !NetworkChangeNotifier::test_notifications_only_) {
     g_network_change_notifier->NotifyObserversOfDNSChangeImpl();
   }
 }
 
 // static
 void NetworkChangeNotifier::NotifyObserversOfInitialDNSConfigRead() {
   if (g_network_change_notifier &&
-      !g_network_change_notifier->test_notifications_only_) {
+      !NetworkChangeNotifier::test_notifications_only_) {
     g_network_change_notifier->NotifyObserversOfInitialDNSConfigReadImpl();
   }
 }
 
 // static
 void NetworkChangeNotifier::SetDnsConfig(const DnsConfig& config) {
   if (!g_network_change_notifier)
     return;
   g_network_change_notifier->network_state_->SetDnsConfig(config);
   NotifyObserversOfDNSChange();
@@ skipping 54 matching lines @@
 
 NetworkChangeNotifier::DisableForTest::~DisableForTest() {
   DCHECK(!g_network_change_notifier);
   g_network_change_notifier = network_change_notifier_;
 }
 
 void NetworkChangeNotifier::DNSObserver::OnInitialDNSConfigRead() {
 }
 
 }  // namespace net