Massively simplify the NetworkChangeNotifier infrastructure:...

chrome/browser/net/chrome_url_request_context.cc

 // 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.
 
 #include "chrome/browser/net/chrome_url_request_context.h"
 
 #include "base/command_line.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/string_util.h"
@@ skipping 65 matching lines @@
         g_browser_process->io_thread()->message_loop(),
         g_browser_process->file_thread()->message_loop());
   }
 
   // Otherwise use the fixed settings from the command line.
   return new net::ProxyConfigServiceFixed(*proxy_config.get());
 }
 
 // Create a proxy service according to the options on command line.
 net::ProxyService* CreateProxyService(
-    net::NetworkChangeNotifier* network_change_notifier,
     net::NetLog* net_log,
     URLRequestContext* context,
     net::ProxyConfigService* proxy_config_service,
     const CommandLine& command_line,
     MessageLoop* io_loop) {
   CheckCurrentlyOnIOThread();
 
   bool use_v8 = !command_line.HasSwitch(switches::kWinHttpProxyResolver);
   if (use_v8 && command_line.HasSwitch(switches::kSingleProcess)) {
     // See the note about V8 multithreading in net/proxy/proxy_resolver_v8.h
     // to understand why we have this limitation.
     LOG(ERROR) << "Cannot use V8 Proxy resolver in single process mode.";
     use_v8 = false;  // Fallback to non-v8 implementation.
   }
 
   return net::ProxyService::Create(
       proxy_config_service,
       use_v8,
       context,
-      network_change_notifier,
       net_log,
       io_loop);
 }
 
 // ----------------------------------------------------------------------------
 // CookieMonster::Delegate implementation
 // ----------------------------------------------------------------------------
 class ChromeCookieMonsterDelegate : public net::CookieMonster::Delegate {
  public:
   explicit ChromeCookieMonsterDelegate(Profile* profile) {
@@ skipping 115 matching lines @@
   IOThread::Globals* io_thread_globals = io_thread()->globals();
 
   // Global host resolver for the context.
   context->set_host_resolver(io_thread_globals->host_resolver);
   context->set_http_auth_handler_factory(
       io_thread_globals->http_auth_handler_factory.get());
 
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
 
   context->set_proxy_service(
-      CreateProxyService(io_thread_globals->network_change_notifier.get(),
-                         io_thread_globals->net_log.get(),
+      CreateProxyService(io_thread_globals->net_log.get(),
                          context,
                          proxy_config_service_.release(),
                          command_line,
                          MessageLoop::current() /*io_loop*/));
 
   net::HttpCache::DefaultBackend* backend = new net::HttpCache::DefaultBackend(
       net::DISK_CACHE, disk_cache_path_, cache_size_,
       ChromeThread::GetMessageLoopProxyForThread(ChromeThread::CACHE));
   net::HttpCache* cache =
-      new net::HttpCache(io_thread_globals->network_change_notifier.get(),
-                         context->host_resolver(),
+      new net::HttpCache(context->host_resolver(),
                          context->proxy_service(),
                          context->ssl_config_service(),
                          context->http_auth_handler_factory(),
                          &io_thread_globals->network_delegate,
                          io_thread_globals->net_log.get(),
                          backend);
 
   if (command_line.HasSwitch(switches::kDisableByteRangeSupport))
     cache->set_enable_range_support(false);
 
@@ skipping 107 matching lines @@
   // as the original profile.
   context->set_host_resolver(original_context->host_resolver());
   context->set_proxy_service(original_context->proxy_service());
   context->set_http_auth_handler_factory(
       original_context->http_auth_handler_factory());
 
   net::HttpCache::BackendFactory* backend =
       net::HttpCache::DefaultBackend::InMemory(0);
 
   net::HttpCache* cache =
-      new net::HttpCache(io_thread_globals->network_change_notifier.get(),
-                         context->host_resolver(),
+      new net::HttpCache(context->host_resolver(),
                          context->proxy_service(),
                          context->ssl_config_service(),
                          context->http_auth_handler_factory(),
                          &io_thread_globals->network_delegate,
                          io_thread_globals->net_log.get(),
                          backend);
   context->set_cookie_store(new net::CookieMonster(NULL,
       cookie_monster_delegate_));
   context->set_cookie_policy(
       new ChromeCookiePolicy(host_content_settings_map_));
@@ skipping 76 matching lines @@
     // HttpCache(HttpTransactionFactory*, BackendFactory*) constructor.
     net::HttpNetworkLayer* main_network_layer =
         static_cast<net::HttpNetworkLayer*>(main_cache->network_layer());
     cache = new net::HttpCache(main_network_layer->GetSession(), backend);
     // TODO(eroman): Since this is poaching the session from the main
     // context, it should hold a reference to that context preventing the
     // session from getting deleted.
   } else {
     // If original HttpCache doesn't exist, simply construct one with a whole
     // new set of network stack.
-    cache = new net::HttpCache(
-        io_thread_globals->network_change_notifier.get(),
-        main_context->host_resolver(),
-        main_context->proxy_service(),
-        main_context->ssl_config_service(),
-        main_context->http_auth_handler_factory(),
-        &io_thread_globals->network_delegate,
-        io_thread_globals->net_log.get(),
-        backend);
+    cache = new net::HttpCache(main_context->host_resolver(),
+                               main_context->proxy_service(),
+                               main_context->ssl_config_service(),
+                               main_context->http_auth_handler_factory(),
+                               &io_thread_globals->network_delegate,
+                               io_thread_globals->net_log.get(),
+                               backend);
   }
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableByteRangeSupport))
     cache->set_enable_range_support(false);
 
   context->set_http_transaction_factory(cache);
 
   // Use the same appcache service as the profile's main context.
   context->set_appcache_service(main_context->appcache_service());
@@ skipping 575 matching lines @@
 
   if (pref_service->HasPrefPath(prefs::kProxyBypassList)) {
     std::wstring proxy_bypass =
         pref_service->GetString(prefs::kProxyBypassList);
     proxy_config->proxy_rules().bypass_rules.ParseFromString(
         WideToASCII(proxy_bypass));
   }
 
   return proxy_config;
 }