Massively simplify the NetworkChangeNotifier infrastructure:

  * Use a process-wide object (singleton pattern)
  * Create/destroy this object on the main thread, make it outlive all consumers
  * Make observer-related functions threadsafe

As a result, the notifier can now be used by any thread (eliminating things like NetworkChangeObserverProxy and NetworkChangeNotifierProxy, and expanding its usefulness); its creation and inner workings are much simplified (eliminating implementation-specific classes); and it is simpler to access (eliminating things like NetworkChangeNotifierThread and a LOT of passing pointers around).

BUG=none
TEST=Unittests; network changes still trigger notifications
Review URL: http://codereview.chromium.org/2802015

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@50895 0039d316-1c4b-4281-b951-d872f2087c98

49 files changed, 511 insertions, 826 deletions

diff --git a/net/base/host_resolver.h b/net/base/host_resolver.h
index d798688..395fc65 100644
--- a/net/base/host_resolver.h
+++ b/net/base/host_resolver.h
@@ -21,7 +21,6 @@ class AddressList;
 class BoundNetLog;
 class HostCache;
 class HostResolverImpl;
-class NetworkChangeNotifier;
 
 // This class represents the task of resolving hostnames (or IP address
 // literal) to an AddressList object.
@@ -236,10 +235,7 @@ class SingleRequestHostResolver {
 // Creates a HostResolver implementation that queries the underlying system.
 // (Except if a unit-test has changed the global HostResolverProc using
 // ScopedHostResolverProc to intercept requests to the system).
-// |network_change_notifier| must outlive HostResolver.  It can optionally be
-// NULL, in which case HostResolver will not respond to network changes.
-HostResolver* CreateSystemHostResolver(
-    NetworkChangeNotifier* network_change_notifier);
+HostResolver* CreateSystemHostResolver();
 
 }  // namespace net
 
diff --git a/net/base/host_resolver_impl.cc b/net/base/host_resolver_impl.cc
index c018a7a..5685fc4 100644
--- a/net/base/host_resolver_impl.cc
+++ b/net/base/host_resolver_impl.cc
@@ -29,7 +29,6 @@
 #include "net/base/net_log.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
-#include "net/base/network_change_notifier.h"
 
 #if defined(OS_WIN)
 #include "net/base/winsock_init.h"
@@ -52,14 +51,13 @@ HostCache* CreateDefaultCache() {
 
 }  // anonymous namespace
 
