Rename ProtocolInterceptJobFactory and make it not use ProtocolHandlers.

chrome/browser/profiles/profile_io_data.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/profiles/profile_io_data.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 53 matching lines @@
 #include "net/http/http_util.h"
 #include "net/http/transport_security_persister.h"
 #include "net/proxy/proxy_config_service_fixed.h"
 #include "net/proxy/proxy_script_fetcher_impl.h"
 #include "net/proxy/proxy_service.h"
 #include "net/ssl/client_cert_store.h"
 #include "net/ssl/server_bound_cert_service.h"
 #include "net/url_request/data_protocol_handler.h"
 #include "net/url_request/file_protocol_handler.h"
 #include "net/url_request/ftp_protocol_handler.h"
-#include "net/url_request/protocol_intercept_job_factory.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_file_job.h"
+#include "net/url_request/url_request_intercepting_job_factory.h"
+#include "net/url_request/url_request_interceptor.h"
 #include "net/url_request/url_request_job_factory_impl.h"
 
 #if defined(ENABLE_CONFIGURATION_POLICY)
 #include "chrome/browser/policy/cloud/policy_header_service_factory.h"
 #include "chrome/browser/policy/policy_helpers.h"
 #include "components/policy/core/browser/url_blacklist_manager.h"
 #include "components/policy/core/common/cloud/policy_header_io_helper.h"
 #include "components/policy/core/common/cloud/policy_header_service.h"
 #include "components/policy/core/common/cloud/user_cloud_policy_manager.h"
 #endif
@@ skipping 84 matching lines @@
   if (!PathService::Get(chrome::DIR_INSPECTOR, &inspector_dir))
     return false;
 
   if (inspector_dir.empty())
     return false;
 
   *path = inspector_dir.AppendASCII(relative_path);
   return true;
 }
 
