Create a new URLRequestJobFactory for isolated request contexts.

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"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "chrome/browser/browser_process.h"
+#include "chrome/browser/net/about_protocol_handler.h"
 #include "chrome/browser/content_settings/cookie_settings.h"
 #include "chrome/browser/content_settings/host_content_settings_map.h"
 #include "chrome/browser/custom_handlers/protocol_handler_registry.h"
 #include "chrome/browser/custom_handlers/protocol_handler_registry_factory.h"
 #include "chrome/browser/download/download_service.h"
 #include "chrome/browser/download/download_service_factory.h"
 #include "chrome/browser/extensions/extension_info_map.h"
 #include "chrome/browser/extensions/extension_protocols.h"
 #include "chrome/browser/extensions/extension_resource_protocols.h"
 #include "chrome/browser/extensions/extension_system.h"
@@ skipping 25 matching lines @@
 #include "content/public/browser/resource_context.h"
 #include "net/base/server_bound_cert_service.h"
 #include "net/cookies/canonical_cookie.h"
 #include "net/cookies/cookie_monster.h"
 #include "net/http/http_transaction_factory.h"
 #include "net/http/http_util.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/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/url_request.h"
 
 #if !defined(OS_ANDROID)
 #include "chrome/browser/managed_mode.h"
 #endif
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/gdata/drive_protocol_handler.h"
 #include "chrome/browser/chromeos/gview_request_interceptor.h"
 #include "chrome/browser/chromeos/proxy_config_service_impl.h"
@@ skipping 108 matching lines @@
 
 #if defined(ENABLE_NOTIFICATIONS)
   params->notification_service =
       DesktopNotificationServiceFactory::GetForProfile(profile);
 #endif
 
   ProtocolHandlerRegistry* protocol_handler_registry =
       ProtocolHandlerRegistryFactory::GetForProfile(profile);
   DCHECK(protocol_handler_registry);
 
-  // the profile instance is only available here in the InitializeOnUIThread
+  // The profile instance is only available here in the InitializeOnUIThread
   // method, so we create the url interceptor here, then save it for