-HostResolver* CreateSystemHostResolver(
-    NetworkChangeNotifier* network_change_notifier) {
+HostResolver* CreateSystemHostResolver() {
   // Maximum of 50 concurrent threads.
   // TODO(eroman): Adjust this, do some A/B experiments.
   static const size_t kMaxJobs = 50u;
 
-  HostResolverImpl* resolver = new HostResolverImpl(
-      NULL, CreateDefaultCache(), network_change_notifier, kMaxJobs);
+  HostResolverImpl* resolver =
+      new HostResolverImpl(NULL, CreateDefaultCache(), kMaxJobs);
 
   return resolver;
 }
@@ -704,7 +702,6 @@ class HostResolverImpl::JobPool {
 HostResolverImpl::HostResolverImpl(
     HostResolverProc* resolver_proc,
     HostCache* cache,
-    NetworkChangeNotifier* network_change_notifier,
     size_t max_jobs)
     : cache_(cache),
       max_jobs_(max_jobs),
@@ -713,7 +710,6 @@ HostResolverImpl::HostResolverImpl(
       resolver_proc_(resolver_proc),
       default_address_family_(ADDRESS_FAMILY_UNSPECIFIED),
       shutdown_(false),
-      network_change_notifier_(network_change_notifier),
       ipv6_probe_monitoring_(false) {
   DCHECK_GT(max_jobs, 0u);
 
@@ -724,8 +720,7 @@ HostResolverImpl::HostResolverImpl(
 #if defined(OS_WIN)
   EnsureWinsockInit();
 #endif
-  if (network_change_notifier_)
-    network_change_notifier_->AddObserver(this);
+  NetworkChangeNotifier::AddObserver(this);
 }
 
 HostResolverImpl::~HostResolverImpl() {
@@ -740,8 +735,7 @@ HostResolverImpl::~HostResolverImpl() {
   if (cur_completing_job_)
     cur_completing_job_->Cancel();
 
-  if (network_change_notifier_)
-    network_change_notifier_->RemoveObserver(this);
+  NetworkChangeNotifier::RemoveObserver(this);
 
   // Delete the job pools.
   for (size_t i = 0u; i < arraysize(job_pools_); ++i)
diff --git a/net/base/host_resolver_impl.h b/net/base/host_resolver_impl.h
index a0e34ca..2a751fb 100644
--- a/net/base/host_resolver_impl.h
+++ b/net/base/host_resolver_impl.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 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.
 
@@ -73,13 +73,10 @@ class HostResolverImpl : public HostResolver,
   // thread-safe since it is run from multiple worker threads. If
   // |resolver_proc| is NULL then the default host resolver procedure is
   // used (which is SystemHostResolverProc except if overridden).
-  // |notifier| must outlive HostResolverImpl.  It can optionally be NULL, in
-  // which case HostResolverImpl will not respond to network changes.
   // |max_jobs| specifies the maximum number of threads that the host resolver
   // will use. Use SetPoolConstraints() to specify finer-grain settings.
   HostResolverImpl(HostResolverProc* resolver_proc,
                    HostCache* cache,
-                   NetworkChangeNotifier* notifier,
                    size_t max_jobs);
 
   // HostResolver methods:
@@ -247,8 +244,6 @@ class HostResolverImpl : public HostResolver,
   // TODO(eroman): hack for http://crbug.com/15513
   bool shutdown_;
 
-  NetworkChangeNotifier* const network_change_notifier_;
-
   // Indicate if probing is done after each network change event to set address
   // family.
   // When false, explicit setting of address family is used.
diff --git a/net/base/host_resolver_impl_unittest.cc b/net/base/host_resolver_impl_unittest.cc
index 3d7e02a..6b33a56 100644
--- a/net/base/host_resolver_impl_unittest.cc
+++ b/net/base/host_resolver_impl_unittest.cc
@@ -13,7 +13,6 @@
 #include "net/base/address_list.h"
 #include "net/base/completion_callback.h"
 #include "net/base/mock_host_resolver.h"
-#include "net/base/mock_network_change_notifier.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log_unittest.h"
 #include "net/base/net_util.h"
@@ -39,11 +38,7 @@ HostCache* CreateDefaultCache() {
 static const size_t kMaxJobs = 10u;
 
 HostResolverImpl* CreateHostResolverImpl(HostResolverProc* resolver_proc) {
-  return new HostResolverImpl(
-      resolver_proc,
-      CreateDefaultCache(),
-      NULL,  // network_change_notifier
-      kMaxJobs);
+  return new HostResolverImpl(resolver_proc, CreateDefaultCache(), kMaxJobs);
 }
 
 // Helper to create a HostResolver::RequestInfo.
@@ -748,7 +743,7 @@ TEST_F(HostResolverImplTest, StartWithinCallback) {
 
   // Turn off caching for this host resolver.
   scoped_refptr<HostResolver> host_resolver(
-      new HostResolverImpl(resolver_proc, NULL, NULL, kMaxJobs));
+      new HostResolverImpl(resolver_proc, NULL, kMaxJobs));
 
   // The class will receive callbacks for when each resolve completes. It
   // checks that the right things happened.
@@ -1044,11 +1039,8 @@ TEST_F(HostResolverImplTest, CancellationObserver) {
 
 // Test that IP address changes flush the cache.
 TEST_F(HostResolverImplTest, FlushCacheOnIPAddressChange) {
-  MockNetworkChangeNotifier mock_network_change_notifier;
   scoped_refptr<HostResolver> host_resolver(
-      new HostResolverImpl(NULL, CreateDefaultCache(),
-                           &mock_network_change_notifier,
-                           kMaxJobs));
+      new HostResolverImpl(NULL, CreateDefaultCache(), kMaxJobs));
 
   AddressList addrlist;
 
@@ -1066,7 +1058,8 @@ TEST_F(HostResolverImplTest, FlushCacheOnIPAddressChange) {
   ASSERT_EQ(OK, rv);  // Should complete synchronously.
 
   // Flush cache by triggering an IP address change.
-  mock_network_change_notifier.NotifyIPAddressChange();
+  NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
+  MessageLoop::current()->RunAllPending();  // Notification happens async.
 
   // Resolve "host1" again -- this time it won't be served from cache, so it
   // will complete asynchronously.
@@ -1084,8 +1077,7 @@ TEST_F(HostResolverImplTest, HigherPriorityRequestsStartedFirst) {
   // This HostResolverImpl will only allow 1 outstanding resolve at a time.
   size_t kMaxJobs = 1u;
   scoped_refptr<HostResolver> host_resolver(
-      new HostResolverImpl(resolver_proc, CreateDefaultCache(),
-                           NULL, kMaxJobs));
+      new HostResolverImpl(resolver_proc, CreateDefaultCache(), kMaxJobs));
 
   CapturingObserver observer;
   host_resolver->AddObserver(&observer);
@@ -1169,8 +1161,7 @@ TEST_F(HostResolverImplTest, CancelPendingRequest) {
   // This HostResolverImpl will only allow 1 outstanding resolve at a time.
   const size_t kMaxJobs = 1u;
   scoped_refptr<HostResolver> host_resolver(
-      new HostResolverImpl(resolver_proc, CreateDefaultCache(),
-                           NULL, kMaxJobs));
+      new HostResolverImpl(resolver_proc, CreateDefaultCache(), kMaxJobs));
 
   // Note that at this point the CapturingHostResolverProc is blocked, so any
   // requests we make will not complete.
@@ -1231,9 +1222,8 @@ TEST_F(HostResolverImplTest, QueueOverflow) {
 
   // This HostResolverImpl will only allow 1 outstanding resolve at a time.
   const size_t kMaxOutstandingJobs = 1u;
-  scoped_refptr<HostResolverImpl> host_resolver(
-      new HostResolverImpl(resolver_proc, CreateDefaultCache(),
-                           NULL, kMaxOutstandingJobs));
+  scoped_refptr<HostResolverImpl> host_resolver(new HostResolverImpl(
+      resolver_proc, CreateDefaultCache(), kMaxOutstandingJobs));
 
   // Only allow up to 3 requests to be enqueued at a time.
   const size_t kMaxPendingRequests = 3u;
@@ -1310,9 +1300,8 @@ TEST_F(HostResolverImplTest, SetDefaultAddressFamily_IPv4) {
 
   // This HostResolverImpl will only allow 1 outstanding resolve at a time.
   const size_t kMaxOutstandingJobs = 1u;
-  scoped_refptr<HostResolverImpl> host_resolver(
-      new HostResolverImpl(resolver_proc, CreateDefaultCache(),
-                           NULL, kMaxOutstandingJobs));
+  scoped_refptr<HostResolverImpl> host_resolver(new HostResolverImpl(
+      resolver_proc, CreateDefaultCache(), kMaxOutstandingJobs));
 
   host_resolver->SetDefaultAddressFamily(ADDRESS_FAMILY_IPV4);
 
@@ -1379,9 +1368,8 @@ TEST_F(HostResolverImplTest, SetDefaultAddressFamily_IPv6) {
 
   // This HostResolverImpl will only allow 1 outstanding resolve at a time.
   const size_t kMaxOutstandingJobs = 1u;
-  scoped_refptr<HostResolverImpl> host_resolver(
-      new HostResolverImpl(resolver_proc, CreateDefaultCache(),
-                           NULL, kMaxOutstandingJobs));
+  scoped_refptr<HostResolverImpl> host_resolver(new HostResolverImpl(
+      resolver_proc, CreateDefaultCache(), kMaxOutstandingJobs));
 
   host_resolver->SetDefaultAddressFamily(ADDRESS_FAMILY_IPV6);
 
@@ -1446,9 +1434,8 @@ TEST_F(HostResolverImplTest, SetDefaultAddressFamily_Synchronous) {
       new CapturingHostResolverProc(new EchoingHostResolverProc);
 
   const size_t kMaxOutstandingJobs = 10u;
-  scoped_refptr<HostResolverImpl> host_resolver(
-      new HostResolverImpl(resolver_proc, CreateDefaultCache(),
-                           NULL, kMaxOutstandingJobs));
+  scoped_refptr<HostResolverImpl> host_resolver(new HostResolverImpl(
+      resolver_proc, CreateDefaultCache(), kMaxOutstandingJobs));
 
   host_resolver->SetDefaultAddressFamily(ADDRESS_FAMILY_IPV4);
 
diff --git a/net/base/mock_host_resolver.cc b/net/base/mock_host_resolver.cc
index 1ee9bb1..8d1fd89 100644
--- a/net/base/mock_host_resolver.cc
+++ b/net/base/mock_host_resolver.cc
@@ -98,7 +98,7 @@ void MockHostResolverBase::Reset(HostResolverProc* interceptor) {
         base::TimeDelta::FromSeconds(0));
   }
 
-  impl_ = new HostResolverImpl(proc, cache, NULL, 50u);
+  impl_ = new HostResolverImpl(proc, cache, 50u);
 }
 
 //-----------------------------------------------------------------------------
diff --git a/net/base/mock_network_change_notifier.h b/net/base/mock_network_change_notifier.h
deleted file mode 100644
index 7d1b38e..0000000
--- a/net/base/mock_network_change_notifier.h
+++ /dev/null
@@ -1,46 +0,0 @@
-// Copyright (c) 2010 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.
-
-#ifndef NET_BASE_MOCK_NETWORK_CHANGE_NOTIFIER_H_
-#define NET_BASE_MOCK_NETWORK_CHANGE_NOTIFIER_H_
-
-#include "base/basictypes.h"
-#include "base/non_thread_safe.h"
-#include "net/base/network_change_notifier.h"
-
-namespace net {
-
-class MockNetworkChangeNotifier : public NetworkChangeNotifier,
-                                  public NonThreadSafe {
- public:
-  MockNetworkChangeNotifier() : observer_(NULL) {}
-
-  virtual ~MockNetworkChangeNotifier() {
-    CHECK(!observer_);
-  }
-
-  void NotifyIPAddressChange() {
-    if (observer_)
-      observer_->OnIPAddressChanged();
-  }
-
-  virtual void AddObserver(Observer* observer) {
-    CHECK(!observer_);
-    observer_ = observer;
-  }
-
-  virtual void RemoveObserver(Observer* observer) {
-    CHECK(observer_ == observer);
-    observer_ = NULL;
-  }
-
- private:
-  Observer* observer_;
-
-  DISALLOW_COPY_AND_ASSIGN(MockNetworkChangeNotifier);
-};
-
-}  // namespace net
-
-#endif  // NET_BASE_MOCK_NETWORK_CHANGE_NOTIFIER_H_
diff --git a/net/base/net_test_suite.h b/net/base/net_test_suite.h
index af58ca7..cc4ed2a 100644
--- a/net/base/net_test_suite.h
+++ b/net/base/net_test_suite.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 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.
 
@@ -25,6 +25,8 @@ class NetTestSuite : public TestSuite {
   // TestSuite::Initialize().  TestSuite::Initialize() performs some global
   // initialization that can only be done once.
   void InitializeTestThread() {
+    network_change_notifier_.reset(net::NetworkChangeNotifier::CreateMock());
+
     host_resolver_proc_ = new net::RuleBasedHostResolverProc(NULL);
     scoped_host_resolver_proc_.Init(host_resolver_proc_.get());
     // In case any attempts are made to resolve host names, force them all to
@@ -44,6 +46,7 @@ class NetTestSuite : public TestSuite {
   }
 
  private:
+  scoped_ptr<net::NetworkChangeNotifier> network_change_notifier_;
   scoped_ptr<MessageLoop> message_loop_;
   scoped_refptr<net::RuleBasedHostResolverProc> host_resolver_proc_;
   net::ScopedDefaultHostResolverProc scoped_host_resolver_proc_;
diff --git a/net/base/network_change_notifier.cc b/net/base/network_change_notifier.cc
index aeca2ab..a0bc6b5 100644
--- a/net/base/network_change_notifier.cc
+++ b/net/base/network_change_notifier.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 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.
 
@@ -14,9 +14,22 @@
 
 namespace net {
 
-// static
-NetworkChangeNotifier*
-NetworkChangeNotifier::CreateDefaultNetworkChangeNotifier() {
+namespace {
+
+// The actual singleton notifier.  The class contract forbids usage of the API
+// in ways that would require us to place locks around access to this object.
+// (The prohibition on global non-POD objects makes it tricky to do such a thing
+// anyway.)
+NetworkChangeNotifier* g_network_change_notifier = NULL;
+
+}  // namespace
+
+NetworkChangeNotifier::~NetworkChangeNotifier() {
+  DCHECK_EQ(this, g_network_change_notifier);
+  g_network_change_notifier = NULL;
+}
+
+NetworkChangeNotifier* NetworkChangeNotifier::Create() {
 #if defined(OS_WIN)
   return new NetworkChangeNotifierWin();
 #elif defined(OS_LINUX)
@@ -29,4 +42,27 @@ NetworkChangeNotifier::CreateDefaultNetworkChangeNotifier() {
 #endif
 }
 
+void NetworkChangeNotifier::AddObserver(Observer* observer) {
+  if (g_network_change_notifier)
+    g_network_change_notifier->observer_list_->AddObserver(observer);
+}
+
+void NetworkChangeNotifier::RemoveObserver(Observer* observer) {
+  if (g_network_change_notifier)
+    g_network_change_notifier->observer_list_->RemoveObserver(observer);
+}
+
+NetworkChangeNotifier::NetworkChangeNotifier()
+    : observer_list_(new ObserverListThreadSafe<Observer>()) {
+  DCHECK(!g_network_change_notifier);
+  g_network_change_notifier = this;
+}
+
+void NetworkChangeNotifier::NotifyObserversOfIPAddressChange() {
+  if (g_network_change_notifier) {
+    g_network_change_notifier->observer_list_->Notify(
+        &Observer::OnIPAddressChanged);
+  }
+}
+
 }  // namespace net
diff --git a/net/base/network_change_notifier.h b/net/base/network_change_notifier.h
index 70b195d..e0a8800 100644
--- a/net/base/network_change_notifier.h
+++ b/net/base/network_change_notifier.h
@@ -6,11 +6,13 @@
 #define NET_BASE_NETWORK_CHANGE_NOTIFIER_H_
 
 #include "base/basictypes.h"
+#include "base/observer_list_threadsafe.h"
 
 namespace net {
 
 // NetworkChangeNotifier monitors the system for network changes, and notifies
-// observers on those events.
+// registered observers of those events.  Observers may register on any thread,
+// and will be called back on the thread from which they registered.
 class NetworkChangeNotifier {
  public:
   class Observer {
@@ -28,21 +30,58 @@ class NetworkChangeNotifier {
     DISALLOW_COPY_AND_ASSIGN(Observer);
   };
 
-  NetworkChangeNotifier() {}
-  virtual ~NetworkChangeNotifier() {}
+  virtual ~NetworkChangeNotifier();
 
-  // These functions add and remove observers to/from the NetworkChangeNotifier.
-  // Each call to AddObserver() must be matched with a corresponding call to
-  // RemoveObserver() with the same parameter.  Observers must remove themselves
-  // before they get deleted, otherwise the NetworkChangeNotifier may try to
-  // notify the wrong object.
-  virtual void AddObserver(Observer* observer) = 0;
-  virtual void RemoveObserver(Observer* observer) = 0;
+  // Creates the process-wide, platform-specific NetworkChangeNotifier.  The
+  // caller owns the returned pointer.  You may call this on any thread.  You
+  // may also avoid creating this entirely (in which case nothing will be
+  // monitored), but if you do create it, you must do so before any other
+  // threads try to access the API below, and it must outlive all other threads
+  // which might try to use it.
+  static NetworkChangeNotifier* Create();
 
-  // This will create the platform specific default NetworkChangeNotifier.
-  static NetworkChangeNotifier* CreateDefaultNetworkChangeNotifier();
+#ifdef UNIT_TEST
+  // Like Create(), but for use in tests.  The mock object doesn't monitor any
+  // events, it merely rebroadcasts notifications when requested.
+  static NetworkChangeNotifier* CreateMock() {
+    return new NetworkChangeNotifier();
+  }
+#endif
+
+  // Registers |observer| to receive notifications of network changes.  The
+  // thread on which this is called is the thread on which |observer| will be
+  // called back with notifications.  This is safe to call if Create() has not
+  // been called (as long as it doesn't race the Create() call on another
+  // thread), in which case it will simply do nothing.
+  static void AddObserver(Observer* observer);
+
+  // Unregisters |observer| from receiving notifications.  This must be called
+  // on the same thread on which AddObserver() was called.  Like AddObserver(),
+  // this is safe to call if Create() has not been called (as long as it doesn't
+  // race the Create() call on another thread), in which case it will simply do
+  // nothing.  Technically, it's also safe to call after the notifier object has
+  // been destroyed, if the call doesn't race the notifier's destruction, but
+  // there's no reason to use the API in this risky way, so don't do it.
+  static void RemoveObserver(Observer* observer);
+
+#ifdef UNIT_TEST
+  // Allow unit tests to trigger notifications.
+  static void NotifyObserversOfIPAddressChangeForTests() {
+    NotifyObserversOfIPAddressChange();
+  }
+#endif
+
+ protected:
+  NetworkChangeNotifier();
+
+  // Broadcasts a notification to all registered observers.  Note that this
+  // happens asynchronously, even for observers on the current thread, even in
+  // tests.
+  static void NotifyObserversOfIPAddressChange();
 
  private:
+  const scoped_refptr<ObserverListThreadSafe<Observer> > observer_list_;
+
   DISALLOW_COPY_AND_ASSIGN(NetworkChangeNotifier);
 };
 
diff --git a/net/base/network_change_notifier_linux.cc b/net/base/network_change_notifier_linux.cc
index 9821be5..aa58c14 100644
--- a/net/base/network_change_notifier_linux.cc
+++ b/net/base/network_change_notifier_linux.cc
@@ -7,13 +7,15 @@
 #include <errno.h>
 #include <sys/socket.h>
 
-#include "base/basictypes.h"
 #include "base/eintr_wrapper.h"
-#include "base/logging.h"
-#include "base/message_loop.h"
+#include "base/task.h"
+#include "base/thread.h"
 #include "net/base/net_errors.h"
 #include "net/base/network_change_notifier_netlink_linux.h"
 
+// We only post tasks to a child thread we own, so we don't need refcounting.
+DISABLE_RUNNABLE_METHOD_REFCOUNT(net::NetworkChangeNotifierLinux);
+
 namespace net {
 
 namespace {
@@ -23,122 +25,115 @@ const int kInvalidSocket = -1;
 }  // namespace
 
 NetworkChangeNotifierLinux::NetworkChangeNotifierLinux()
-    : netlink_fd_(kInvalidSocket),
-#if defined(OS_CHROMEOS)
-      ALLOW_THIS_IN_INITIALIZER_LIST(factory_(this)),
-#endif
-      loop_(MessageLoopForIO::current()) {
-  netlink_fd_ = InitializeNetlinkSocket();
-  if (netlink_fd_ < 0) {
-    netlink_fd_ = kInvalidSocket;
-    return;
-  }
-
-  ListenForNotifications();
-  loop_->AddDestructionObserver(this);
+    : notifier_thread_(new base::Thread("NetworkChangeNotifier")),
+      netlink_fd_(kInvalidSocket) {
+  // We create this notifier thread because the notification implementation
+  // needs a MessageLoopForIO, and there's no guarantee that
+  // MessageLoop::current() meets that criterion.
+  base::Thread::Options thread_options(MessageLoop::TYPE_IO, 0);
+  notifier_thread_->StartWithOptions(thread_options);
+  notifier_thread_->message_loop()->PostTask(FROM_HERE,
+      NewRunnableMethod(this, &NetworkChangeNotifierLinux::Init));
 }
 
 NetworkChangeNotifierLinux::~NetworkChangeNotifierLinux() {
-  DCHECK(CalledOnValidThread());
-  StopWatching();
-
-  if (loop_)
-    loop_->RemoveDestructionObserver(this);
+  // We don't need to explicitly Stop(), but doing so allows us to sanity-
+  // check that the notifier thread shut down properly.
+  notifier_thread_->Stop();
+  DCHECK_EQ(kInvalidSocket, netlink_fd_);
 }
 
-void NetworkChangeNotifierLinux::AddObserver(Observer* observer) {
-  DCHECK(CalledOnValidThread());
-  observers_.AddObserver(observer);
-}
+void NetworkChangeNotifierLinux::WillDestroyCurrentMessageLoop() {
+  DCHECK(notifier_thread_ != NULL);
+  // We can't check the notifier_thread_'s message_loop(), as it's now 0.
+  // DCHECK_EQ(notifier_thread_->message_loop(), MessageLoop::current());
 
-void NetworkChangeNotifierLinux::RemoveObserver(Observer* observer) {
-  DCHECK(CalledOnValidThread());
-  observers_.RemoveObserver(observer);
+  if (netlink_fd_ != kInvalidSocket) {
+    if (HANDLE_EINTR(close(netlink_fd_)) != 0)
+      PLOG(ERROR) << "Failed to close socket";
+    netlink_fd_ = kInvalidSocket;
+    netlink_watcher_.StopWatchingFileDescriptor();
+  }
 }
 
 void NetworkChangeNotifierLinux::OnFileCanReadWithoutBlocking(int fd) {
-  DCHECK(CalledOnValidThread());
-  DCHECK_EQ(fd, netlink_fd_);
+  DCHECK(notifier_thread_ != NULL);
+  DCHECK_EQ(notifier_thread_->message_loop(), MessageLoop::current());
 
+  DCHECK_EQ(fd, netlink_fd_);
   ListenForNotifications();
 }
 
 void NetworkChangeNotifierLinux::OnFileCanWriteWithoutBlocking(int /* fd */) {
-  DCHECK(CalledOnValidThread());
+  DCHECK(notifier_thread_ != NULL);
+  DCHECK_EQ(notifier_thread_->message_loop(), MessageLoop::current());
+
   NOTREACHED();
 }
 
-void NetworkChangeNotifierLinux::WillDestroyCurrentMessageLoop() {
-  DCHECK(CalledOnValidThread());
-  StopWatching();
-  loop_ = NULL;
+void NetworkChangeNotifierLinux::Init() {
+  DCHECK(notifier_thread_ != NULL);
+  DCHECK_EQ(notifier_thread_->message_loop(), MessageLoop::current());
+
+  netlink_fd_ = InitializeNetlinkSocket();
+  if (netlink_fd_ < 0) {
+    netlink_fd_ = kInvalidSocket;
+    return;
+  }
+  MessageLoop::current()->AddDestructionObserver(this);
+  ListenForNotifications();
 }
 
 void NetworkChangeNotifierLinux::ListenForNotifications() {
-  DCHECK(CalledOnValidThread());
+  DCHECK(notifier_thread_ != NULL);
+  DCHECK_EQ(notifier_thread_->message_loop(), MessageLoop::current());
+
   char buf[4096];
   int rv = ReadNotificationMessage(buf, arraysize(buf));
-  while (rv > 0 ) {
+  while (rv > 0) {
     if (HandleNetlinkMessage(buf, rv)) {
       LOG(INFO) << "Detected IP address changes.";
-
 #if defined(OS_CHROMEOS)
       // TODO(zelidrag): chromium-os:3996 - introduced artificial delay to
       // work around the issue of proxy initialization before name resolving
       // is functional in ChromeOS. This should be removed once this bug
       // is properly fixed.
-      MessageLoop::current()->PostDelayedTask(
-          FROM_HERE,
-          factory_.NewRunnableMethod(
-              &NetworkChangeNotifierLinux::NotifyObserversIPAddressChanged),
-          500);
+      const int kObserverNotificationDelayMS = 500;
+      MessageLoop::current()->PostDelayedTask(FROM_HERE, NewRunnableMethod(
+          &NetworkChangeNotifier::NotifyObserversOfIPAddressChange),
+          kObserverNotificationDelayMS);
 #else
-      NotifyObserversIPAddressChanged();
+      NotifyObserversOfIPAddressChange();
 #endif
     }
     rv = ReadNotificationMessage(buf, arraysize(buf));
   }
 
   if (rv == ERR_IO_PENDING) {
-    rv = loop_->WatchFileDescriptor(
-        netlink_fd_, false, MessageLoopForIO::WATCH_READ, &netlink_watcher_,
-        this);
+    rv = MessageLoopForIO::current()->WatchFileDescriptor(netlink_fd_, false,
+        MessageLoopForIO::WATCH_READ, &netlink_watcher_, this);
     LOG_IF(ERROR, !rv) << "Failed to watch netlink socket: " << netlink_fd_;
   }
 }
 
-void NetworkChangeNotifierLinux::NotifyObserversIPAddressChanged() {
-  FOR_EACH_OBSERVER(Observer, observers_, OnIPAddressChanged());
-}
-
 int NetworkChangeNotifierLinux::ReadNotificationMessage(char* buf, size_t len) {
-  DCHECK(CalledOnValidThread());
+  DCHECK(notifier_thread_ != NULL);
+  DCHECK_EQ(notifier_thread_->message_loop(), MessageLoop::current());
+
   DCHECK_NE(len, 0u);
   DCHECK(buf);
-
   memset(buf, 0, sizeof(buf));
   int rv = recv(netlink_fd_, buf, len, 0);
-  if (rv > 0) {
+  if (rv > 0)
     return rv;
-  } else {
-    DCHECK_NE(rv, 0);
-    if (errno != EAGAIN && errno != EWOULDBLOCK) {
-      PLOG(DFATAL) << "recv";
-      return ERR_FAILED;
-    }
 
-    return ERR_IO_PENDING;
+  DCHECK_NE(rv, 0);
+  if (errno != EAGAIN && errno != EWOULDBLOCK) {
+    PLOG(DFATAL) << "recv";
+    return ERR_FAILED;
   }
-}
 
-void NetworkChangeNotifierLinux::StopWatching() {
-  DCHECK(CalledOnValidThread());
-  if (netlink_fd_ != kInvalidSocket) {
-    if (HANDLE_EINTR(close(netlink_fd_)) != 0)
-      PLOG(ERROR) << "Failed to close socket";
-    netlink_fd_ = kInvalidSocket;
-    netlink_watcher_.StopWatchingFileDescriptor();
-  }
+  return ERR_IO_PENDING;
 }
 
 }  // namespace net
diff --git a/net/base/network_change_notifier_linux.h b/net/base/network_change_notifier_linux.h
index dcedbf4..aca9377 100644
--- a/net/base/network_change_notifier_linux.h
+++ b/net/base/network_change_notifier_linux.h
@@ -7,37 +7,34 @@
 
 #include "base/basictypes.h"
 #include "base/message_loop.h"
-#include "base/non_thread_safe.h"
-#include "base/observer_list.h"
+#include "base/scoped_ptr.h"
 #include "net/base/network_change_notifier.h"
 
-#if defined(OS_CHROMEOS)
-#include "base/task.h"
-#endif
+namespace base {
+class Thread;
+}
 
 namespace net {
 
-class NetworkChangeNotifierLinux
-    : public NetworkChangeNotifier,
-      public NonThreadSafe,
-      public MessageLoopForIO::Watcher,
-      public MessageLoop::DestructionObserver {
+class NetworkChangeNotifierLinux : public MessageLoop::DestructionObserver,
+                                   public MessageLoopForIO::Watcher,
+                                   public NetworkChangeNotifier {
  public:
   NetworkChangeNotifierLinux();
 
-  // NetworkChangeNotifier methods:
-  virtual void AddObserver(Observer* observer);
-  virtual void RemoveObserver(Observer* observer);
+ private:
+  virtual ~NetworkChangeNotifierLinux();
+
+  // MessageLoop::DestructionObserver:
+  virtual void WillDestroyCurrentMessageLoop();
 
-  // MessageLoopForIO::Watcher methods:
+  // MessageLoopForIO::Watcher:
   virtual void OnFileCanReadWithoutBlocking(int fd);
   virtual void OnFileCanWriteWithoutBlocking(int /* fd */);
 
-  // MessageLoop::DestructionObserver methods:
-  virtual void WillDestroyCurrentMessageLoop();
-
- private:
-  virtual ~NetworkChangeNotifierLinux();
+  // Called on the notifier thread to initialize the notification
+  // implementation.
+  void Init();
 
   // Starts listening for netlink messages.  Also handles the messages if there
   // are any available on the netlink socket.
@@ -48,21 +45,14 @@ class NetworkChangeNotifierLinux
   // recv() would block.  Otherwise, it returns a net error code.
   int ReadNotificationMessage(char* buf, size_t len);
 
-  // Stops watching the netlink file descriptor.
-  void StopWatching();
-
-  void NotifyObserversIPAddressChanged();
-
-  // http://crbug.com/36890.
-  ObserverList<Observer, false> observers_;
-
-  int netlink_fd_;  // This is the netlink socket descriptor.
+  // The thread used to listen for notifications.  This relays the notification
+  // to the registered observers without posting back to the thread the object
+  // was created on.
+  scoped_ptr<base::Thread> notifier_thread_;
 
-#if defined(OS_CHROMEOS)
-  ScopedRunnableMethodFactory<NetworkChangeNotifierLinux> factory_;
-#endif
+  // The netlink socket descriptor.
+  int netlink_fd_;
 
-  MessageLoopForIO* loop_;
   MessageLoopForIO::FileDescriptorWatcher netlink_watcher_;
 
   DISALLOW_COPY_AND_ASSIGN(NetworkChangeNotifierLinux);
diff --git a/net/base/network_change_notifier_mac.cc b/net/base/network_change_notifier_mac.cc
index ba38907..797de6d 100644
--- a/net/base/network_change_notifier_mac.cc
+++ b/net/base/network_change_notifier_mac.cc
@@ -2,168 +2,116 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-// There are three classes involved here.  There's NetworkChangeNotifierMac,
-// which is the Mac specific implementation of NetworkChangeNotifier.  It is the
-// class with which clients can register themselves as network change
-// observers.  There's NetworkChangeNotifierThread, which is a base::Thread
-// subclass of MessageLoop::TYPE_UI (since it needs a CFRunLoop) that contains
-// the NetworkChangeNotifierImpl.  NetworkChangeNotifierImpl is the object
-// that receives the actual OS X notifications and posts them to the
-// NetworkChangeNotifierMac's message loop, so that NetworkChangeNotifierMac
-// can notify all its observers.
-//
-// When NetworkChangeNotifierMac is being deleted, it will delete the
-// NetworkChangeNotifierThread, which will Stop() it and also delete the
-// NetworkChangeNotifierImpl.  Therefore, NetworkChangeNotifierImpl and
-// NetworkChangeNotifierThread's lifetimes generally begin after and end before
-// NetworkChangeNotifierMac.  There is an edge case where a notification task
-// gets posted to the IO thread, thereby maintaining a reference to
-// NetworkChangeNotifierImpl beyond the lifetime of NetworkChangeNotifierThread.
-// In this case, the notification is cancelled, and NetworkChangeNotifierImpl
-// will be deleted once all notification tasks that reference it have been run.
-
 #include "net/base/network_change_notifier_mac.h"
-#include <SystemConfiguration/SCDynamicStore.h>
+
 #include <SystemConfiguration/SCDynamicStoreKey.h>
 #include <SystemConfiguration/SCSchemaDefinitions.h>
 #include <algorithm>
-#include "base/logging.h"
-#include "base/message_loop.h"
-#include "base/scoped_cftyperef.h"
-#include "base/thread.h"
-
-namespace net {
 
-namespace {
-
-// NetworkChangeNotifierImpl should be created on a thread with a CFRunLoop,
-// since it requires one to pump notifications.  However, it also runs some
-// methods on |notifier_loop_|, because it cannot post calls to |notifier_|
-// since NetworkChangeNotifier is not ref counted in a thread safe manner.
-class NetworkChangeNotifierImpl
-    : public base::RefCountedThreadSafe<NetworkChangeNotifierImpl> {
- public:
-  NetworkChangeNotifierImpl(MessageLoop* notifier_loop,
-                            NetworkChangeNotifierMac* notifier);
+#include "base/thread.h"
 
-  void Shutdown();
+// We only post tasks to a child thread we own, so we don't need refcounting.
+DISABLE_RUNNABLE_METHOD_REFCOUNT(net::NetworkChangeNotifierMac);
 
- private:
-  friend class base::RefCountedThreadSafe<NetworkChangeNotifierImpl>;
-  ~NetworkChangeNotifierImpl();
+namespace net {
 
-  static void DynamicStoreCallback(SCDynamicStoreRef /* store */,
-                                   CFArrayRef changed_keys,
-                                   void* config);
+NetworkChangeNotifierMac::NetworkChangeNotifierMac()
+    : notifier_thread_(new base::Thread("NetworkChangeNotifier")) {
+  // We create this notifier thread because the notification implementation
+  // needs a thread with a CFRunLoop, and there's no guarantee that
+  // MessageLoop::current() meets that criterion.
+  base::Thread::Options thread_options(MessageLoop::TYPE_UI, 0);
+  notifier_thread_->StartWithOptions(thread_options);
+  // TODO(willchan): Look to see if there's a better signal for when it's ok to
+  // initialize this, rather than just delaying it by a fixed time.
+  const int kNotifierThreadInitializationDelayMS = 1000;
+  notifier_thread_->message_loop()->PostDelayedTask(FROM_HERE,
+      NewRunnableMethod(this, &NetworkChangeNotifierMac::Init),
+      kNotifierThreadInitializationDelayMS);
+}
 
-  void OnNetworkConfigChange(CFArrayRef changed_keys);
+NetworkChangeNotifierMac::~NetworkChangeNotifierMac() {
+  // We don't need to explicitly Stop(), but doing so allows us to sanity-
+  // check that the notifier thread shut down properly.
+  notifier_thread_->Stop();
+  DCHECK(run_loop_source_ == NULL);
+}
 
-  // Runs on |notifier_loop_|.
-  void OnIPAddressChanged();
+// static
+void NetworkChangeNotifierMac::DynamicStoreCallback(
+    SCDynamicStoreRef /* store */,
+    CFArrayRef changed_keys,
+    void* config) {
+  NetworkChangeNotifierMac* net_config =
+      static_cast<NetworkChangeNotifierMac*>(config);
+  net_config->OnNetworkConfigChange(changed_keys);
+}
 
-  // Raw pointers.  Note that |notifier_| _must_ outlive the
-  // NetworkChangeNotifierImpl.  For lifecycle management details, read the
-  // comment at the top of the file.
-  MessageLoop* const notifier_loop_;
-  NetworkChangeNotifierMac* notifier_;
+void NetworkChangeNotifierMac::WillDestroyCurrentMessageLoop() {
+  DCHECK(notifier_thread_ != NULL);
+  // We can't check the notifier_thread_'s message_loop(), as it's now 0.
+  // DCHECK_EQ(notifier_thread_->message_loop(), MessageLoop::current());
 
-  scoped_cftyperef<CFRunLoopSourceRef> source_;
+  DCHECK(run_loop_source_ != NULL);
+  CFRunLoopRemoveSource(CFRunLoopGetCurrent(), run_loop_source_.get(),
+                        kCFRunLoopCommonModes);
+  run_loop_source_.reset();
+}
 
-  DISALLOW_COPY_AND_ASSIGN(NetworkChangeNotifierImpl);
-};
+void NetworkChangeNotifierMac::Init() {
+  DCHECK(notifier_thread_ != NULL);
+  DCHECK_EQ(notifier_thread_->message_loop(), MessageLoop::current());
 
-NetworkChangeNotifierImpl::NetworkChangeNotifierImpl(
-    MessageLoop* notifier_loop, NetworkChangeNotifierMac* notifier)
-    : notifier_loop_(notifier_loop),
-      notifier_(notifier) {
-  DCHECK_EQ(MessageLoop::TYPE_UI, MessageLoop::current()->type());
+  // Add a run loop source for a dynamic store to the current run loop.
   SCDynamicStoreContext context = {
-    0,    // Version 0.
-    this, // User data.
-    NULL, // This is not reference counted.  No retain function.
-    NULL, // This is not reference counted.  No release function.
-    NULL, // No description for this.
+    0,     // Version 0.
+    this,  // User data.
+    NULL,  // This is not reference counted.  No retain function.
+    NULL,  // This is not reference counted.  No release function.
+    NULL,  // No description for this.
   };
-
-  // Get a reference to the dynamic store.
-  scoped_cftyperef<SCDynamicStoreRef> store(
-      SCDynamicStoreCreate(NULL /* use default allocator */,
-                           CFSTR("org.chromium"),
-                           DynamicStoreCallback, &context));
-
-  // Create a run loop source for the dynamic store.
-  source_.reset(SCDynamicStoreCreateRunLoopSource(
-      NULL /* use default allocator */,
-      store.get(),
-      0 /* 0 sounds like a fine source order to me! */));
-
-  // Add the run loop source to the current run loop.
-  CFRunLoopAddSource(CFRunLoopGetCurrent(),
-                     source_.get(),
+  scoped_cftyperef<SCDynamicStoreRef> store(SCDynamicStoreCreate(
+      NULL, CFSTR("org.chromium"), DynamicStoreCallback, &context));
+  run_loop_source_.reset(SCDynamicStoreCreateRunLoopSource(
+      NULL, store.get(), 0));
+  CFRunLoopAddSource(CFRunLoopGetCurrent(), run_loop_source_.get(),
                      kCFRunLoopCommonModes);
 
-  // Set up the notification keys.
+  // Set up notifications for interface and IP address changes.
   scoped_cftyperef<CFMutableArrayRef> notification_keys(
       CFArrayCreateMutable(kCFAllocatorDefault, 0, &kCFTypeArrayCallBacks));
-
-  // Monitor interface changes.
-  scoped_cftyperef<CFStringRef> key(
-      SCDynamicStoreKeyCreateNetworkGlobalEntity(
-          NULL /* default allocator */, kSCDynamicStoreDomainState,
-          kSCEntNetInterface));
+  scoped_cftyperef<CFStringRef> key(SCDynamicStoreKeyCreateNetworkGlobalEntity(
+      NULL, kSCDynamicStoreDomainState, kSCEntNetInterface));
   CFArrayAppendValue(notification_keys.get(), key.get());
-
-  // Monitor IP address changes.
-
   key.reset(SCDynamicStoreKeyCreateNetworkGlobalEntity(
-      NULL /* default allocator */, kSCDynamicStoreDomainState,
-      kSCEntNetIPv4));
+      NULL, kSCDynamicStoreDomainState, kSCEntNetIPv4));
   CFArrayAppendValue(notification_keys.get(), key.get());
-
   key.reset(SCDynamicStoreKeyCreateNetworkGlobalEntity(
-      NULL /* default allocator */, kSCDynamicStoreDomainState,
-      kSCEntNetIPv6));
+      NULL, kSCDynamicStoreDomainState, kSCEntNetIPv6));
   CFArrayAppendValue(notification_keys.get(), key.get());
 
-  // Ok, let's ask for notifications!
+  // Set the notification keys.  This starts us receiving notifications.
+  bool ret = SCDynamicStoreSetNotificationKeys(
+      store.get(), notification_keys.get(), NULL);
   // TODO(willchan): Figure out a proper way to handle this rather than crash.
-  CHECK(SCDynamicStoreSetNotificationKeys(
-      store.get(), notification_keys.get(), NULL));
-}
+  CHECK(ret);
 
-NetworkChangeNotifierImpl::~NetworkChangeNotifierImpl() {
-  CFRunLoopRemoveSource(CFRunLoopGetCurrent(),
-                        source_.get(),
-                        kCFRunLoopCommonModes);
-}
-
-void NetworkChangeNotifierImpl::Shutdown() {
-  CHECK(notifier_);
-  notifier_ = NULL;
+  MessageLoop::current()->AddDestructionObserver(this);
 }
 
-// static
-void NetworkChangeNotifierImpl::DynamicStoreCallback(
-    SCDynamicStoreRef /* store */,
-    CFArrayRef changed_keys,
-    void* config) {
-  NetworkChangeNotifierImpl* net_config =
-      static_cast<NetworkChangeNotifierImpl*>(config);
-  net_config->OnNetworkConfigChange(changed_keys);
-}
+void NetworkChangeNotifierMac::OnNetworkConfigChange(CFArrayRef changed_keys) {
+  DCHECK(notifier_thread_ != NULL);
+  DCHECK_EQ(notifier_thread_->message_loop(), MessageLoop::current());
 
-void NetworkChangeNotifierImpl::OnNetworkConfigChange(CFArrayRef changed_keys) {
   for (CFIndex i = 0; i < CFArrayGetCount(changed_keys); ++i) {
     CFStringRef key = static_cast<CFStringRef>(
         CFArrayGetValueAtIndex(changed_keys, i));
     if (CFStringHasSuffix(key, kSCEntNetIPv4) ||
         CFStringHasSuffix(key, kSCEntNetIPv6)) {
-      notifier_loop_->PostTask(
-          FROM_HERE,
-          NewRunnableMethod(
-              this,
-              &NetworkChangeNotifierImpl::OnIPAddressChanged));
-    } else if (CFStringHasSuffix(key, kSCEntNetInterface)) {
+      NotifyObserversOfIPAddressChange();
+      return;
+    }
+    if (CFStringHasSuffix(key, kSCEntNetInterface)) {
       // TODO(willchan): Does not appear to be working.  Look into this.
       // Perhaps this isn't needed anyway.
     } else {
@@ -172,91 +120,4 @@ void NetworkChangeNotifierImpl::OnNetworkConfigChange(CFArrayRef changed_keys) {
   }
 }
 
-void NetworkChangeNotifierImpl::OnIPAddressChanged() {
-  // If |notifier_| doesn't exist, then that means we're shutting down, so
-  // notifications are all cancelled.
-  if (notifier_)
-    notifier_->OnIPAddressChanged();
-}
-
-class NetworkChangeNotifierThread : public base::Thread {
- public:
-  NetworkChangeNotifierThread(MessageLoop* notifier_loop,
-                              NetworkChangeNotifierMac* notifier);
-  ~NetworkChangeNotifierThread();
-
- protected:
-  virtual void Init();
-
- private:
-  MessageLoop* const notifier_loop_;
-  NetworkChangeNotifierMac* const notifier_;
-  scoped_refptr<NetworkChangeNotifierImpl> notifier_impl_;
-
-  DISALLOW_COPY_AND_ASSIGN(NetworkChangeNotifierThread);
-};
-
-NetworkChangeNotifierThread::NetworkChangeNotifierThread(
-    MessageLoop* notifier_loop, NetworkChangeNotifierMac* notifier)
-    : base::Thread("NetworkChangeNotifier"),
-      notifier_loop_(notifier_loop),
-      notifier_(notifier) {}
-
-NetworkChangeNotifierThread::~NetworkChangeNotifierThread() {
-  notifier_impl_->Shutdown();
-  Stop();
-}
-
-// Note that |notifier_impl_| is initialized on the network change
-// notifier thread, not whatever thread constructs the
-// NetworkChangeNotifierThread object.  This is important, because this thread
-// is the one that has a CFRunLoop.
-void NetworkChangeNotifierThread::Init() {
-  notifier_impl_ =
-      new NetworkChangeNotifierImpl(notifier_loop_, notifier_);
-}
-
-}  // namespace
-
-NetworkChangeNotifierMac::NetworkChangeNotifierMac()
-    : notifier_thread_(NULL),
-      method_factory_(this) {
-  // TODO(willchan): Look to see if there's a better signal for when it's ok to
-  // initialize this, rather than just delaying it by a fixed time.
-  const int kNotifierThreadInitializationDelayMS = 1000;
-  MessageLoop* loop = MessageLoop::current();
-  loop->PostDelayedTask(
-      FROM_HERE,
-      method_factory_.NewRunnableMethod(
-          &NetworkChangeNotifierMac::InitializeNotifierThread, loop),
-      kNotifierThreadInitializationDelayMS);
-}
-
-void NetworkChangeNotifierMac::OnIPAddressChanged() {
-  DCHECK(CalledOnValidThread());
-  FOR_EACH_OBSERVER(Observer, observers_, OnIPAddressChanged());
-}
-
-void NetworkChangeNotifierMac::AddObserver(Observer* observer) {
-  DCHECK(CalledOnValidThread());
-  observers_.AddObserver(observer);
-}
-
-void NetworkChangeNotifierMac::RemoveObserver(Observer* observer) {
-  DCHECK(CalledOnValidThread());
-  observers_.RemoveObserver(observer);
-}
-
-NetworkChangeNotifierMac::~NetworkChangeNotifierMac() {
-  DCHECK(CalledOnValidThread());
-}
-
-void NetworkChangeNotifierMac::InitializeNotifierThread(MessageLoop* loop) {
-  DCHECK(CalledOnValidThread());
-  notifier_thread_.reset(new NetworkChangeNotifierThread(loop, this));
-  base::Thread::Options thread_options;
-  thread_options.message_loop_type = MessageLoop::TYPE_UI;
-  notifier_thread_->StartWithOptions(thread_options);
-}
-
 }  // namespace net
diff --git a/net/base/network_change_notifier_mac.h b/net/base/network_change_notifier_mac.h
index 2ffaaba..c85f244 100644
--- a/net/base/network_change_notifier_mac.h
+++ b/net/base/network_change_notifier_mac.h
@@ -5,52 +5,52 @@
 #ifndef NET_BASE_NETWORK_CHANGE_NOTIFIER_MAC_H_
 #define NET_BASE_NETWORK_CHANGE_NOTIFIER_MAC_H_
 
+#include <SystemConfiguration/SCDynamicStore.h>
+
 #include "base/basictypes.h"
-#include "base/non_thread_safe.h"
-#include "base/observer_list.h"
-#include "base/ref_counted.h"
+#include "base/message_loop.h"
+#include "base/scoped_cftyperef.h"
 #include "base/scoped_ptr.h"
-#include "base/task.h"
 #include "net/base/network_change_notifier.h"
 
-class MessageLoop;
 namespace base {
 class Thread;
-}  // namespace base
+}
 
 namespace net {
 
-class NetworkChangeNotifierMac : public NetworkChangeNotifier,
-                                 public NonThreadSafe {
+class NetworkChangeNotifierMac : public MessageLoop::DestructionObserver,
+                                 public NetworkChangeNotifier {
  public:
   NetworkChangeNotifierMac();
 
-  void OnIPAddressChanged();
+ private:
+  virtual ~NetworkChangeNotifierMac();
 
-  // NetworkChangeNotifier methods:
-  virtual void AddObserver(Observer* observer);
-  virtual void RemoveObserver(Observer* observer);
+  // Called back by OS.  Calls OnNetworkConfigChange().
+  static void DynamicStoreCallback(SCDynamicStoreRef /* store */,
+                                   CFArrayRef changed_keys,
+                                   void* config);
 
- private:
-  friend class base::RefCounted<NetworkChangeNotifierMac>;
+  // MessageLoop::DestructionObserver:
+  virtual void WillDestroyCurrentMessageLoop();
 
-  virtual ~NetworkChangeNotifierMac();
+  // Called on the notifier thread to initialize the notification
+  // implementation.  The SystemConfiguration calls in this function can lead to
+  // contention early on, so we invoke this function later on in startup to keep
+  // it fast.
+  void Init();
 
-  // Initializes the notifier thread.  The SystemConfiguration calls in this
-  // function can lead to contention early on, so we invoke this function later
-  // on in startup to keep it fast.
-  // See http://crbug.com/34926 for details.
-  void InitializeNotifierThread(MessageLoop* loop);
+  // Called by DynamicStoreCallback() when something about the network config
+  // changes.
+  void OnNetworkConfigChange(CFArrayRef changed_keys);
 
-  // Receives the OS X network change notifications on this thread.
+  // The thread used to listen for notifications.  This relays the notification
+  // to the registered observers without posting back to the thread the object
+  // was created on.
   scoped_ptr<base::Thread> notifier_thread_;
 
-  // TODO(willchan): Fix the URLRequestContextGetter leaks and flip the false to
-  // true so we assert that all observers have been removed.
-  ObserverList<Observer, false> observers_;
-
-  // Used to initialize the notifier thread.
-  ScopedRunnableMethodFactory<NetworkChangeNotifierMac> method_factory_;
+  scoped_cftyperef<CFRunLoopSourceRef> run_loop_source_;
 
   DISALLOW_COPY_AND_ASSIGN(NetworkChangeNotifierMac);
 };
diff --git a/net/base/network_change_notifier_win.cc b/net/base/network_change_notifier_win.cc
index bed361c..e0e0892 100644
--- a/net/base/network_change_notifier_win.cc
+++ b/net/base/network_change_notifier_win.cc
@@ -5,84 +5,35 @@
 #include "net/base/network_change_notifier_win.h"
 
 #include <iphlpapi.h>
-#include <windows.h>
 #include <winsock2.h>
 
-#include "base/basictypes.h"
-#include "base/compiler_specific.h"
-#include "base/logging.h"
-#include "base/object_watcher.h"
+#pragma comment(lib, "iphlpapi.lib")
 
 namespace net {
 
-class NetworkChangeNotifierWin::Impl
-    : public base::ObjectWatcher::Delegate {
- public:
-  explicit Impl(NetworkChangeNotifierWin* notifier);
-  virtual ~Impl();
-
-  void WatchForAddressChange();
-
-  // ObjectWatcher::Delegate methods:
-
-  virtual void OnObjectSignaled(HANDLE object);
-
- private:
-  NetworkChangeNotifierWin* const notifier_;
-  base::ObjectWatcher addr_watcher_;
-  OVERLAPPED addr_overlapped_;
-
-  DISALLOW_COPY_AND_ASSIGN(Impl);
-};
-
-NetworkChangeNotifierWin::Impl::Impl(NetworkChangeNotifierWin* notifier)
-    : notifier_(notifier) {
-  memset(&addr_overlapped_, 0, sizeof(addr_overlapped_));
+NetworkChangeNotifierWin::NetworkChangeNotifierWin() {
+  memset(&addr_overlapped_, 0, sizeof addr_overlapped_);
   addr_overlapped_.hEvent = WSACreateEvent();
 }
 
-NetworkChangeNotifierWin::Impl::~Impl() {
+NetworkChangeNotifierWin::~NetworkChangeNotifierWin() {
   CancelIPChangeNotify(&addr_overlapped_);
   addr_watcher_.StopWatching();
   WSACloseEvent(addr_overlapped_.hEvent);
-  memset(&addr_overlapped_, 0, sizeof(addr_overlapped_));
-}
-
-void NetworkChangeNotifierWin::Impl::WatchForAddressChange() {
-  HANDLE handle = NULL;
-  DWORD ret = NotifyAddrChange(&handle, &addr_overlapped_);
-  CHECK(ret == ERROR_IO_PENDING);
-  addr_watcher_.StartWatching(addr_overlapped_.hEvent, this);
 }
 
-void NetworkChangeNotifierWin::Impl::OnObjectSignaled(HANDLE object) {
-  notifier_->OnIPAddressChanged();
+void NetworkChangeNotifierWin::OnObjectSignaled(HANDLE object) {
+  NotifyObserversOfIPAddressChange();
 
-  // Start watching for further address changes.
+  // Start watching for the next address change.
   WatchForAddressChange();
 }
 
-NetworkChangeNotifierWin::NetworkChangeNotifierWin()
-    : impl_(new Impl(ALLOW_THIS_IN_INITIALIZER_LIST(this))) {
-  impl_->WatchForAddressChange();
-}
-void NetworkChangeNotifierWin::OnIPAddressChanged() {
-  DCHECK(CalledOnValidThread());
-  FOR_EACH_OBSERVER(Observer, observers_, OnIPAddressChanged());
-}
-
-void NetworkChangeNotifierWin::AddObserver(Observer* observer) {
-  DCHECK(CalledOnValidThread());
-  observers_.AddObserver(observer);
-}
-
-void NetworkChangeNotifierWin::RemoveObserver(Observer* observer) {
-  DCHECK(CalledOnValidThread());
-  observers_.RemoveObserver(observer);
-}
-
-NetworkChangeNotifierWin::~NetworkChangeNotifierWin() {
-  DCHECK(CalledOnValidThread());
+void NetworkChangeNotifierWin::WatchForAddressChange() {
+  HANDLE handle = NULL;
+  DWORD ret = NotifyAddrChange(&handle, &addr_overlapped_);
+  CHECK(ret == ERROR_IO_PENDING);
+  addr_watcher_.StartWatching(addr_overlapped_.hEvent, this);
 }
 
 }  // namespace net
diff --git a/net/base/network_change_notifier_win.h b/net/base/network_change_notifier_win.h
index ba2f53dc..2077ca8 100644
--- a/net/base/network_change_notifier_win.h
+++ b/net/base/network_change_notifier_win.h
@@ -5,35 +5,30 @@
 #ifndef NET_BASE_NETWORK_CHANGE_NOTIFIER_WIN_H_
 #define NET_BASE_NETWORK_CHANGE_NOTIFIER_WIN_H_
 
+#include <windows.h>
+
 #include "base/basictypes.h"
-#include "base/non_thread_safe.h"
 #include "base/object_watcher.h"
-#include "base/observer_list.h"
 #include "net/base/network_change_notifier.h"
 
 namespace net {
 
 class NetworkChangeNotifierWin : public NetworkChangeNotifier,
-                                 public NonThreadSafe {
+                                 public base::ObjectWatcher::Delegate {
  public:
   NetworkChangeNotifierWin();
 
-  // Called by NetworkChangeNotifierWin::Impl.
-  void OnIPAddressChanged();
-
-  // NetworkChangeNotifier methods:
-  virtual void AddObserver(Observer* observer);
-  virtual void RemoveObserver(Observer* observer);
-
  private:
-  class Impl;
-
   virtual ~NetworkChangeNotifierWin();
 
-  // TODO(willchan): Fix the URLRequestContextGetter leaks and flip the false to
-  // true so we assert that all observers have been removed.
-  ObserverList<Observer, false> observers_;
-  scoped_ptr<Impl> impl_;
+  // ObjectWatcher::Delegate methods:
+  virtual void OnObjectSignaled(HANDLE object);
+
+  // Begins listening for a single subsequent address change.
+  void WatchForAddressChange();
+
+  base::ObjectWatcher addr_watcher_;
+  OVERLAPPED addr_overlapped_;
 
   DISALLOW_COPY_AND_ASSIGN(NetworkChangeNotifierWin);
 };
diff --git a/net/http/http_cache.cc b/net/http/http_cache.cc
index ef9198c..7e73d94 100644
--- a/net/http/http_cache.cc
+++ b/net/http/http_cache.cc
@@ -222,8 +222,7 @@ void HttpCache::MetadataWriter::OnIOComplete(int result) {
 
 //-----------------------------------------------------------------------------
 
-HttpCache::HttpCache(NetworkChangeNotifier* network_change_notifier,
-                     HostResolver* host_resolver, ProxyService* proxy_service,
+HttpCache::HttpCache(HostResolver* host_resolver, ProxyService* proxy_service,
                      SSLConfigService* ssl_config_service,
                      HttpAuthHandlerFactory* http_auth_handler_factory,
                      HttpNetworkDelegate* network_delegate,
@@ -233,11 +232,9 @@ HttpCache::HttpCache(NetworkChangeNotifier* network_change_notifier,
       temp_backend_(NULL),
       building_backend_(false),
       mode_(NORMAL),
-      network_layer_(HttpNetworkLayer::CreateFactory(
-          network_change_notifier, host_resolver, proxy_service,
-          ssl_config_service, http_auth_handler_factory,
-          network_delegate,
-          net_log)),
+      network_layer_(HttpNetworkLayer::CreateFactory(host_resolver,
+          proxy_service, ssl_config_service, http_auth_handler_factory,
+          network_delegate, net_log)),
       ALLOW_THIS_IN_INITIALIZER_LIST(task_factory_(this)),
       enable_range_support_(true) {
 }
diff --git a/net/http/http_cache.h b/net/http/http_cache.h
index 9ed20b4..734e58d 100644
--- a/net/http/http_cache.h
+++ b/net/http/http_cache.h
@@ -46,7 +46,6 @@ struct HttpRequestInfo;
 class HttpResponseInfo;
 class IOBuffer;
 class NetLog;
-class NetworkChangeNotifier;
 class ProxyService;
 class SSLConfigService;
 class ViewCacheHelper;
@@ -113,8 +112,8 @@ class HttpCache : public HttpTransactionFactory,
 
   // The disk cache is initialized lazily (by CreateTransaction) in this case.
   // The  HttpCache takes ownership of the |backend_factory|.
-  HttpCache(NetworkChangeNotifier* network_change_notifier,
-            HostResolver* host_resolver, ProxyService* proxy_service,
+  HttpCache(HostResolver* host_resolver,
+            ProxyService* proxy_service,
             SSLConfigService* ssl_config_service,
             HttpAuthHandlerFactory* http_auth_handler_factory,
             HttpNetworkDelegate* network_delegate,
diff --git a/net/http/http_network_layer.cc b/net/http/http_network_layer.cc
index 2329627..27c6272 100644
--- a/net/http/http_network_layer.cc
+++ b/net/http/http_network_layer.cc
@@ -21,7 +21,6 @@ namespace net {
 
 // static
 HttpTransactionFactory* HttpNetworkLayer::CreateFactory(
-    NetworkChangeNotifier* network_change_notifier,
     HostResolver* host_resolver,
     ProxyService* proxy_service,
     SSLConfigService* ssl_config_service,
@@ -31,7 +30,6 @@ HttpTransactionFactory* HttpNetworkLayer::CreateFactory(
   DCHECK(proxy_service);
 
   return new HttpNetworkLayer(ClientSocketFactory::GetDefaultFactory(),
-                              network_change_notifier,
                               host_resolver, proxy_service, ssl_config_service,
                               http_auth_handler_factory,
                               network_delegate,
@@ -51,7 +49,6 @@ bool HttpNetworkLayer::force_spdy_ = false;
 
 HttpNetworkLayer::HttpNetworkLayer(
     ClientSocketFactory* socket_factory,
-    NetworkChangeNotifier* network_change_notifier,
     HostResolver* host_resolver,
     ProxyService* proxy_service,
     SSLConfigService* ssl_config_service,
@@ -59,7 +56,6 @@ HttpNetworkLayer::HttpNetworkLayer(
     HttpNetworkDelegate* network_delegate,
     NetLog* net_log)
     : socket_factory_(socket_factory),
-      network_change_notifier_(network_change_notifier),
       host_resolver_(host_resolver),
       proxy_service_(proxy_service),
       ssl_config_service_(ssl_config_service),
@@ -75,7 +71,6 @@ HttpNetworkLayer::HttpNetworkLayer(
 
 HttpNetworkLayer::HttpNetworkLayer(HttpNetworkSession* session)
     : socket_factory_(ClientSocketFactory::GetDefaultFactory()),
-      network_change_notifier_(NULL),
       ssl_config_service_(NULL),
       session_(session),
       spdy_session_pool_(session->spdy_session_pool()),
@@ -114,15 +109,11 @@ void HttpNetworkLayer::Suspend(bool suspend) {
 HttpNetworkSession* HttpNetworkLayer::GetSession() {
   if (!session_) {
     DCHECK(proxy_service_);
-    SpdySessionPool* spdy_pool = new SpdySessionPool(network_change_notifier_);
-    session_ = new HttpNetworkSession(
-        network_change_notifier_, host_resolver_, proxy_service_,
+    SpdySessionPool* spdy_pool = new SpdySessionPool();
+    session_ = new HttpNetworkSession(host_resolver_, proxy_service_,
         socket_factory_, ssl_config_service_, spdy_pool,
-        http_auth_handler_factory_,
-        network_delegate_,
-        net_log_);
+        http_auth_handler_factory_, network_delegate_, net_log_);
     // These were just temps for lazy-initializing HttpNetworkSession.
-    network_change_notifier_ = NULL;
     host_resolver_ = NULL;
     proxy_service_ = NULL;
     socket_factory_ = NULL;
diff --git a/net/http/http_network_layer.h b/net/http/http_network_layer.h
index 54989410..4a61065 100644
--- a/net/http/http_network_layer.h
+++ b/net/http/http_network_layer.h
@@ -19,7 +19,6 @@ class HttpAuthHandlerFactory;
 class HttpNetworkDelegate;
 class HttpNetworkSession;
 class NetLog;
-class NetworkChangeNotifier;
 class ProxyInfo;
 class ProxyService;
 class SpdySessionPool;
@@ -27,11 +26,11 @@ class SSLConfigService;
 
 class HttpNetworkLayer : public HttpTransactionFactory {
  public:
-  // |socket_factory|, |network_change_notifier|, |proxy_service| and
-  // |host_resolver| must remain valid for the lifetime of HttpNetworkLayer.
+  // |socket_factory|, |proxy_service| and |host_resolver| must remain valid for
+  // the lifetime of HttpNetworkLayer.
   HttpNetworkLayer(ClientSocketFactory* socket_factory,
-                   NetworkChangeNotifier* network_change_notifier,
-                   HostResolver* host_resolver, ProxyService* proxy_service,
+                   HostResolver* host_resolver,
+                   ProxyService* proxy_service,
                    SSLConfigService* ssl_config_service,
                    HttpAuthHandlerFactory* http_auth_handler_factory,
                    HttpNetworkDelegate* network_delegate,
@@ -44,7 +43,6 @@ class HttpNetworkLayer : public HttpTransactionFactory {
   // This function hides the details of how a network layer gets instantiated
   // and allows other implementations to be substituted.
   static HttpTransactionFactory* CreateFactory(
-      NetworkChangeNotifier* network_change_notifier,
       HostResolver* host_resolver,
       ProxyService* proxy_service,
       SSLConfigService* ssl_config_service,
@@ -77,8 +75,6 @@ class HttpNetworkLayer : public HttpTransactionFactory {
   // The factory we will use to create network sockets.
   ClientSocketFactory* socket_factory_;
 
-  NetworkChangeNotifier* network_change_notifier_;
-
   // The host resolver and proxy service that will be used when lazily
   // creating |session_|.
   scoped_refptr<HostResolver> host_resolver_;
diff --git a/net/http/http_network_layer_unittest.cc b/net/http/http_network_layer_unittest.cc
index 9f20943..274d2dc 100644
--- a/net/http/http_network_layer_unittest.cc
+++ b/net/http/http_network_layer_unittest.cc
@@ -16,9 +16,9 @@ class HttpNetworkLayerTest : public PlatformTest {
 };
 
 TEST_F(HttpNetworkLayerTest, CreateAndDestroy) {
-  net::HttpNetworkLayer factory(
-      NULL, NULL, new net::MockHostResolver, net::ProxyService::CreateNull(),
-      new net::SSLConfigServiceDefaults, NULL, NULL, NULL);
+  net::HttpNetworkLayer factory(NULL, new net::MockHostResolver,
+      net::ProxyService::CreateNull(), new net::SSLConfigServiceDefaults, NULL,
+      NULL, NULL);
 
   scoped_ptr<net::HttpTransaction> trans;
   int rv = factory.CreateTransaction(&trans);
@@ -27,9 +27,9 @@ TEST_F(HttpNetworkLayerTest, CreateAndDestroy) {
 }
 
 TEST_F(HttpNetworkLayerTest, Suspend) {
-  net::HttpNetworkLayer factory(
-      NULL, NULL, new net::MockHostResolver, net::ProxyService::CreateNull(),
-      new net::SSLConfigServiceDefaults, NULL, NULL, NULL);
+  net::HttpNetworkLayer factory(NULL, new net::MockHostResolver,
+      net::ProxyService::CreateNull(), new net::SSLConfigServiceDefaults, NULL,
+      NULL, NULL);
 
   scoped_ptr<net::HttpTransaction> trans;
   int rv = factory.CreateTransaction(&trans);
@@ -67,11 +67,9 @@ TEST_F(HttpNetworkLayerTest, GET) {
                                      data_writes, arraysize(data_reads));
   mock_socket_factory.AddSocketDataProvider(&data);
 
-  net::HttpNetworkLayer factory(&mock_socket_factory, NULL,
-                                new net::MockHostResolver,
-                                net::ProxyService::CreateNull(),
-                                new net::SSLConfigServiceDefaults,
-                                NULL, NULL, NULL);
+  net::HttpNetworkLayer factory(&mock_socket_factory, new net::MockHostResolver,
+      net::ProxyService::CreateNull(), new net::SSLConfigServiceDefaults, NULL,
+      NULL, NULL);
 
   TestCompletionCallback callback;
 
diff --git a/net/http/http_network_session.cc b/net/http/http_network_session.cc
index 1083626..ea5a5cf 100644
--- a/net/http/http_network_session.cc
+++ b/net/http/http_network_session.cc
@@ -36,7 +36,6 @@ uint16 g_fixed_https_port = 0;
 }  // namespace
 
 HttpNetworkSession::HttpNetworkSession(
-    NetworkChangeNotifier* network_change_notifier,
     HostResolver* host_resolver,
     ProxyService* proxy_service,
     ClientSocketFactory* client_socket_factory,
@@ -45,18 +44,16 @@ HttpNetworkSession::HttpNetworkSession(
     HttpAuthHandlerFactory* http_auth_handler_factory,
     HttpNetworkDelegate* network_delegate,
     NetLog* net_log)
-    : network_change_notifier_(network_change_notifier),
       // TODO(vandebo) when we've completely converted to pools, the base TCP
       // pool name should get changed to TCP instead of Transport.
-      tcp_pool_histograms_(new ClientSocketPoolHistograms("Transport")),
+    : tcp_pool_histograms_(new ClientSocketPoolHistograms("Transport")),
       http_proxy_pool_histograms_(new ClientSocketPoolHistograms("HTTPProxy")),
       tcp_for_socks_pool_histograms_(
           new ClientSocketPoolHistograms("TCPforSOCKS")),
       socks_pool_histograms_(new ClientSocketPoolHistograms("SOCK")),
-      tcp_socket_pool_(new TCPClientSocketPool(
-          g_max_sockets, g_max_sockets_per_group, tcp_pool_histograms_,
-          host_resolver, client_socket_factory, network_change_notifier_,
-          net_log)),
+      tcp_socket_pool_(new TCPClientSocketPool(g_max_sockets,
+          g_max_sockets_per_group, tcp_pool_histograms_, host_resolver,
+          client_socket_factory, net_log)),
       socket_factory_(client_socket_factory),
       host_resolver_(host_resolver),
       proxy_service_(proxy_service),
@@ -80,14 +77,10 @@ HttpNetworkSession::GetSocketPoolForHTTPProxy(const HostPortPair& http_proxy) {
     return it->second;
 
   std::pair<HTTPProxySocketPoolMap::iterator, bool> ret =
-      http_proxy_socket_pool_.insert(
-          std::make_pair(
-              http_proxy,
-              new TCPClientSocketPool(
-                  g_max_sockets_per_proxy_server, g_max_sockets_per_group,
-                  http_proxy_pool_histograms_, host_resolver_, socket_factory_,
-                  network_change_notifier_,
-                  net_log_)));
+      http_proxy_socket_pool_.insert(std::make_pair(http_proxy,
+          new TCPClientSocketPool(g_max_sockets_per_proxy_server,
+              g_max_sockets_per_group, http_proxy_pool_histograms_,
+              host_resolver_, socket_factory_, net_log_)));
 
   return ret.first->second;
 }
@@ -99,20 +92,14 @@ HttpNetworkSession::GetSocketPoolForSOCKSProxy(
   if (it != socks_socket_pool_.end())
     return it->second;
 
-  std::pair<SOCKSSocketPoolMap::iterator, bool> ret =
-      socks_socket_pool_.insert(
-          std::make_pair(
-              socks_proxy,
-              new SOCKSClientSocketPool(
-                  g_max_sockets_per_proxy_server, g_max_sockets_per_group,
-                  socks_pool_histograms_, host_resolver_,
-                  new TCPClientSocketPool(g_max_sockets_per_proxy_server,
-                                          g_max_sockets_per_group,
-                                          tcp_for_socks_pool_histograms_,
-                                          host_resolver_, socket_factory_,
-                                          network_change_notifier_,
-                                          net_log_),
-                  network_change_notifier_, net_log_)));
+  std::pair<SOCKSSocketPoolMap::iterator, bool> ret = socks_socket_pool_.insert(
+      std::make_pair(socks_proxy, new SOCKSClientSocketPool(
+          g_max_sockets_per_proxy_server, g_max_sockets_per_group,
+          socks_pool_histograms_, host_resolver_,
+          new TCPClientSocketPool(g_max_sockets_per_proxy_server,
+              g_max_sockets_per_group, tcp_for_socks_pool_histograms_,
+              host_resolver_, socket_factory_, net_log_),
+          net_log_)));
 
   return ret.first->second;
 }
diff --git a/net/http/http_network_session.h b/net/http/http_network_session.h
index 1288197..319753c 100644
--- a/net/http/http_network_session.h
+++ b/net/http/http_network_session.h
@@ -28,14 +28,12 @@ class ClientSocketFactory;
 class HttpAuthHandlerFactory;
 class HttpNetworkDelegate;
 class HttpNetworkSessionPeer;
-class NetworkChangeNotifier;
 class SpdySessionPool;
 
 // This class holds session objects used by HttpNetworkTransaction objects.
 class HttpNetworkSession : public base::RefCounted<HttpNetworkSession> {
  public:
   HttpNetworkSession(
-      NetworkChangeNotifier* network_change_notifier,
       HostResolver* host_resolver,
       ProxyService* proxy_service,
       ClientSocketFactory* client_socket_factory,
@@ -113,7 +111,6 @@ class HttpNetworkSession : public base::RefCounted<HttpNetworkSession> {
   HttpAuthCache auth_cache_;
   SSLClientAuthCache ssl_client_auth_cache_;
   HttpAlternateProtocols alternate_protocols_;
-  NetworkChangeNotifier* const network_change_notifier_;
   scoped_refptr<ClientSocketPoolHistograms> tcp_pool_histograms_;
   scoped_refptr<ClientSocketPoolHistograms> http_proxy_pool_histograms_;
   scoped_refptr<ClientSocketPoolHistograms> tcp_for_socks_pool_histograms_;
diff --git a/net/http/http_network_transaction_unittest.cc b/net/http/http_network_transaction_unittest.cc
index 35ba760..dd04773 100644
--- a/net/http/http_network_transaction_unittest.cc
+++ b/net/http/http_network_transaction_unittest.cc
@@ -83,7 +83,7 @@ struct SessionDependencies {
         proxy_service(ProxyService::CreateNull()),
         ssl_config_service(new SSLConfigServiceDefaults),
         http_auth_handler_factory(HttpAuthHandlerFactory::CreateDefault()),
-        spdy_session_pool(new SpdySessionPool(NULL)) {}
+        spdy_session_pool(new SpdySessionPool()) {}
 
   // Custom proxy service dependency.
   explicit SessionDependencies(ProxyService* proxy_service)
@@ -91,7 +91,7 @@ struct SessionDependencies {
         proxy_service(proxy_service),
         ssl_config_service(new SSLConfigServiceDefaults),
         http_auth_handler_factory(HttpAuthHandlerFactory::CreateDefault()),
-        spdy_session_pool(new SpdySessionPool(NULL)) {}
+        spdy_session_pool(new SpdySessionPool()) {}
 
   scoped_refptr<MockHostResolverBase> host_resolver;
   scoped_refptr<ProxyService> proxy_service;
@@ -108,8 +108,7 @@ ProxyService* CreateFixedProxyService(const std::string& proxy) {
 }
 
 HttpNetworkSession* CreateSession(SessionDependencies* session_deps) {
-  return new HttpNetworkSession(NULL,
-                                session_deps->host_resolver,
+  return new HttpNetworkSession(session_deps->host_resolver,
                                 session_deps->proxy_service,
                                 &session_deps->socket_factory,
                                 session_deps->ssl_config_service,
@@ -241,7 +240,8 @@ class CaptureGroupNameSocketPool : public EmulatedClientSocketPool {
  public:
   explicit CaptureGroupNameSocketPool(HttpNetworkSession* session)
       : EmulatedClientSocketPool(0, 0, NULL, session->host_resolver(), NULL,
-                                 NULL, NULL) {}
+                                 NULL) {
+  }
   const std::string last_group_name_received() const {
     return last_group_name_;
   }
@@ -5249,11 +5249,9 @@ TEST_F(HttpNetworkTransactionTest, UseAlternateProtocolForTunneledNpnSpdy) {
 
   CapturingProxyResolver* capturing_proxy_resolver =
       new CapturingProxyResolver();
-  SessionDependencies session_deps(
-      new ProxyService(new ProxyConfigServiceFixed(proxy_config),
-                       capturing_proxy_resolver,
-                       NULL,
-                       NULL));
+  SessionDependencies session_deps(new ProxyService(
+      new ProxyConfigServiceFixed(proxy_config), capturing_proxy_resolver,
+      NULL));
 
   HttpRequestInfo request;
   request.method = "GET";
diff --git a/net/net.gyp b/net/net.gyp
index 1ed0833..5a25071 100644
--- a/net/net.gyp
+++ b/net/net.gyp
@@ -590,11 +590,6 @@
               'third_party/nss/ssl.gyp:ssl',
               'tld_cleanup',
             ],
-            'link_settings': {
-              'libraries': [
-                '-lIphlpapi.lib',
-              ],
-            },
           },
           {  # else: OS != "win"
             'dependencies': [
@@ -662,9 +657,9 @@
         'base/mapped_host_resolver_unittest.cc',
         'base/mime_sniffer_unittest.cc',
         'base/mime_util_unittest.cc',
-        'base/mock_network_change_notifier.h',
         'base/net_log_unittest.h',
         'base/net_test_constants.h',
+        'base/net_test_suite.h',
         'base/net_util_unittest.cc',
         'base/registry_controlled_domain_unittest.cc',
         'base/run_all_unittests.cc',
diff --git a/net/proxy/proxy_script_fetcher_unittest.cc b/net/proxy/proxy_script_fetcher_unittest.cc
index ff12ebc..c3925e3 100644
--- a/net/proxy/proxy_script_fetcher_unittest.cc
+++ b/net/proxy/proxy_script_fetcher_unittest.cc
@@ -32,16 +32,14 @@ class RequestContext : public URLRequestContext {
  public:
   RequestContext() {
     net::ProxyConfig no_proxy;
-    host_resolver_ = net::CreateSystemHostResolver(NULL);
+    host_resolver_ = net::CreateSystemHostResolver();
     proxy_service_ = net::ProxyService::CreateFixed(no_proxy);
     ssl_config_service_ = new net::SSLConfigServiceDefaults;
 
-    http_transaction_factory_ =
-        new net::HttpCache(
-            net::HttpNetworkLayer::CreateFactory(
-                NULL, host_resolver_, proxy_service_, ssl_config_service_,
-                NULL, NULL, NULL),
-            net::HttpCache::DefaultBackend::InMemory(0));
+    http_transaction_factory_ = new net::HttpCache(
+        net::HttpNetworkLayer::CreateFactory(host_resolver_, proxy_service_,
+            ssl_config_service_, NULL, NULL, NULL),
+        net::HttpCache::DefaultBackend::InMemory(0));
   }
 
  private:
diff --git a/net/proxy/proxy_service.cc b/net/proxy/proxy_service.cc
index 002c514..cb7da0c 100644
--- a/net/proxy/proxy_service.cc
+++ b/net/proxy/proxy_service.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 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.
 
@@ -200,7 +200,6 @@ class ProxyService::PacRequest
 
 ProxyService::ProxyService(ProxyConfigService* config_service,
                            ProxyResolver* resolver,
-                           NetworkChangeNotifier* network_change_notifier,
                            NetLog* net_log)
     : config_service_(config_service),
       resolver_(resolver),
@@ -208,11 +207,8 @@ ProxyService::ProxyService(ProxyConfigService* config_service,
       should_use_proxy_resolver_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(init_proxy_resolver_callback_(
           this, &ProxyService::OnInitProxyResolverComplete)),
-      net_log_(net_log),
-      network_change_notifier_(network_change_notifier) {
-  // Register to receive network change notifications.
-  if (network_change_notifier_)
-    network_change_notifier_->AddObserver(this);
+      net_log_(net_log) {
+  NetworkChangeNotifier::AddObserver(this);
 }
 
 // static
@@ -220,7 +216,6 @@ ProxyService* ProxyService::Create(
     ProxyConfigService* proxy_config_service,
     bool use_v8_resolver,
     URLRequestContext* url_request_context,
-    NetworkChangeNotifier* network_change_notifier,
     NetLog* net_log,
     MessageLoop* io_loop) {
   ProxyResolver* proxy_resolver = NULL;
@@ -249,9 +244,8 @@ ProxyService* ProxyService::Create(
         new SingleThreadedProxyResolver(CreateNonV8ProxyResolver());
   }
 
-  ProxyService* proxy_service = new ProxyService(
-      proxy_config_service, proxy_resolver, network_change_notifier,
-      net_log);
+  ProxyService* proxy_service =
+      new ProxyService(proxy_config_service, proxy_resolver, net_log);
 
   if (proxy_resolver->expects_pac_bytes()) {
     // Configure PAC script downloads to be issued using |url_request_context|.
@@ -265,16 +259,13 @@ ProxyService* ProxyService::Create(
 
 // static
 ProxyService* ProxyService::CreateFixed(const ProxyConfig& pc) {
-  return Create(new ProxyConfigServiceFixed(pc), false, NULL, NULL,
-                NULL, NULL);
+  return Create(new ProxyConfigServiceFixed(pc), false, NULL, NULL, NULL);
 }
 
 // static
 ProxyService* ProxyService::CreateNull() {
   // Use a configuration fetcher and proxy resolver which always fail.
-  return new ProxyService(new ProxyConfigServiceNull,
-                          new ProxyResolverNull,
-                          NULL,
+  return new ProxyService(new ProxyConfigServiceNull, new ProxyResolverNull,
                           NULL);
 }
 
@@ -341,9 +332,7 @@ int ProxyService::TryToCompleteSynchronously(const GURL& url,
 }
 
 ProxyService::~ProxyService() {
-  // Unregister to receive network change notifications.
-  if (network_change_notifier_)
-    network_change_notifier_->RemoveObserver(this);
+  NetworkChangeNotifier::RemoveObserver(this);
 
   // Cancel any inprogress requests.
   for (PendingRequests::iterator it = pending_requests_.begin();
@@ -675,8 +664,6 @@ void ProxyService::UpdateConfigIfOld(const BoundNetLog& net_log) {
 
 
 void ProxyService::OnIPAddressChanged() {
-  DCHECK(network_change_notifier_);
-
   // Mark the current configuration as being un-initialized.
   //
   // This will force us to re-fetch the configuration (and re-run all of
diff --git a/net/proxy/proxy_service.h b/net/proxy/proxy_service.h
index 49c7979..22435e4 100644
--- a/net/proxy/proxy_service.h
+++ b/net/proxy/proxy_service.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 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.
 
@@ -36,13 +36,10 @@ class ProxyService : public base::RefCountedThreadSafe<ProxyService>,
                      public NetworkChangeNotifier::Observer {
  public:
   // The instance takes ownership of |config_service| and |resolver|.
-  // If |network_change_notifier| is non-NULL, the proxy service will register
-  // with it to detect when the network setup has changed. This is used to
-  // decide when to re-configure the proxy discovery.
   // |net_log| is a possibly NULL destination to send log events to. It must
   // remain alive for the lifetime of this ProxyService.
-  ProxyService(ProxyConfigService* config_service, ProxyResolver* resolver,
-               NetworkChangeNotifier* network_change_notifier,
+  ProxyService(ProxyConfigService* config_service,
+               ProxyResolver* resolver,
                NetLog* net_log);
 
   // Used internally to handle PAC queries.
@@ -143,8 +140,6 @@ class ProxyService : public base::RefCountedThreadSafe<ProxyService>,
   // |url_request_context| is only used when use_v8_resolver is true:
   // it specifies the URL request context that will be used if a PAC
   // script needs to be fetched.
-  // |network_change_notifier| may be NULL. Otherwise it will be used to
-  // signal the ProxyService when the network setup has changed.
   // |io_loop| points to the IO thread's message loop. It is only used
   // when pc is NULL.
   // ##########################################################################
@@ -156,7 +151,6 @@ class ProxyService : public base::RefCountedThreadSafe<ProxyService>,
       ProxyConfigService* proxy_config_service,
       bool use_v8_resolver,
       URLRequestContext* url_request_context,
-      NetworkChangeNotifier* network_change_notifier,
       NetLog* net_log,
       MessageLoop* io_loop);
 
@@ -244,7 +238,8 @@ class ProxyService : public base::RefCountedThreadSafe<ProxyService>,
                               int result_code,
                               const BoundNetLog& net_log);
 
-  // NetworkChangeNotifier::Observer methods:
+  // NetworkChangeNotifier::Observer
+  // When this is called, we re-fetch PAC scripts and re-run WPAD.
   virtual void OnIPAddressChanged();
 
   scoped_ptr<ProxyConfigService> config_service_;
@@ -287,10 +282,6 @@ class ProxyService : public base::RefCountedThreadSafe<ProxyService>,
   // sent to.
   NetLog* net_log_;
 
-  // The (possibly NULL) network change notifier that we use to decide when
-  // to refetch PAC scripts or re-run WPAD.
-  NetworkChangeNotifier* const network_change_notifier_;
-
   DISALLOW_COPY_AND_ASSIGN(ProxyService);
 };
 
@@ -301,9 +292,12 @@ class SyncProxyServiceHelper
   SyncProxyServiceHelper(MessageLoop* io_message_loop,
                          ProxyService* proxy_service);
 
-  int ResolveProxy(const GURL& url, ProxyInfo* proxy_info, const BoundNetLog& net_log);
+  int ResolveProxy(const GURL& url,
+                   ProxyInfo* proxy_info,
+                   const BoundNetLog& net_log);
   int ReconsiderProxyAfterError(const GURL& url,
-                                ProxyInfo* proxy_info, const BoundNetLog& net_log);
+                                ProxyInfo* proxy_info,
+                                const BoundNetLog& net_log);
 
  private:
   friend class base::RefCountedThreadSafe<SyncProxyServiceHelper>;
diff --git a/net/proxy/proxy_service_unittest.cc b/net/proxy/proxy_service_unittest.cc
index f5e76d9..3cf80cd 100644
--- a/net/proxy/proxy_service_unittest.cc
+++ b/net/proxy/proxy_service_unittest.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 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.
 
@@ -12,7 +12,6 @@
 #include "googleurl/src/gurl.h"
 #include "net/base/net_log.h"
 #include "net/base/net_log_unittest.h"
-#include "net/base/mock_network_change_notifier.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/proxy/mock_proxy_resolver.h"
@@ -92,7 +91,7 @@ class MockProxyScriptFetcher : public ProxyScriptFetcher {
 TEST(ProxyServiceTest, Direct) {
   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
   scoped_refptr<ProxyService> service(
-      new ProxyService(new MockProxyConfigService, resolver, NULL, NULL));
+      new ProxyService(new MockProxyConfigService, resolver, NULL));
 
   GURL url("http://www.google.com/");
 
@@ -120,7 +119,7 @@ TEST(ProxyServiceTest, PAC) {
   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
 
   scoped_refptr<ProxyService> service(
-      new ProxyService(config_service, resolver, NULL, NULL));
+      new ProxyService(config_service, resolver, NULL));
 
   GURL url("http://www.google.com/");
 
@@ -167,7 +166,7 @@ TEST(ProxyServiceTest, PAC_NoIdentityOrHash) {
   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
 
   scoped_refptr<ProxyService> service(
-      new ProxyService(config_service, resolver, NULL, NULL));
+      new ProxyService(config_service, resolver, NULL));
 
   GURL url("http://username:password@www.google.com/?ref#hash#hash");
 
@@ -195,7 +194,7 @@ TEST(ProxyServiceTest, PAC_FailoverWithoutDirect) {
   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
 
   scoped_refptr<ProxyService> service(
-      new ProxyService(config_service, resolver, NULL, NULL));
+      new ProxyService(config_service, resolver, NULL));
 
   GURL url("http://www.google.com/");
 
@@ -253,7 +252,7 @@ TEST(ProxyServiceTest, PAC_FailoverAfterDirect) {
   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
 
   scoped_refptr<ProxyService> service(
-      new ProxyService(config_service, resolver, NULL, NULL));
+      new ProxyService(config_service, resolver, NULL));
 
   GURL url("http://www.google.com/");
 
@@ -319,7 +318,7 @@ TEST(ProxyServiceTest, ProxyResolverFails) {
   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
 
   scoped_refptr<ProxyService> service(
-      new ProxyService(config_service, resolver, NULL, NULL));
+      new ProxyService(config_service, resolver, NULL));
 
   // Start first resolve request.
   GURL url("http://www.google.com/");
@@ -372,7 +371,7 @@ TEST(ProxyServiceTest, ProxyFallback) {
   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
 
   scoped_refptr<ProxyService> service(
-      new ProxyService(config_service, resolver, NULL, NULL));
+      new ProxyService(config_service, resolver, NULL));
 
   GURL url("http://www.google.com/");
 
@@ -462,7 +461,7 @@ TEST(ProxyServiceTest, ProxyFallbackToDirect) {
   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
 
   scoped_refptr<ProxyService> service(
-      new ProxyService(config_service, resolver, NULL, NULL));
+      new ProxyService(config_service, resolver, NULL));
 
   GURL url("http://www.google.com/");
 
@@ -525,7 +524,7 @@ TEST(ProxyServiceTest, ProxyFallback_NewSettings) {
   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
 
   scoped_refptr<ProxyService> service(
-      new ProxyService(config_service, resolver, NULL, NULL));
+      new ProxyService(config_service, resolver, NULL));
 
   GURL url("http://www.google.com/");
 
@@ -617,7 +616,7 @@ TEST(ProxyServiceTest, ProxyFallback_BadConfig) {
   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
 
   scoped_refptr<ProxyService> service(
-      new ProxyService(config_service, resolver, NULL, NULL));
+      new ProxyService(config_service, resolver, NULL));
 
   GURL url("http://www.google.com/");
 
@@ -704,8 +703,7 @@ TEST(ProxyServiceTest, ProxyBypassList) {
   config.proxy_rules().bypass_rules.ParseFromString("*.org");
 
   scoped_refptr<ProxyService> service(new ProxyService(
-      new MockProxyConfigService(config), new MockAsyncProxyResolver, NULL,
-      NULL));
+      new MockProxyConfigService(config), new MockAsyncProxyResolver, NULL));
 
   int rv;
   GURL url1("http://www.webkit.org");
@@ -729,8 +727,7 @@ TEST(ProxyServiceTest, PerProtocolProxyTests) {
   config.set_auto_detect(false);
   {
     scoped_refptr<ProxyService> service(new ProxyService(
-        new MockProxyConfigService(config), new MockAsyncProxyResolver, NULL,
-        NULL));
+        new MockProxyConfigService(config), new MockAsyncProxyResolver, NULL));
     GURL test_url("http://www.msn.com");
     ProxyInfo info;
     TestCompletionCallback callback;
@@ -742,8 +739,7 @@ TEST(ProxyServiceTest, PerProtocolProxyTests) {
   }
   {
     scoped_refptr<ProxyService> service(new ProxyService(
-        new MockProxyConfigService(config), new MockAsyncProxyResolver, NULL,
-        NULL));
+        new MockProxyConfigService(config), new MockAsyncProxyResolver, NULL));
     GURL test_url("ftp://ftp.google.com");
     ProxyInfo info;
     TestCompletionCallback callback;
@@ -755,8 +751,7 @@ TEST(ProxyServiceTest, PerProtocolProxyTests) {
   }
   {
     scoped_refptr<ProxyService> service(new ProxyService(
-        new MockProxyConfigService(config), new MockAsyncProxyResolver, NULL,
-        NULL));
+        new MockProxyConfigService(config), new MockAsyncProxyResolver, NULL));
     GURL test_url("https://webbranch.techcu.com");
     ProxyInfo info;
     TestCompletionCallback callback;
@@ -769,8 +764,7 @@ TEST(ProxyServiceTest, PerProtocolProxyTests) {
   {
     config.proxy_rules().ParseFromString("foopy1:8080");
     scoped_refptr<ProxyService> service(new ProxyService(
-        new MockProxyConfigService(config), new MockAsyncProxyResolver, NULL,
-        NULL));
+        new MockProxyConfigService(config), new MockAsyncProxyResolver, NULL));
     GURL test_url("http://www.microsoft.com");
     ProxyInfo info;
     TestCompletionCallback callback;
@@ -793,8 +787,7 @@ TEST(ProxyServiceTest, DefaultProxyFallbackToSOCKS) {
 
   {
     scoped_refptr<ProxyService> service(new ProxyService(
-        new MockProxyConfigService(config), new MockAsyncProxyResolver, NULL,
-        NULL));
+        new MockProxyConfigService(config), new MockAsyncProxyResolver, NULL));
     GURL test_url("http://www.msn.com");
     ProxyInfo info;
     TestCompletionCallback callback;
@@ -806,8 +799,7 @@ TEST(ProxyServiceTest, DefaultProxyFallbackToSOCKS) {
   }
   {
     scoped_refptr<ProxyService> service(new ProxyService(
-        new MockProxyConfigService(config), new MockAsyncProxyResolver, NULL,
-        NULL));
+        new MockProxyConfigService(config), new MockAsyncProxyResolver, NULL));
     GURL test_url("ftp://ftp.google.com");
     ProxyInfo info;
     TestCompletionCallback callback;
@@ -819,8 +811,7 @@ TEST(ProxyServiceTest, DefaultProxyFallbackToSOCKS) {
   }
   {
     scoped_refptr<ProxyService> service(new ProxyService(
-        new MockProxyConfigService(config), new MockAsyncProxyResolver, NULL,
-        NULL));
+        new MockProxyConfigService(config), new MockAsyncProxyResolver, NULL));
     GURL test_url("https://webbranch.techcu.com");
     ProxyInfo info;
     TestCompletionCallback callback;
@@ -832,8 +823,7 @@ TEST(ProxyServiceTest, DefaultProxyFallbackToSOCKS) {
   }
   {
     scoped_refptr<ProxyService> service(new ProxyService(
-        new MockProxyConfigService(config), new MockAsyncProxyResolver, NULL,
-        NULL));
+        new MockProxyConfigService(config), new MockAsyncProxyResolver, NULL));
     GURL test_url("unknown://www.microsoft.com");
     ProxyInfo info;
     TestCompletionCallback callback;
@@ -853,7 +843,7 @@ TEST(ProxyServiceTest, CancelInProgressRequest) {
   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
 
   scoped_refptr<ProxyService> service(
-      new ProxyService(config_service, resolver, NULL, NULL));
+      new ProxyService(config_service, resolver, NULL));
 
   // Start 3 requests.
 
@@ -928,7 +918,7 @@ TEST(ProxyServiceTest, InitialPACScriptDownload) {
       new MockAsyncProxyResolverExpectsBytes;
 
   scoped_refptr<ProxyService> service(
-      new ProxyService(config_service, resolver, NULL, NULL));
+      new ProxyService(config_service, resolver, NULL));
 
   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   service->SetProxyScriptFetcher(fetcher);
@@ -1007,7 +997,7 @@ TEST(ProxyServiceTest, ChangeScriptFetcherWhilePACDownloadInProgress) {
       new MockAsyncProxyResolverExpectsBytes;
 
   scoped_refptr<ProxyService> service(
-      new ProxyService(config_service, resolver, NULL, NULL));
+      new ProxyService(config_service, resolver, NULL));
 
   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   service->SetProxyScriptFetcher(fetcher);
@@ -1064,7 +1054,7 @@ TEST(ProxyServiceTest, CancelWhilePACFetching) {
       new MockAsyncProxyResolverExpectsBytes;
 
   scoped_refptr<ProxyService> service(
-      new ProxyService(config_service, resolver, NULL, NULL));
+      new ProxyService(config_service, resolver, NULL));
 
   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   service->SetProxyScriptFetcher(fetcher);
@@ -1152,7 +1142,7 @@ TEST(ProxyServiceTest, FallbackFromAutodetectToCustomPac) {
   MockAsyncProxyResolverExpectsBytes* resolver =
       new MockAsyncProxyResolverExpectsBytes;
   scoped_refptr<ProxyService> service(
-      new ProxyService(config_service, resolver, NULL, NULL));
+      new ProxyService(config_service, resolver, NULL));
 
   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   service->SetProxyScriptFetcher(fetcher);
@@ -1223,7 +1213,7 @@ TEST(ProxyServiceTest, FallbackFromAutodetectToCustomPac2) {
   MockAsyncProxyResolverExpectsBytes* resolver =
       new MockAsyncProxyResolverExpectsBytes;
   scoped_refptr<ProxyService> service(
-      new ProxyService(config_service, resolver, NULL, NULL));
+      new ProxyService(config_service, resolver, NULL));
 
   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   service->SetProxyScriptFetcher(fetcher);
@@ -1299,7 +1289,7 @@ TEST(ProxyServiceTest, FallbackFromAutodetectToCustomToManual) {
   MockAsyncProxyResolverExpectsBytes* resolver =
       new MockAsyncProxyResolverExpectsBytes;
   scoped_refptr<ProxyService> service(
-      new ProxyService(config_service, resolver, NULL, NULL));
+      new ProxyService(config_service, resolver, NULL));
 
   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   service->SetProxyScriptFetcher(fetcher);
@@ -1357,7 +1347,7 @@ TEST(ProxyServiceTest, BypassDoesntApplyToPac) {
   MockAsyncProxyResolverExpectsBytes* resolver =
       new MockAsyncProxyResolverExpectsBytes;
   scoped_refptr<ProxyService> service(
-      new ProxyService(config_service, resolver, NULL, NULL));
+      new ProxyService(config_service, resolver, NULL));
 
   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   service->SetProxyScriptFetcher(fetcher);
@@ -1425,7 +1415,7 @@ TEST(ProxyServiceTest, DeleteWhileInitProxyResolverHasOutstandingFetch) {
   MockAsyncProxyResolverExpectsBytes* resolver =
       new MockAsyncProxyResolverExpectsBytes;
   scoped_refptr<ProxyService> service(
-      new ProxyService(config_service, resolver, NULL, NULL));
+      new ProxyService(config_service, resolver, NULL));
 
   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   service->SetProxyScriptFetcher(fetcher);
@@ -1461,7 +1451,7 @@ TEST(ProxyServiceTest, DeleteWhileInitProxyResolverHasOutstandingSet) {
   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
 
   scoped_refptr<ProxyService> service(
-      new ProxyService(config_service, resolver, NULL, NULL));
+      new ProxyService(config_service, resolver, NULL));
 
   GURL url("http://www.google.com/");
 
@@ -1483,8 +1473,7 @@ TEST(ProxyServiceTest, ResetProxyConfigService) {
   config1.set_auto_detect(false);
   scoped_refptr<ProxyService> service(new ProxyService(
       new MockProxyConfigService(config1),
-      new MockAsyncProxyResolverExpectsBytes,
-      NULL, NULL));
+      new MockAsyncProxyResolverExpectsBytes, NULL));
 
   ProxyInfo info;
   TestCompletionCallback callback1;
@@ -1516,7 +1505,7 @@ TEST(ProxyServiceTest, UpdateConfigAfterFailedAutodetect) {
   MockProxyConfigService* config_service = new MockProxyConfigService(config);
   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
   scoped_refptr<ProxyService> service(
-      new ProxyService(config_service, resolver, NULL, NULL));
+      new ProxyService(config_service, resolver, NULL));
 
   // Start 1 requests.
 
@@ -1562,7 +1551,7 @@ TEST(ProxyServiceTest, UpdateConfigFromPACToDirect) {
   MockProxyConfigService* config_service = new MockProxyConfigService(config);
   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
   scoped_refptr<ProxyService> service(
-      new ProxyService(config_service, resolver, NULL, NULL));
+      new ProxyService(config_service, resolver, NULL));
 
   // Start 1 request.
 
@@ -1614,11 +1603,8 @@ TEST(ProxyServiceTest, NetworkChangeTriggersPacRefetch) {
   MockAsyncProxyResolverExpectsBytes* resolver =
       new MockAsyncProxyResolverExpectsBytes;
 
-  MockNetworkChangeNotifier network_change_notifier;
-
   scoped_refptr<ProxyService> service(
-      new ProxyService(config_service, resolver, &network_change_notifier,
-                       NULL));
+      new ProxyService(config_service, resolver, NULL));
 
   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   service->SetProxyScriptFetcher(fetcher);
@@ -1662,8 +1648,8 @@ TEST(ProxyServiceTest, NetworkChangeTriggersPacRefetch) {
   // Now simluate a change in the network. The ProxyConfigService is still
   // going to return the same PAC URL as before, but this URL needs to be
   // refetched on the new network.
-
-  network_change_notifier.NotifyIPAddressChange();
+  NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
+  MessageLoop::current()->RunAllPending();  // Notification happens async.
 
   // Start a second request.
   ProxyInfo info2;
diff --git a/net/socket/client_socket_pool_base.cc b/net/socket/client_socket_pool_base.cc
index 1ff2789..40daa35 100644
--- a/net/socket/client_socket_pool_base.cc
+++ b/net/socket/client_socket_pool_base.cc
@@ -128,8 +128,7 @@ ClientSocketPoolBaseHelper::ClientSocketPoolBaseHelper(
     int max_sockets_per_group,
     base::TimeDelta unused_idle_socket_timeout,
     base::TimeDelta used_idle_socket_timeout,
-    ConnectJobFactory* connect_job_factory,
-    NetworkChangeNotifier* network_change_notifier)
+    ConnectJobFactory* connect_job_factory)
     : idle_socket_count_(0),
       connecting_socket_count_(0),
       handed_out_socket_count_(0),
@@ -140,15 +139,13 @@ ClientSocketPoolBaseHelper::ClientSocketPoolBaseHelper(
       used_idle_socket_timeout_(used_idle_socket_timeout),
       may_have_stalled_group_(false),
       connect_job_factory_(connect_job_factory),
-      network_change_notifier_(network_change_notifier),
       backup_jobs_enabled_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)),
       pool_generation_number_(0) {
   DCHECK_LE(0, max_sockets_per_group);
   DCHECK_LE(max_sockets_per_group, max_sockets);
 
-  if (network_change_notifier_)
-    network_change_notifier_->AddObserver(this);
+  NetworkChangeNotifier::AddObserver(this);
 }
 
 ClientSocketPoolBaseHelper::~ClientSocketPoolBaseHelper() {
@@ -161,8 +158,7 @@ ClientSocketPoolBaseHelper::~ClientSocketPoolBaseHelper() {
   CHECK(group_map_.empty());
   DCHECK_EQ(0, connecting_socket_count_);
 
-  if (network_change_notifier_)
-    network_change_notifier_->RemoveObserver(this);
+  NetworkChangeNotifier::RemoveObserver(this);
 }
 
 // InsertRequestIntoQueue inserts the request into the queue based on
@@ -383,8 +379,8 @@ void ClientSocketPoolBaseHelper::ReleaseSocket(const std::string& group_name,
   // Run this asynchronously to allow the caller to finish before we let
   // another to begin doing work.  This also avoids nasty recursion issues.
   // NOTE: We cannot refer to the handle argument after this method returns.
-  MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(
-      this, &ClientSocketPoolBaseHelper::DoReleaseSocket, group_name, socket, id));
+  MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(this,
+      &ClientSocketPoolBaseHelper::DoReleaseSocket, group_name, socket, id));
 }
 
 void ClientSocketPoolBaseHelper::CloseIdleSockets() {
@@ -640,6 +636,10 @@ void ClientSocketPoolBaseHelper::OnConnectJobComplete(
   }
 }
 
+void ClientSocketPoolBaseHelper::OnIPAddressChanged() {
+  Flush();
+}
+
 void ClientSocketPoolBaseHelper::Flush() {
   pool_generation_number_++;
   CancelAllConnectJobs();
diff --git a/net/socket/client_socket_pool_base.h b/net/socket/client_socket_pool_base.h
index 942142d..deb405d 100644
--- a/net/socket/client_socket_pool_base.h
+++ b/net/socket/client_socket_pool_base.h
@@ -174,8 +174,7 @@ class ClientSocketPoolBaseHelper
       int max_sockets_per_group,
       base::TimeDelta unused_idle_socket_timeout,
       base::TimeDelta used_idle_socket_timeout,
-      ConnectJobFactory* connect_job_factory,
-      NetworkChangeNotifier* network_change_notifier);
+      ConnectJobFactory* connect_job_factory);
 
   // See ClientSocketPool::RequestSocket for documentation on this function.
   // ClientSocketPoolBaseHelper takes ownership of |request|, which must be
@@ -220,7 +219,7 @@ class ClientSocketPoolBaseHelper
   virtual void OnConnectJobComplete(int result, ConnectJob* job);
 
   // NetworkChangeNotifier::Observer methods:
-  virtual void OnIPAddressChanged() { Flush(); }
+  virtual void OnIPAddressChanged();
 
   // For testing.
   bool may_have_stalled_group() const { return may_have_stalled_group_; }
@@ -460,8 +459,6 @@ class ClientSocketPoolBaseHelper
 
   const scoped_ptr<ConnectJobFactory> connect_job_factory_;
 
-  NetworkChangeNotifier* const network_change_notifier_;
-
   // TODO(vandebo) Remove when backup jobs move to TCPClientSocketPool
   bool backup_jobs_enabled_;
 
@@ -527,14 +524,12 @@ class ClientSocketPoolBase {
       const scoped_refptr<ClientSocketPoolHistograms>& histograms,
       base::TimeDelta unused_idle_socket_timeout,
       base::TimeDelta used_idle_socket_timeout,
-      ConnectJobFactory* connect_job_factory,
-      NetworkChangeNotifier* network_change_notifier)
+      ConnectJobFactory* connect_job_factory)
       : histograms_(histograms),
         helper_(new internal::ClientSocketPoolBaseHelper(
           max_sockets, max_sockets_per_group,
           unused_idle_socket_timeout, used_idle_socket_timeout,
-          new ConnectJobFactoryAdaptor(connect_job_factory),
-          network_change_notifier)) {}
+          new ConnectJobFactoryAdaptor(connect_job_factory))) {}
 
   virtual ~ClientSocketPoolBase() {}
 
diff --git a/net/socket/client_socket_pool_base_unittest.cc b/net/socket/client_socket_pool_base_unittest.cc
index c9ad282..7b84d94 100644
--- a/net/socket/client_socket_pool_base_unittest.cc
+++ b/net/socket/client_socket_pool_base_unittest.cc
@@ -293,7 +293,7 @@ class TestClientSocketPool : public ClientSocketPool {
       TestClientSocketPoolBase::ConnectJobFactory* connect_job_factory)
       : base_(max_sockets, max_sockets_per_group, histograms,
               unused_idle_socket_timeout, used_idle_socket_timeout,
-              connect_job_factory, NULL) {}
+              connect_job_factory) {}
 
   virtual int RequestSocket(
       const std::string& group_name,
diff --git a/net/socket/socks_client_socket_pool.cc b/net/socket/socks_client_socket_pool.cc
index 455b671..3e025cb 100644
--- a/net/socket/socks_client_socket_pool.cc
+++ b/net/socket/socks_client_socket_pool.cc
@@ -163,14 +163,13 @@ SOCKSClientSocketPool::SOCKSClientSocketPool(
     const scoped_refptr<ClientSocketPoolHistograms>& histograms,
     const scoped_refptr<HostResolver>& host_resolver,
     const scoped_refptr<TCPClientSocketPool>& tcp_pool,
-    NetworkChangeNotifier* network_change_notifier,
     NetLog* net_log)
     : base_(max_sockets, max_sockets_per_group, histograms,
             base::TimeDelta::FromSeconds(
                 ClientSocketPool::unused_idle_socket_timeout()),
             base::TimeDelta::FromSeconds(kUsedIdleSocketTimeout),
-            new SOCKSConnectJobFactory(tcp_pool, host_resolver, net_log),
-            network_change_notifier) {}
+            new SOCKSConnectJobFactory(tcp_pool, host_resolver, net_log)) {
+}
 
 SOCKSClientSocketPool::~SOCKSClientSocketPool() {}
 
diff --git a/net/socket/socks_client_socket_pool.h b/net/socket/socks_client_socket_pool.h
index b0b9b4b..7da2af54 100644
--- a/net/socket/socks_client_socket_pool.h
+++ b/net/socket/socks_client_socket_pool.h
@@ -111,7 +111,6 @@ class SOCKSClientSocketPool : public ClientSocketPool {
       const scoped_refptr<ClientSocketPoolHistograms>& histograms,
       const scoped_refptr<HostResolver>& host_resolver,
       const scoped_refptr<TCPClientSocketPool>& tcp_pool,
-      NetworkChangeNotifier* network_change_notifier,
       NetLog* net_log);
 
   // ClientSocketPool methods:
diff --git a/net/socket/socks_client_socket_pool_unittest.cc b/net/socket/socks_client_socket_pool_unittest.cc
index 452fbcc..fb83d96 100644
--- a/net/socket/socks_client_socket_pool_unittest.cc
+++ b/net/socket/socks_client_socket_pool_unittest.cc
@@ -10,7 +10,6 @@
 #include "base/compiler_specific.h"
 #include "base/time.h"
 #include "net/base/mock_host_resolver.h"
-#include "net/base/mock_network_change_notifier.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/socket/client_socket_factory.h"
@@ -82,12 +81,13 @@ class MockTCPClientSocketPool : public TCPClientSocketPool {
     DISALLOW_COPY_AND_ASSIGN(MockConnectJob);
   };
 
-  MockTCPClientSocketPool(int max_sockets, int max_sockets_per_group,
+  MockTCPClientSocketPool(
+      int max_sockets,
+      int max_sockets_per_group,
       const scoped_refptr<ClientSocketPoolHistograms>& histograms,
-      ClientSocketFactory* socket_factory,
-      NetworkChangeNotifier* network_change_notifier)
+      ClientSocketFactory* socket_factory)
       : TCPClientSocketPool(max_sockets, max_sockets_per_group, histograms,
-                            NULL, NULL, network_change_notifier, NULL),
+                            NULL, NULL, NULL),
         client_socket_factory_(socket_factory),
         release_count_(0),
         cancel_count_(0) {}
@@ -174,16 +174,13 @@ class SOCKSClientSocketPoolTest : public ClientSocketPoolTest {
       : ignored_tcp_socket_params_(
             HostPortPair("proxy", 80), MEDIUM, GURL(), false),
         tcp_histograms_(new ClientSocketPoolHistograms("MockTCP")),
-        tcp_socket_pool_(new MockTCPClientSocketPool(
-            kMaxSockets, kMaxSocketsPerGroup, tcp_histograms_,
-            &tcp_client_socket_factory_, &tcp_notifier_)),
+        tcp_socket_pool_(new MockTCPClientSocketPool(kMaxSockets,
+            kMaxSocketsPerGroup, tcp_histograms_, &tcp_client_socket_factory_)),
         ignored_socket_params_(ignored_tcp_socket_params_, true,
-                               HostPortPair("host", 80),
-                               MEDIUM, GURL()),
+                               HostPortPair("host", 80), MEDIUM, GURL()),
         socks_histograms_(new ClientSocketPoolHistograms("SOCKSUnitTest")),
-        pool_(new SOCKSClientSocketPool(
-            kMaxSockets, kMaxSocketsPerGroup, socks_histograms_, NULL,
-            tcp_socket_pool_, &socks_notifier_, NULL)) {
+        pool_(new SOCKSClientSocketPool(kMaxSockets, kMaxSocketsPerGroup,
+            socks_histograms_, NULL, tcp_socket_pool_, NULL)) {
   }
 
   int StartRequest(const std::string& group_name, RequestPriority priority) {
@@ -194,12 +191,10 @@ class SOCKSClientSocketPoolTest : public ClientSocketPoolTest {
   TCPSocketParams ignored_tcp_socket_params_;
   scoped_refptr<ClientSocketPoolHistograms> tcp_histograms_;
   MockClientSocketFactory tcp_client_socket_factory_;
-  MockNetworkChangeNotifier tcp_notifier_;
   scoped_refptr<MockTCPClientSocketPool> tcp_socket_pool_;
 
   SOCKSSocketParams ignored_socket_params_;
   scoped_refptr<ClientSocketPoolHistograms> socks_histograms_;
-  MockNetworkChangeNotifier socks_notifier_;
   scoped_refptr<SOCKSClientSocketPool> pool_;
 };
 
diff --git a/net/socket/ssl_client_socket_unittest.cc b/net/socket/ssl_client_socket_unittest.cc
index 7eec8fa..68016e0 100644
--- a/net/socket/ssl_client_socket_unittest.cc
+++ b/net/socket/ssl_client_socket_unittest.cc
@@ -26,7 +26,7 @@ const net::SSLConfig kDefaultSSLConfig;
 class SSLClientSocketTest : public PlatformTest {
  public:
   SSLClientSocketTest()
-    : resolver_(net::CreateSystemHostResolver(NULL)),
+      : resolver_(net::CreateSystemHostResolver()),
         socket_factory_(net::ClientSocketFactory::GetDefaultFactory()) {
   }
 
diff --git a/net/socket/ssl_test_util.cc b/net/socket/ssl_test_util.cc
index 7ef1a83..f2999f0 100644
--- a/net/socket/ssl_test_util.cc
+++ b/net/socket/ssl_test_util.cc
@@ -229,8 +229,7 @@ bool TestServerLauncher::WaitToStart(const std::string& host_name, int port) {
   // Verify that the webserver is actually started.
   // Otherwise tests can fail if they run faster than Python can start.
   net::AddressList addr;
-  scoped_refptr<net::HostResolver> resolver(
-      net::CreateSystemHostResolver(NULL));
+  scoped_refptr<net::HostResolver> resolver(net::CreateSystemHostResolver());
   net::HostResolver::RequestInfo info(host_name, port);
   int rv = resolver->Resolve(info, &addr, NULL, NULL, BoundNetLog());
   if (rv != net::OK)
@@ -369,7 +368,7 @@ bool LaunchTestServerAsJob(const std::wstring& cmdline,
   PROCESS_INFORMATION process_info;
 
   // If this code is run under a debugger, the test server process is
-  // automatically associated with a job object created by the debugger. 
+  // automatically associated with a job object created by the debugger.
   // The CREATE_BREAKAWAY_FROM_JOB flag is used to prevent this.
   if (!CreateProcess(NULL,
                      const_cast<wchar_t*>(cmdline.c_str()), NULL, NULL,
diff --git a/net/socket/tcp_client_socket_pool.cc b/net/socket/tcp_client_socket_pool.cc
index f2e9609..7937ef9 100644
--- a/net/socket/tcp_client_socket_pool.cc
+++ b/net/socket/tcp_client_socket_pool.cc
@@ -178,15 +178,13 @@ TCPClientSocketPool::TCPClientSocketPool(
     const scoped_refptr<ClientSocketPoolHistograms>& histograms,
     HostResolver* host_resolver,
     ClientSocketFactory* client_socket_factory,
-    NetworkChangeNotifier* network_change_notifier,
     NetLog* net_log)
     : base_(max_sockets, max_sockets_per_group, histograms,
             base::TimeDelta::FromSeconds(
                 ClientSocketPool::unused_idle_socket_timeout()),
             base::TimeDelta::FromSeconds(kUsedIdleSocketTimeout),
             new TCPConnectJobFactory(client_socket_factory,
-                                     host_resolver, net_log),
-            network_change_notifier) {
+                                     host_resolver, net_log)) {
   base_.EnableBackupJobs();
 }
 
diff --git a/net/socket/tcp_client_socket_pool.h b/net/socket/tcp_client_socket_pool.h
index 07ce3fa..6c7d483 100644
--- a/net/socket/tcp_client_socket_pool.h
+++ b/net/socket/tcp_client_socket_pool.h
@@ -118,7 +118,6 @@ class TCPClientSocketPool : public ClientSocketPool {
       const scoped_refptr<ClientSocketPoolHistograms>& histograms,
       HostResolver* host_resolver,
       ClientSocketFactory* client_socket_factory,
-      NetworkChangeNotifier* network_change_notifier,
       NetLog* net_log);
 
   // ClientSocketPool methods:
diff --git a/net/socket/tcp_client_socket_pool_unittest.cc b/net/socket/tcp_client_socket_pool_unittest.cc
index 25e7fdd..60ef667 100644
--- a/net/socket/tcp_client_socket_pool_unittest.cc
+++ b/net/socket/tcp_client_socket_pool_unittest.cc
@@ -8,7 +8,6 @@
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
 #include "net/base/mock_host_resolver.h"
-#include "net/base/mock_network_change_notifier.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/socket/client_socket.h"
@@ -272,7 +271,6 @@ class TCPClientSocketPoolTest : public ClientSocketPoolTest {
                                       histograms_,
                                       host_resolver_,
                                       &client_socket_factory_,
-                                      &notifier_,
                                       NULL)) {
   }
 
@@ -285,7 +283,6 @@ class TCPClientSocketPoolTest : public ClientSocketPoolTest {
   scoped_refptr<ClientSocketPoolHistograms> histograms_;
   scoped_refptr<MockHostResolver> host_resolver_;
   MockClientSocketFactory client_socket_factory_;
-  MockNetworkChangeNotifier notifier_;
   scoped_refptr<TCPClientSocketPool> pool_;
 };
 
@@ -684,7 +681,9 @@ TEST_F(TCPClientSocketPoolTest, ResetIdleSocketsOnIPAddressChange) {
   EXPECT_EQ(1, pool_->IdleSocketCount());
 
   // After an IP address change, we should have 0 idle sockets.
-  notifier_.NotifyIPAddressChange();
+  NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
+  MessageLoop::current()->RunAllPending();  // Notification happens async.
+
   EXPECT_EQ(0, pool_->IdleSocketCount());
 }
 
@@ -742,13 +741,8 @@ TEST_F(TCPClientSocketPoolTest, BackupSocketConnect) {
     EXPECT_EQ(0, pool_->IdleSocketCount());
     handle.Reset();
 
-    pool_ = new TCPClientSocketPool(kMaxSockets,
-                                    kMaxSocketsPerGroup,
-                                    histograms_,
-                                    host_resolver_,
-                                    &client_socket_factory_,
-                                    NULL,
-                                    NULL);
+    pool_ = new TCPClientSocketPool(kMaxSockets, kMaxSocketsPerGroup,
+        histograms_, host_resolver_, &client_socket_factory_, NULL);
   }
 }
 
diff --git a/net/socket/tcp_client_socket_unittest.cc b/net/socket/tcp_client_socket_unittest.cc
index a2b584a..30628d3 100644
--- a/net/socket/tcp_client_socket_unittest.cc
+++ b/net/socket/tcp_client_socket_unittest.cc
@@ -89,7 +89,7 @@ void TCPClientSocketTest::SetUp() {
   listen_port_ = port;
 
   AddressList addr;
-  scoped_refptr<HostResolver> resolver(CreateSystemHostResolver(NULL));
+  scoped_refptr<HostResolver> resolver(CreateSystemHostResolver());
   HostResolver::RequestInfo info("localhost", listen_port_);
   int rv = resolver->Resolve(info, &addr, NULL, NULL, BoundNetLog());
   CHECK_EQ(rv, OK);
diff --git a/net/socket/tcp_pinger_unittest.cc b/net/socket/tcp_pinger_unittest.cc
index 29fd78e..8cd4ed4 100644
--- a/net/socket/tcp_pinger_unittest.cc
+++ b/net/socket/tcp_pinger_unittest.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2006-2009 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 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.
 
@@ -65,8 +65,7 @@ void TCPPingerTest::SetUp() {
 
 TEST_F(TCPPingerTest, Ping) {
   net::AddressList addr;
-  scoped_refptr<net::HostResolver> resolver(
-      net::CreateSystemHostResolver(NULL));
+  scoped_refptr<net::HostResolver> resolver(net::CreateSystemHostResolver());
 
   net::HostResolver::RequestInfo info("localhost", listen_port_);
   int rv = resolver->Resolve(info, &addr, NULL, NULL, net::BoundNetLog());
@@ -79,8 +78,7 @@ TEST_F(TCPPingerTest, Ping) {
 
 TEST_F(TCPPingerTest, PingFail) {
   net::AddressList addr;
-  scoped_refptr<net::HostResolver> resolver(
-      net::CreateSystemHostResolver(NULL));
+  scoped_refptr<net::HostResolver> resolver(net::CreateSystemHostResolver());
 
   // "Kill" "server"
   listen_sock_ = NULL;
diff --git a/net/spdy/spdy_http_stream_unittest.cc b/net/spdy/spdy_http_stream_unittest.cc
index c3b321a..d1d3546 100644
--- a/net/spdy/spdy_http_stream_unittest.cc
+++ b/net/spdy/spdy_http_stream_unittest.cc
@@ -55,7 +55,7 @@ class SessionDependencies {
         proxy_service(CreateNullProxyService()),
         ssl_config_service(new SSLConfigServiceDefaults),
         http_auth_handler_factory(HttpAuthHandlerFactory::CreateDefault()),
-        spdy_session_pool(new SpdySessionPool(NULL)) {}
+        spdy_session_pool(new SpdySessionPool()) {}
 
   // Custom proxy service dependency.
   explicit SessionDependencies(ProxyService* proxy_service)
@@ -63,7 +63,7 @@ class SessionDependencies {
         proxy_service(proxy_service),
         ssl_config_service(new SSLConfigServiceDefaults),
         http_auth_handler_factory(HttpAuthHandlerFactory::CreateDefault()),
-        spdy_session_pool(new SpdySessionPool(NULL)) {}
+        spdy_session_pool(new SpdySessionPool()) {}
 
   scoped_refptr<MockHostResolverBase> host_resolver;
   scoped_refptr<ProxyService> proxy_service;
@@ -74,8 +74,7 @@ class SessionDependencies {
 };
 
 HttpNetworkSession* CreateSession(SessionDependencies* session_deps) {
-  return new HttpNetworkSession(NULL,
-                                session_deps->host_resolver,
+  return new HttpNetworkSession(session_deps->host_resolver,
                                 session_deps->proxy_service,
                                 &session_deps->socket_factory,
                                 session_deps->ssl_config_service,
diff --git a/net/spdy/spdy_network_transaction_unittest.cc b/net/spdy/spdy_network_transaction_unittest.cc
index c6e1cb0..e912b78 100644
--- a/net/spdy/spdy_network_transaction_unittest.cc
+++ b/net/spdy/spdy_network_transaction_unittest.cc
@@ -55,7 +55,7 @@ class SessionDependencies {
         proxy_service(ProxyService::CreateNull()),
         ssl_config_service(new SSLConfigServiceDefaults),
         http_auth_handler_factory(HttpAuthHandlerFactory::CreateDefault()),
-        spdy_session_pool(new SpdySessionPool(NULL)) {
+        spdy_session_pool(new SpdySessionPool()) {
     // Note: The CancelledTransaction test does cleanup by running all tasks
     // in the message loop (RunAllPending).  Unfortunately, that doesn't clean
     // up tasks on the host resolver thread; and TCPConnectJob is currently
@@ -71,7 +71,7 @@ class SessionDependencies {
         proxy_service(proxy_service),
         ssl_config_service(new SSLConfigServiceDefaults),
         http_auth_handler_factory(HttpAuthHandlerFactory::CreateDefault()),
-        spdy_session_pool(new SpdySessionPool(NULL)) {}
+        spdy_session_pool(new SpdySessionPool()) {}
 
   scoped_refptr<MockHostResolverBase> host_resolver;
   scoped_refptr<ProxyService> proxy_service;
@@ -82,8 +82,7 @@ class SessionDependencies {
 };
 
 HttpNetworkSession* CreateSession(SessionDependencies* session_deps) {
-  return new HttpNetworkSession(NULL,
-                                session_deps->host_resolver,
+  return new HttpNetworkSession(session_deps->host_resolver,
                                 session_deps->proxy_service,
                                 &session_deps->socket_factory,
                                 session_deps->ssl_config_service,
diff --git a/net/spdy/spdy_session_pool.cc b/net/spdy/spdy_session_pool.cc
index c7e2e79..3374a2e 100644
--- a/net/spdy/spdy_session_pool.cc
+++ b/net/spdy/spdy_session_pool.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 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.
 
@@ -14,17 +14,14 @@ static const size_t kMaxSessionsPerDomain = 1;
 
 int SpdySessionPool::g_max_sessions_per_domain = kMaxSessionsPerDomain;
 
-SpdySessionPool::SpdySessionPool(NetworkChangeNotifier* notifier)
-    : network_change_notifier_(notifier) {
-  if (network_change_notifier_)
-    network_change_notifier_->AddObserver(this);
+SpdySessionPool::SpdySessionPool() {
+  NetworkChangeNotifier::AddObserver(this);
 }
 
 SpdySessionPool::~SpdySessionPool() {
   CloseAllSessions();
 
-  if (network_change_notifier_)
-    network_change_notifier_->RemoveObserver(this);
+  NetworkChangeNotifier::RemoveObserver(this);
 }
 
 scoped_refptr<SpdySession> SpdySessionPool::Get(
@@ -85,6 +82,10 @@ void SpdySessionPool::Remove(const scoped_refptr<SpdySession>& session) {
     RemoveSessionList(session->host_port_pair());
 }
 
+void SpdySessionPool::OnIPAddressChanged() {
+  ClearSessions();
+}
+
 SpdySessionPool::SpdySessionList*
     SpdySessionPool::AddSessionList(const HostPortPair& host_port_pair) {
   DCHECK(sessions_.find(host_port_pair) == sessions_.end());
diff --git a/net/spdy/spdy_session_pool.h b/net/spdy/spdy_session_pool.h
index 08d01e0..3ea97f3 100644
--- a/net/spdy/spdy_session_pool.h
+++ b/net/spdy/spdy_session_pool.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 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.
 
@@ -21,7 +21,6 @@ namespace net {
 class BoundNetLog;
 class ClientSocketHandle;
 class HttpNetworkSession;
-class NetworkChangeNotifier;
 class SpdySession;
 
 // This is a very simple pool for open SpdySessions.
@@ -30,7 +29,7 @@ class SpdySessionPool
     : public base::RefCounted<SpdySessionPool>,
       public NetworkChangeNotifier::Observer {
  public:
-  explicit SpdySessionPool(NetworkChangeNotifier* notifier);
+  SpdySessionPool();
 
   // Either returns an existing SpdySession or creates a new SpdySession for
   // use.
@@ -72,7 +71,7 @@ class SpdySessionPool
   // We flush all idle sessions and release references to the active ones so
   // they won't get re-used.  The active ones will either complete successfully
   // or error out due to the IP address change.
-  virtual void OnIPAddressChanged() { ClearSessions(); }
+  virtual void OnIPAddressChanged();
 
  private:
   friend class base::RefCounted<SpdySessionPool>;
@@ -100,8 +99,6 @@ class SpdySessionPool
   // This is our weak session pool - one session per domain.
   SpdySessionsMap sessions_;
 
-  NetworkChangeNotifier* const network_change_notifier_;
-
   static int g_max_sessions_per_domain;
 
   DISALLOW_COPY_AND_ASSIGN(SpdySessionPool);
diff --git a/net/spdy/spdy_session_unittest.cc b/net/spdy/spdy_session_unittest.cc
index 67dcb94..20b73d9 100644
--- a/net/spdy/spdy_session_unittest.cc
+++ b/net/spdy/spdy_session_unittest.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 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.
 
@@ -41,7 +41,7 @@ class SessionDependencies {
       : host_resolver(new MockHostResolver),
         proxy_service(ProxyService::CreateNull()),
         ssl_config_service(new SSLConfigServiceDefaults),
-        spdy_session_pool(new SpdySessionPool(NULL)) {
+        spdy_session_pool(new SpdySessionPool()) {
   }
 
   scoped_refptr<MockHostResolverBase> host_resolver;
@@ -52,8 +52,7 @@ class SessionDependencies {
 };
 
 HttpNetworkSession* CreateSession(SessionDependencies* session_deps) {
-  return new HttpNetworkSession(NULL,
-                                session_deps->host_resolver,
+  return new HttpNetworkSession(session_deps->host_resolver,
                                 session_deps->proxy_service,
                                 &session_deps->socket_factory,
                                 session_deps->ssl_config_service,
diff --git a/net/tools/fetch/fetch_client.cc b/net/tools/fetch/fetch_client.cc
index d6ba673..9e2a21c 100644
--- a/net/tools/fetch/fetch_client.cc
+++ b/net/tools/fetch/fetch_client.cc
@@ -133,7 +133,7 @@ int main(int argc, char**argv) {
   MessageLoop loop(MessageLoop::TYPE_IO);
 
   scoped_refptr<net::HostResolver> host_resolver(
-      net::CreateSystemHostResolver(NULL));
+      net::CreateSystemHostResolver());
 
   scoped_refptr<net::ProxyService> proxy_service(
       net::ProxyService::CreateNull());
@@ -143,18 +143,14 @@ int main(int argc, char**argv) {
   scoped_ptr<net::HttpAuthHandlerFactory> http_auth_handler_factory(
       net::HttpAuthHandlerFactory::CreateDefault());
   if (use_cache) {
-    factory = new net::HttpCache(NULL, host_resolver, proxy_service,
-                                 ssl_config_service,
-                                 http_auth_handler_factory.get(),
-                                 NULL,
-                                 NULL,
-                                 net::HttpCache::DefaultBackend::InMemory(0));
+    factory = new net::HttpCache(host_resolver, proxy_service,
+        ssl_config_service, http_auth_handler_factory.get(), NULL, NULL,
+        net::HttpCache::DefaultBackend::InMemory(0));
   } else {
     factory = new net::HttpNetworkLayer(
-        net::ClientSocketFactory::GetDefaultFactory(), NULL, host_resolver,
+        net::ClientSocketFactory::GetDefaultFactory(), host_resolver,
         proxy_service, ssl_config_service, http_auth_handler_factory.get(),
-        NULL,
-        NULL);
+        NULL, NULL);
   }
 
   {
diff --git a/net/tools/hresolv/hresolv.cc b/net/tools/hresolv/hresolv.cc
index c3858ad..9c67070 100644
--- a/net/tools/hresolv/hresolv.cc
+++ b/net/tools/hresolv/hresolv.cc
@@ -447,7 +447,7 @@ int main(int argc, char** argv) {
       base::TimeDelta::FromSeconds(0));
 
   scoped_refptr<net::HostResolver> host_resolver(
-      new net::HostResolverImpl(NULL, cache, NULL, 100u));
+      new net::HostResolverImpl(NULL, cache, 100u));
   ResolverInvoker invoker(host_resolver.get());
   invoker.ResolveAll(hosts_and_times, options.async);
 
diff --git a/net/url_request/url_request_unittest.h b/net/url_request/url_request_unittest.h
index 02f8ab0..411e32a 100644
--- a/net/url_request/url_request_unittest.h
+++ b/net/url_request/url_request_unittest.h
@@ -131,13 +131,13 @@ class TestCookiePolicy : public net::CookiePolicy {
 class TestURLRequestContext : public URLRequestContext {
  public:
   TestURLRequestContext() {
-    host_resolver_ = net::CreateSystemHostResolver(NULL);
+    host_resolver_ = net::CreateSystemHostResolver();
     proxy_service_ = net::ProxyService::CreateNull();
     Init();
   }
 
   explicit TestURLRequestContext(const std::string& proxy) {
-    host_resolver_ = net::CreateSystemHostResolver(NULL);
+    host_resolver_ = net::CreateSystemHostResolver();
     net::ProxyConfig proxy_config;
     proxy_config.proxy_rules().ParseFromString(proxy);
     proxy_service_ = net::ProxyService::CreateFixed(proxy_config);
@@ -160,15 +160,14 @@ class TestURLRequestContext : public URLRequestContext {
     ftp_transaction_factory_ = new net::FtpNetworkLayer(host_resolver_);
     ssl_config_service_ = new net::SSLConfigServiceDefaults;
     http_auth_handler_factory_ = net::HttpAuthHandlerFactory::CreateDefault();
-    http_transaction_factory_ =
-        new net::HttpCache(
-          net::HttpNetworkLayer::CreateFactory(NULL, host_resolver_,
-                                               proxy_service_,
-                                               ssl_config_service_,
-                                               http_auth_handler_factory_,
-                                               network_delegate_,
-                                               NULL),
-          net::HttpCache::DefaultBackend::InMemory(0));
+    http_transaction_factory_ = new net::HttpCache(
+        net::HttpNetworkLayer::CreateFactory(host_resolver_,
+                                             proxy_service_,
+                                             ssl_config_service_,
+                                             http_auth_handler_factory_,
+                                             network_delegate_,
+                                             NULL),
+        net::HttpCache::DefaultBackend::InMemory(0));
     // In-memory cookie store.
     cookie_store_ = new net::CookieMonster(NULL, NULL);
     accept_language_ = "en-us,fr";