Make the ChromeNetworkDelegate use the ExtensionEventRouterForwarder

chrome/browser/io_thread.cc

 // Copyright (c) 2011 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/io_thread.h"
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/debug/leak_tracker.h"
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
 #include "base/stl_util-inl.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/threading/thread_restrictions.h"
 #include "chrome/browser/browser_process.h"
+#include "chrome/browser/extensions/extension_event_router_forwarder.h"
+#include "chrome/browser/net/chrome_network_delegate.h"
 #include "chrome/browser/net/chrome_net_log.h"
 #include "chrome/browser/net/chrome_url_request_context.h"
 #include "chrome/browser/net/connect_interceptor.h"
 #include "chrome/browser/net/passive_log_collector.h"
 #include "chrome/browser/net/predictor_api.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/net/raw_host_resolver_proc.h"
 #include "chrome/common/net/url_fetcher.h"
 #include "chrome/common/pref_names.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/gpu_process_host.h"
 #include "content/browser/in_process_webkit/indexed_db_key_utility_client.h"
 #include "net/base/cert_verifier.h"
 #include "net/base/cookie_monster.h"
 #include "net/base/dnsrr_resolver.h"
 #include "net/base/host_cache.h"
 #include "net/base/host_resolver.h"
 #include "net/base/host_resolver_impl.h"
 #include "net/base/mapped_host_resolver.h"
 #include "net/base/net_util.h"
-#include "net/base/network_delegate.h"
 #include "net/http/http_auth_filter.h"
 #include "net/http/http_auth_handler_factory.h"
 #include "net/http/http_network_layer.h"
 #include "net/http/http_network_session.h"
 #if defined(USE_NSS)
 #include "net/ocsp/nss_ocsp.h"
 #endif  // defined(USE_NSS)
 #include "net/proxy/proxy_script_fetcher_impl.h"
 
 namespace {
@@ skipping 121 matching lines @@
                        net::NetLog::Source(),
                        net::NetLog::PHASE_NONE,
                        NULL);
   }
 
  private:
   net::NetLog* net_log_;
   DISALLOW_COPY_AND_ASSIGN(LoggingNetworkChangeObserver);
 };
 
-class SystemNetworkDelegate : public net::NetworkDelegate {
- public:
-  SystemNetworkDelegate() {}
-  ~SystemNetworkDelegate() {}
-
-  // NetworkDelegate methods:
-  // TODO(willchan): Implement these functions!
-  virtual void OnBeforeURLRequest(net::URLRequest* request) {}
-  virtual void OnSendHttpRequest(net::HttpRequestHeaders* headers) {}
-  virtual void OnResponseStarted(net::URLRequest* request) {}
-  virtual void OnReadCompleted(net::URLRequest* request, int bytes_read) {}
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(SystemNetworkDelegate);
-};
-
 scoped_refptr<net::URLRequestContext>
 ConstructProxyScriptFetcherContext(IOThread::Globals* globals,
                                    net::NetLog* net_log) {
   scoped_refptr<net::URLRequestContext> context(new net::URLRequestContext);
   context->set_net_log(net_log);
   context->set_host_resolver(globals->host_resolver.get());
   context->set_cert_verifier(globals->cert_verifier.get());
   context->set_dnsrr_resolver(globals->dnsrr_resolver.get());
   context->set_http_auth_handler_factory(
       globals->http_auth_handler_factory.get());
   context->set_proxy_service(globals->proxy_script_fetcher_proxy_service.get());
   context->set_http_transaction_factory(
       globals->proxy_script_fetcher_http_transaction_factory.get());
   // In-memory cookie store.
   context->set_cookie_store(new net::CookieMonster(NULL, NULL));
-  // TODO(mpcomplete): give it a SystemNetworkDelegate.
+  context->set_network_delegate(globals->system_network_delegate.get());
   return context;
 }
 
 }  // namespace
 
 // The IOThread object must outlive any tasks posted to the IO thread before the
 // Quit task.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(IOThread);
 
 IOThread::Globals::Globals() {}
 
 IOThread::Globals::~Globals() {}
 
 // |local_state| is passed in explicitly in order to (1) reduce implicit
 // dependencies and (2) make IOThread more flexible for testing.