-  // later delivery to the job factory in LazyInitialize
-  params->protocol_handler_url_interceptor.reset(
+  // later delivery to the job factory in LazyInitialize.
+  params->protocol_handler_interceptor.reset(
       protocol_handler_registry->CreateURLInterceptor());
 
   ChromeProxyConfigService* proxy_config_service =
       ProxyServiceFactory::CreateProxyConfigService(true);
   params->proxy_config_service.reset(proxy_config_service);
   profile->GetProxyConfigTracker()->SetChromeProxyConfigService(
       proxy_config_service);
   params->profile = profile;
   profile_params_.reset(params.release());
 
@@ skipping 24 matching lines @@
   BrowserContext::EnsureResourceContextInitialized(profile);
 }
 
 ProfileIOData::MediaRequestContext::MediaRequestContext(
     chrome_browser_net::LoadTimeStats* load_time_stats)
     : ChromeURLRequestContext(ChromeURLRequestContext::CONTEXT_TYPE_MEDIA,
                               load_time_stats) {
 }
 
 void ProfileIOData::MediaRequestContext::SetHttpTransactionFactory(
-    net::HttpTransactionFactory* http_factory) {
-  http_factory_.reset(http_factory);
-  set_http_transaction_factory(http_factory);
+    scoped_ptr<net::HttpTransactionFactory> http_factory) {
+  http_factory_ = http_factory.Pass();
+  set_http_transaction_factory(http_factory_.get());
 }
 
 ProfileIOData::MediaRequestContext::~MediaRequestContext() {}
 
 ProfileIOData::AppRequestContext::AppRequestContext(
     chrome_browser_net::LoadTimeStats* load_time_stats)
     : ChromeURLRequestContext(ChromeURLRequestContext::CONTEXT_TYPE_APP,
                               load_time_stats) {
 }
 
 void ProfileIOData::AppRequestContext::SetCookieStore(
     net::CookieStore* cookie_store) {
   cookie_store_ = cookie_store;
   set_cookie_store(cookie_store);
 }
 
 void ProfileIOData::AppRequestContext::SetHttpTransactionFactory(
-    net::HttpTransactionFactory* http_factory) {
-  http_factory_.reset(http_factory);
-  set_http_transaction_factory(http_factory);
+    scoped_ptr<net::HttpTransactionFactory> http_factory) {
+  http_factory_ = http_factory.Pass();
+  set_http_transaction_factory(http_factory_.get());
+}
+
+void ProfileIOData::AppRequestContext::SetJobFactory(
+    scoped_ptr<net::URLRequestJobFactory> job_factory) {
+  job_factory_ = job_factory.Pass();
+  set_job_factory(job_factory_.get());
 }
 
 ProfileIOData::AppRequestContext::~AppRequestContext() {}
 
 ProfileIOData::ProfileParams::ProfileParams()
     : io_thread(NULL),
 #if defined(ENABLE_NOTIFICATIONS)
       notification_service(NULL),
 #endif
       profile(NULL) {
@@ skipping 95 matching lines @@
 
 ChromeURLRequestContext*
 ProfileIOData::GetExtensionsRequestContext() const {
   LazyInitialize();
   return extensions_request_context_.get();
 }
 
 ChromeURLRequestContext*
 ProfileIOData::GetIsolatedAppRequestContext(
     ChromeURLRequestContext* main_context,
-    const std::string& app_id) const {
+    const std::string& app_id,
+    scoped_ptr<net::URLRequestJobFactory::Interceptor>
+        protocol_handler_interceptor) const {
   LazyInitialize();
   ChromeURLRequestContext* context = NULL;
   if (ContainsKey(app_request_context_map_, app_id)) {
     context = app_request_context_map_[app_id];
   } else {
-    context = AcquireIsolatedAppRequestContext(main_context, app_id);
+    context = AcquireIsolatedAppRequestContext(
+        main_context, app_id, protocol_handler_interceptor.Pass());
     app_request_context_map_[app_id] = context;
   }
   DCHECK(context);
   return context;
 }
 
 ChromeURLRequestContext*
 ProfileIOData::GetIsolatedMediaRequestContext(
-    ChromeURLRequestContext* main_context,
+    ChromeURLRequestContext* app_context,
     const std::string& app_id) const {
   LazyInitialize();
   ChromeURLRequestContext* context = NULL;
   if (ContainsKey(isolated_media_request_context_map_, app_id)) {
     context = isolated_media_request_context_map_[app_id];
   } else {
-    // Get the app context as the starting point for the media context,
-    // so that it uses the app's cookie store.
-    ChromeURLRequestContext* app_context = GetIsolatedAppRequestContext(
-        main_context, app_id);
     context = AcquireIsolatedMediaRequestContext(app_context, app_id);
     isolated_media_request_context_map_[app_id] = context;
   }
   DCHECK(context);
   return context;
 }
 
 ExtensionInfoMap* ProfileIOData::GetExtensionInfoMap() const {
   DCHECK(extension_info_map_) << "ExtensionSystem not initialized";
   return extension_info_map_;
@@ skipping 169 matching lines @@
 void ProfileIOData::ApplyProfileParamsToContext(
     ChromeURLRequestContext* context) const {
   context->set_is_incognito(is_incognito());
   context->set_accept_language(profile_params_->accept_language);
   context->set_accept_charset(profile_params_->accept_charset);
   context->set_referrer_charset(profile_params_->referrer_charset);
   context->set_ssl_config_service(profile_params_->ssl_config_service);
 }
 
 void ProfileIOData::SetUpJobFactoryDefaults(
-    net::URLRequestJobFactory* job_factory) const {
+    net::URLRequestJobFactory* job_factory,
+    scoped_ptr<net::URLRequestJobFactory::Interceptor>
+        protocol_handler_interceptor,
+    net::NetworkDelegate* network_delegate,
+    net::FtpTransactionFactory* ftp_transaction_factory,
+    net::FtpAuthCache* ftp_auth_cache) const {
   // NOTE(willchan): Keep these protocol handlers in sync with
   // ProfileIOData::IsHandledProtocol().
+  bool set_protocol = job_factory->SetProtocolHandler(
+      chrome::kFileScheme, new net::FileProtocolHandler());
+  DCHECK(set_protocol);
 
-  if (profile_params_->protocol_handler_url_interceptor.get()) {
-    job_factory->AddInterceptor(
-        profile_params_->protocol_handler_url_interceptor.release());
+  set_protocol = job_factory->SetProtocolHandler(
+      chrome::kChromeDevToolsScheme,
+      CreateDevToolsProtocolHandler(chrome_url_data_manager_backend(),
+                                    network_delegate));
+  DCHECK(set_protocol);
+
+  if (protocol_handler_interceptor.get()) {
+    job_factory->AddInterceptor(protocol_handler_interceptor.release());
   }
 
-  bool set_protocol = job_factory->SetProtocolHandler(
+  set_protocol = job_factory->SetProtocolHandler(
       chrome::kExtensionScheme,
-      CreateExtensionProtocolHandler(is_incognito(),
-                                     profile_params_->extension_info_map));
+      CreateExtensionProtocolHandler(is_incognito(), GetExtensionInfoMap()));
   DCHECK(set_protocol);
   set_protocol = job_factory->SetProtocolHandler(
       chrome::kExtensionResourceScheme,
       CreateExtensionResourceProtocolHandler());
   DCHECK(set_protocol);
   set_protocol = job_factory->SetProtocolHandler(
       chrome::kChromeUIScheme,
       ChromeURLDataManagerBackend::CreateProtocolHandler(
           chrome_url_data_manager_backend_.get()));
   DCHECK(set_protocol);
   set_protocol = job_factory->SetProtocolHandler(
       chrome::kDataScheme, new net::DataProtocolHandler());
   DCHECK(set_protocol);
 #if defined(OS_CHROMEOS)
   if (!is_incognito()) {
     set_protocol = job_factory->SetProtocolHandler(
         chrome::kDriveScheme, new gdata::DriveProtocolHandler());
     DCHECK(set_protocol);
   }
 #if !defined(GOOGLE_CHROME_BUILD)
   // Install the GView request interceptor that will redirect requests
   // of compatible documents (PDF, etc) to the GView document viewer.
   const CommandLine& parsed_command_line = *CommandLine::ForCurrentProcess();
   if (parsed_command_line.HasSwitch(switches::kEnableGView))
     job_factory->AddInterceptor(new chromeos::GViewRequestInterceptor);
 #endif  // !defined(GOOGLE_CHROME_BUILD)
 #endif  // defined(OS_CHROMEOS)
+
+  job_factory->SetProtocolHandler(chrome::kAboutScheme,
+                                  new net::AboutProtocolHandler());
+#if !defined(DISABLE_FTP_SUPPORT)
+  DCHECK(ftp_transaction_factory);
+  job_factory->SetProtocolHandler(
+      chrome::kFtpScheme,
+      new net::FtpProtocolHandler(ftp_transaction_factory,
+                                  ftp_auth_cache));
+#endif  // !defined(DISABLE_FTP_SUPPORT)
 }
 
 void ProfileIOData::ShutdownOnUIThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   enable_referrers_.Destroy();
   enable_do_not_track_.Destroy();
 #if !defined(OS_CHROMEOS)
   enable_metrics_.Destroy();
 #endif
   safe_browsing_enabled_.Destroy();
@@ skipping 42 matching lines @@
   params->http_pipelining_enabled = globals->http_pipelining_enabled;
   params->testing_fixed_http_port = globals->testing_fixed_http_port;
   params->testing_fixed_https_port = globals->testing_fixed_https_port;
 
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   if (command_line.HasSwitch(switches::kTrustedSpdyProxy)) {
     params->trusted_spdy_proxy = command_line.GetSwitchValueASCII(
         switches::kTrustedSpdyProxy);
   }
 }