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 {

[Matt Perry, 2011/02/25 23:28:40]

I think Will had other plans for this beyond making it a ChromeNetworkDelegate
without a profile. For example, with your change, ChromeNetworkDelegate can no
longer assume that any URLRequests it sees have a ChromeURLRequestContext.

But I'll let Will comment further.

[willchan no longer on Chromium, 2011/02/26 02:11:35]

I actually forgot to mention this to jochen when he spoke to me about it
earlier, but yes, mpcomplete is right. But it's fine to delete this. I'll
resurrect it eventually. When that happens, I may end up creating some sort of
ExtensionNetworkDelegate object or something that will be shared by both
ChromeNetworkDelegate and SystemNetworkDelegate, where all the existing logic
(since all of it is strictly extension stuff right now) will move.

Note that eventually we will shim in other things, like NetLog, and DevTools, a
replacement for URLRequest::Interceptor/URLRequest::ProtocolFactory (both are
globals) / etc. Interceptors/ProtocolFactories often need to know that they're
using a ChromeURLRequestContext, and some won't need to be included in the
SystemNetworkDelegate.

- 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_, NULL));
   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();
   }
 }