-class DebugDevToolsInterceptor
-    : public net::URLRequestJobFactory::ProtocolHandler {
+class DebugDevToolsInterceptor : public net::URLRequestInterceptor {
  public:
   DebugDevToolsInterceptor() {}
   virtual ~DebugDevToolsInterceptor() {}
 
-  virtual net::URLRequestJob* MaybeCreateJob(
+  // net::URLRequestInterceptor implementation.
+  virtual net::URLRequestJob* MaybeInterceptRequest(
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate) const OVERRIDE {
     base::FilePath path;
     if (IsSupportedDevToolsURL(request->url(), &path))
       return new net::URLRequestFileJob(
           request, network_delegate, path,
           content::BrowserThread::GetBlockingPool()->
               GetTaskRunnerWithShutdownBehavior(
                   base::SequencedWorkerPool::SKIP_ON_SHUTDOWN));
 
@@ skipping 485 matching lines @@
   DCHECK(initialized_);
   return extensions_request_context_.get();
 }
 
 ChromeURLRequestContext* ProfileIOData::GetIsolatedAppRequestContext(
     ChromeURLRequestContext* main_context,
     const StoragePartitionDescriptor& partition_descriptor,
     scoped_ptr<ProtocolHandlerRegistry::JobInterceptorFactory>
         protocol_handler_interceptor,
     content::ProtocolHandlerMap* protocol_handlers,
-    content::ProtocolHandlerScopedVector protocol_interceptors) const {
+    content::URLRequestInterceptorScopedVector request_interceptors) const {
   DCHECK(initialized_);
   ChromeURLRequestContext* context = NULL;
   if (ContainsKey(app_request_context_map_, partition_descriptor)) {
     context = app_request_context_map_[partition_descriptor];
   } else {
     context =
         AcquireIsolatedAppRequestContext(main_context,
                                          partition_descriptor,
                                          protocol_handler_interceptor.Pass(),
                                          protocol_handlers,
-                                         protocol_interceptors.Pass());
+                                         request_interceptors.Pass());
     app_request_context_map_[partition_descriptor] = context;
   }
   DCHECK(context);
   return context;
 }
 
 ChromeURLRequestContext* ProfileIOData::GetIsolatedMediaRequestContext(
     ChromeURLRequestContext* app_context,
     const StoragePartitionDescriptor& partition_descriptor) const {
   DCHECK(initialized_);
@@ skipping 187 matching lines @@
   // The SSL session cache is partitioned by setting a string. This returns a
   // unique string to partition the SSL session cache. Each time we create a
   // new profile, we'll get a fresh SSL session cache which is separate from
   // the other profiles.
   static unsigned ssl_session_cache_instance = 0;
   return base::StringPrintf("profile/%u", ssl_session_cache_instance++);
 }
 
 void ProfileIOData::Init(
     content::ProtocolHandlerMap* protocol_handlers,
-    content::ProtocolHandlerScopedVector protocol_interceptors) const {
+    content::URLRequestInterceptorScopedVector request_interceptors) const {
   // The basic logic is implemented here. The specific initialization
   // is done in InitializeInternal(), implemented by subtypes. Static helper
   // functions have been provided to assist in common operations.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!initialized_);
 
   startup_metric_utils::ScopedSlowStartupUMA
       scoped_timer("Startup.SlowStartupProfileIODataInit");
 
   // TODO(jhawkins): Remove once crbug.com/102004 is fixed.
@@ skipping 78 matching lines @@
   } else {
     main_request_context_->set_cert_verifier(
         new net::MultiThreadedCertVerifier(verify_proc.get()));
   }
 #else
   main_request_context_->set_cert_verifier(
       io_thread_globals->cert_verifier.get());
 #endif
 
   InitializeInternal(
-      profile_params_.get(), protocol_handlers, protocol_interceptors.Pass());
+      profile_params_.get(), protocol_handlers, request_interceptors.Pass());
 
   profile_params_.reset();
   initialized_ = true;
 }
 
 void ProfileIOData::ApplyProfileParamsToContext(
     ChromeURLRequestContext* context) const {
   context->set_http_user_agent_settings(
       chrome_http_user_agent_settings_.get());
   context->set_ssl_config_service(profile_params_->ssl_config_service.get());
 }
 
 scoped_ptr<net::URLRequestJobFactory> ProfileIOData::SetUpJobFactoryDefaults(
     scoped_ptr<net::URLRequestJobFactoryImpl> job_factory,
-    content::ProtocolHandlerScopedVector protocol_interceptors,
+    content::URLRequestInterceptorScopedVector request_interceptors,
     scoped_ptr<ProtocolHandlerRegistry::JobInterceptorFactory>
         protocol_handler_interceptor,
     net::NetworkDelegate* network_delegate,
     net::FtpTransactionFactory* ftp_transaction_factory) const {
   // NOTE(willchan): Keep these protocol handlers in sync with
   // ProfileIOData::IsHandledProtocol().
   bool set_protocol = job_factory->SetProtocolHandler(
       content::kFileScheme,
       new net::FileProtocolHandler(
           content::BrowserThread::GetBlockingPool()->
@@ skipping 28 matching lines @@
   job_factory->SetProtocolHandler(
       content::kAboutScheme, new chrome_browser_net::AboutProtocolHandler());
 #if !defined(DISABLE_FTP_SUPPORT)
   DCHECK(ftp_transaction_factory);
   job_factory->SetProtocolHandler(
       content::kFtpScheme,
       new net::FtpProtocolHandler(ftp_transaction_factory));
 #endif  // !defined(DISABLE_FTP_SUPPORT)
 
 #if defined(DEBUG_DEVTOOLS)
-  protocol_interceptors.push_back(new DebugDevToolsInterceptor);
+  request_interceptors.push_back(new DebugDevToolsInterceptor);
 #endif
 
   // Set up interceptors in the reverse order.
   scoped_ptr<net::URLRequestJobFactory> top_job_factory =
       job_factory.PassAs<net::URLRequestJobFactory>();
-  for (content::ProtocolHandlerScopedVector::reverse_iterator i =
-           protocol_interceptors.rbegin();
-       i != protocol_interceptors.rend();
+  for (content::URLRequestInterceptorScopedVector::reverse_iterator i =
+           request_interceptors.rbegin();
+       i != request_interceptors.rend();
        ++i) {
-    top_job_factory.reset(new net::ProtocolInterceptJobFactory(
+    top_job_factory.reset(new net::URLRequestInterceptingJobFactory(
         top_job_factory.Pass(), make_scoped_ptr(*i)));
   }
-  protocol_interceptors.weak_clear();
+  request_interceptors.weak_clear();
 
   if (protocol_handler_interceptor) {
     protocol_handler_interceptor->Chain(top_job_factory.Pass());
     return protocol_handler_interceptor.PassAs<net::URLRequestJobFactory>();
   } else {
     return top_job_factory.Pass();
   }
 }
 
 void ProfileIOData::ShutdownOnUIThread() {
@@ skipping 70 matching lines @@
 void ProfileIOData::SetCookieSettingsForTesting(
     CookieSettings* cookie_settings) {
   DCHECK(!cookie_settings_.get());
   cookie_settings_ = cookie_settings;
 }
 
 void ProfileIOData::set_signin_names_for_testing(
     SigninNamesOnIOThread* signin_names) {
   signin_names_.reset(signin_names);
 }