-IOThread::IOThread(PrefService* local_state, ChromeNetLog* net_log)
+IOThread::IOThread(
+    PrefService* local_state,
+    ChromeNetLog* net_log,
+    ExtensionEventRouterForwarder* extension_event_router_forwarder)
     : BrowserProcessSubThread(BrowserThread::IO),
       net_log_(net_log),
+      extension_event_router_forwarder_(extension_event_router_forwarder),
       globals_(NULL),
       speculative_interceptor_(NULL),
       predictor_(NULL) {
   // We call RegisterPrefs() here (instead of inside browser_prefs.cc) to make
   // sure that everything is initialized in the right order.
   RegisterPrefs(local_state);
   auth_schemes_ = local_state->GetString(prefs::kAuthSchemes);
   negotiate_disable_cname_lookup_ = local_state->GetBoolean(
       prefs::kDisableAuthNegotiateCnameLookup);
   negotiate_enable_port_ = local_state->GetBoolean(
@@ skipping 95 matching lines @@
 
   DCHECK(!globals_);
   globals_ = new Globals;
 
   // Add an observer that will emit network change events to the ChromeNetLog.
   // Assuming NetworkChangeNotifier dispatches in FIFO order, we should be
   // logging the network change before other IO thread consumers respond to it.
   network_change_observer_.reset(
       new LoggingNetworkChangeObserver(net_log_));
 
-  globals_->system_network_delegate.reset(new SystemNetworkDelegate);
+  globals_->extension_event_router_forwarder =
+      extension_event_router_forwarder_;
+  globals_->system_network_delegate.reset(new ChromeNetworkDelegate(
+        extension_event_router_forwarder_, Profile::kInvalidProfileId));
   globals_->host_resolver.reset(
       CreateGlobalHostResolver(net_log_));
   globals_->cert_verifier.reset(new net::CertVerifier);
   globals_->dnsrr_resolver.reset(new net::DnsRRResolver);
   // TODO(willchan): Use the real SSLConfigService.
   globals_->ssl_config_service =
       net::SSLConfigService::CreateSystemSSLConfigService();
   globals_->http_auth_handler_factory.reset(CreateDefaultAuthHandlerFactory(
       globals_->host_resolver.get()));
   // For the ProxyScriptFetcher, we use a direct ProxyService.
   globals_->proxy_script_fetcher_proxy_service =
       net::ProxyService::CreateDirectWithNetLog(net_log_);
   net::HttpNetworkSession::Params session_params;
   session_params.host_resolver = globals_->host_resolver.get();
   session_params.cert_verifier = globals_->cert_verifier.get();
   session_params.proxy_service =
       globals_->proxy_script_fetcher_proxy_service.get();
   session_params.http_auth_handler_factory =
       globals_->http_auth_handler_factory.get();
-  // TODO(willchan): Enable for proxy script fetcher context.
   session_params.network_delegate = globals_->system_network_delegate.get();
   session_params.net_log = net_log_;
   session_params.ssl_config_service = globals_->ssl_config_service;
   scoped_refptr<net::HttpNetworkSession> network_session(
       new net::HttpNetworkSession(session_params));
   globals_->proxy_script_fetcher_http_transaction_factory.reset(
       new net::HttpNetworkLayer(network_session));
 
   scoped_refptr<net::URLRequestContext> proxy_script_fetcher_context =
       ConstructProxyScriptFetcherContext(globals_, net_log_);
@@ skipping 164 matching lines @@
 void IOThread::ClearHostCache() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (globals_->host_resolver->GetAsHostResolverImpl()) {
     net::HostCache* host_cache =
         globals_->host_resolver.get()->GetAsHostResolverImpl()->cache();
     if (host_cache)
       host_cache->clear();
   }
 }