Create a new URLRequestJobFactory for isolated request contexts.

chrome/browser/profiles/profile_impl_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_impl_io_data.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/threading/worker_pool.h"
 #include "chrome/browser/api/prefs/pref_member.h"
+#include "chrome/browser/custom_handlers/protocol_handler_registry.h"
+#include "chrome/browser/custom_handlers/protocol_handler_registry_factory.h"
 #include "chrome/browser/io_thread.h"
-#include "chrome/browser/net/about_protocol_handler.h"
 #include "chrome/browser/net/chrome_net_log.h"
 #include "chrome/browser/net/clear_on_exit_policy.h"
 #include "chrome/browser/net/connect_interceptor.h"
 #include "chrome/browser/net/http_server_properties_manager.h"
 #include "chrome/browser/net/predictor.h"
 #include "chrome/browser/net/sqlite_persistent_cookie_store.h"
 #include "chrome/browser/net/sqlite_server_bound_cert_store.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/webui/chrome_url_data_manager_backend.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/resource_context.h"
 #include "content/public/browser/storage_partition.h"
 #include "net/base/server_bound_cert_service.h"
 #include "net/ftp/ftp_network_layer.h"
 #include "net/http/http_cache.h"
-#include "net/url_request/file_protocol_handler.h"
-#include "net/url_request/ftp_protocol_handler.h"
 #include "net/url_request/url_request_job_factory_impl.h"
 #include "webkit/quota/special_storage_policy.h"
 
 using content::BrowserThread;
 
 ProfileImplIOData::Handle::Handle(Profile* profile)
     : io_data_(new ProfileImplIOData),
       profile_(profile),
       initialized_(false) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 163 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   CHECK(!app_id.empty());
   LazyInitialize();
 
   // Keep a map of request context getters, one per requested app ID.
   ChromeURLRequestContextGetterMap::iterator iter =
       app_request_context_getter_map_.find(app_id);
   if (iter != app_request_context_getter_map_.end())
     return iter->second;
 
+  scoped_ptr<net::URLRequestJobFactory::Interceptor>
+      protocol_handler_interceptor(
+          ProtocolHandlerRegistryFactory::GetForProfile(profile_)->
+              CreateURLInterceptor());
   ChromeURLRequestContextGetter* context =
       ChromeURLRequestContextGetter::CreateOriginalForIsolatedApp(
-          profile_, io_data_, app_id);
+          profile_, io_data_, app_id, protocol_handler_interceptor.Pass());
   app_request_context_getter_map_[app_id] = context;
 
   return context;
 }
 
 scoped_refptr<ChromeURLRequestContextGetter>
 ProfileImplIOData::Handle::GetIsolatedMediaRequestContextGetter(
     const std::string& app_id) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // We must have an app ID, or this will act like the default media context.
   CHECK(!app_id.empty());
   LazyInitialize();
 
   // Keep a map of request context getters, one per requested app ID.
   ChromeURLRequestContextGetterMap::iterator iter =
       isolated_media_request_context_getter_map_.find(app_id);
   if (iter != isolated_media_request_context_getter_map_.end())
     return iter->second;
 
+  // Get the app context as the starting point for the media context, so that
+  // it uses the app's cookie store.
+  ChromeURLRequestContextGetter* app_context =
+      GetIsolatedAppRequestContextGetter(app_id);
   ChromeURLRequestContextGetter* context =
       ChromeURLRequestContextGetter::CreateOriginalForIsolatedMedia(
-          profile_, io_data_, app_id);
+          profile_, app_context, io_data_, app_id);
   isolated_media_request_context_getter_map_[app_id] = context;
 
   return context;
 }
 
 void ProfileImplIOData::Handle::ClearNetworkingHistorySince(
     base::Time time) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   LazyInitialize();
 
@@ skipping 165 matching lines @@
         record_mode ? net::HttpCache::RECORD : net::HttpCache::PLAYBACK);
   }
 
   main_http_factory_.reset(main_cache);
   main_context->set_http_transaction_factory(main_cache);
 
 #if !defined(DISABLE_FTP_SUPPORT)
   ftp_factory_.reset(
       new net::FtpNetworkLayer(io_thread_globals->host_resolver.get()));
   main_context->set_ftp_transaction_factory(ftp_factory_.get());
+  extensions_context->set_ftp_transaction_factory(ftp_factory_.get());
 #endif  // !defined(DISABLE_FTP_SUPPORT)
 
   main_context->set_chrome_url_data_manager_backend(
       chrome_url_data_manager_backend());
 
   // Create a media request context based on the main context, but using a
   // media cache.
   media_request_context_.reset(InitializeMediaRequestContext(main_context, ""));
 
   main_job_factory_.reset(new net::URLRequestJobFactoryImpl);
   media_request_job_factory_.reset(new net::URLRequestJobFactoryImpl);
   extensions_job_factory_.reset(new net::URLRequestJobFactoryImpl);
 
-  int set_protocol = main_job_factory_->SetProtocolHandler(
-      chrome::kFileScheme, new net::FileProtocolHandler());
-  DCHECK(set_protocol);
-  set_protocol = media_request_job_factory_->SetProtocolHandler(
-      chrome::kFileScheme, new net::FileProtocolHandler());
-  DCHECK(set_protocol);
+  SetUpJobFactory(main_job_factory_.get(),
+                  profile_params->protocol_handler_interceptor.Pass(),
+                  network_delegate(),
+                  main_context->ftp_transaction_factory(),
+                  main_context->ftp_auth_cache());
+  SetUpJobFactory(media_request_job_factory_.get(),
+                  scoped_ptr<net::URLRequestJobFactoryImpl::Interceptor>(NULL),
+                  network_delegate(),
+                  media_request_context_->ftp_transaction_factory(),
+                  media_request_context_->ftp_auth_cache());
   // TODO(shalev): The extensions_job_factory has a NULL NetworkDelegate.
   // Without a network_delegate, this protocol handler will never
   // handle file: requests, but as a side effect it makes
   // job_factory::IsHandledProtocol return true, which prevents attempts to
-  // handle the protocol externally.
-  set_protocol = extensions_job_factory_->SetProtocolHandler(
-      chrome::kFileScheme, new net::FileProtocolHandler());
-  DCHECK(set_protocol);
-
-  set_protocol = main_job_factory_->SetProtocolHandler(
-      chrome::kChromeDevToolsScheme,
-      CreateDevToolsProtocolHandler(chrome_url_data_manager_backend(),
-                                    network_delegate()));
-  DCHECK(set_protocol);
-  set_protocol = media_request_job_factory_->SetProtocolHandler(
-      chrome::kChromeDevToolsScheme,
-      CreateDevToolsProtocolHandler(chrome_url_data_manager_backend(),
-                                    network_delegate()));
-  DCHECK(set_protocol);
-  set_protocol = extensions_job_factory_->SetProtocolHandler(
-      chrome::kChromeDevToolsScheme,
-      CreateDevToolsProtocolHandler(chrome_url_data_manager_backend(), NULL));
-  DCHECK(set_protocol);
-
-  net::URLRequestJobFactory* job_factories[3];
-  job_factories[0] = main_job_factory_.get();
-  job_factories[1] = media_request_job_factory_.get();
-  job_factories[2] = extensions_job_factory_.get();
-
-  net::FtpAuthCache* ftp_auth_caches[3];
-  ftp_auth_caches[0] = main_context->ftp_auth_cache();
-  ftp_auth_caches[1] = media_request_context_->ftp_auth_cache();
-  ftp_auth_caches[2] = extensions_context->ftp_auth_cache();
-
-  for (int i = 0; i < 3; i++) {
-    SetUpJobFactoryDefaults(job_factories[i]);
-    job_factories[i]->SetProtocolHandler(chrome::kAboutScheme,
-                                         new net::AboutProtocolHandler());
-    CreateFtpProtocolHandler(job_factories[i], ftp_auth_caches[i]);
-    job_factories[i]->AddInterceptor(
-        new chrome_browser_net::ConnectInterceptor(predictor_.get()));
-  }
+  // handle the protocol externally. We pass NULL in to
+  // SetUpJobFactory() to get this effect.
+  SetUpJobFactory(extensions_job_factory_.get(),
+                  scoped_ptr<net::URLRequestJobFactoryImpl::Interceptor>(NULL),
+                  NULL,
+                  extensions_context->ftp_transaction_factory(),
+                  extensions_context->ftp_auth_cache());
 
   main_context->set_job_factory(main_job_factory_.get());
   media_request_context_->set_job_factory(media_request_job_factory_.get());
   extensions_context->set_job_factory(extensions_job_factory_.get());
 
   lazy_params_.reset();
 }
 
 ChromeURLRequestContext*
 ProfileImplIOData::InitializeAppRequestContext(
     ChromeURLRequestContext* main_context,
-    const std::string& app_id) const {
+    const std::string& app_id,
+    scoped_ptr<net::URLRequestJobFactory::Interceptor>
+        protocol_handler_interceptor) const {
   // If this is for a guest process, we should not persist cookies and http
   // cache.
   bool is_guest_process = (app_id.find("guest-") != std::string::npos);
 
   // Copy most state from the main context.
   AppRequestContext* context = new AppRequestContext(load_time_stats());
   context->CopyFrom(main_context);
 
   using content::StoragePartition;
   FilePath app_path =
@@ skipping 46 matching lines @@
     scoped_refptr<SQLitePersistentCookieStore> cookie_db =
         new SQLitePersistentCookieStore(cookie_path, false, NULL);
     // TODO(creis): We should have a cookie delegate for notifying the cookie
     // extensions API, but we need to update it to understand isolated apps
     // first.
     cookie_store = new net::CookieMonster(cookie_db.get(), NULL);
   }
 
   // Transfer ownership of the cookies and cache to AppRequestContext.
   context->SetCookieStore(cookie_store);
-  context->SetHttpTransactionFactory(app_http_cache);
+  context->SetHttpTransactionFactory(
+      scoped_ptr<net::HttpTransactionFactory>(app_http_cache));
+
+  // Overwrite the job factory that we inherit from the main context so
+  // that we can later provide our own handles for storage related protocols.
+  scoped_ptr<net::URLRequestJobFactory> job_factory(
+      new net::URLRequestJobFactoryImpl());
+  SetUpJobFactory(job_factory.get(), protocol_handler_interceptor.Pass(),
+                  network_delegate(),
+                  context->ftp_transaction_factory(),
+                  context->ftp_auth_cache());
+  context->SetJobFactory(job_factory.Pass());
 
   return context;
 }
 
 ChromeURLRequestContext*
 ProfileImplIOData::InitializeMediaRequestContext(
     ChromeURLRequestContext* original_context,
     const std::string& app_id) const {
   // If this is for a guest process, we do not persist storage, so we can
   // simply use the app's in-memory cache (like off-the-record mode).
@@ skipping 19 matching lines @@
 
   // Use a separate HTTP disk cache for isolated apps.
   net::HttpCache::BackendFactory* media_backend =
       new net::HttpCache::DefaultBackend(
           net::MEDIA_CACHE,
           cache_path,
           cache_max_size,
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::CACHE));
   net::HttpNetworkSession* main_network_session =
       main_http_factory_->GetSession();
-  net::HttpCache* media_http_cache =
-      new net::HttpCache(main_network_session, media_backend);
+  scoped_ptr<net::HttpTransactionFactory> media_http_cache(
+      new net::HttpCache(main_network_session, media_backend));
 
   // Transfer ownership of the cache to MediaRequestContext.
-  context->SetHttpTransactionFactory(media_http_cache);
+  context->SetHttpTransactionFactory(media_http_cache.Pass());
+
+  // Note that we do not create a new URLRequestJobFactory because
+  // the media context should behave exactly like its parent context
+  // in all respects except for cache behavior on media subresources.
+  // The CopyFrom() step above means that our media context will use
+  // the same URLRequestJobFactory instance that our parent context does.
 
   return context;
 }
 
 ChromeURLRequestContext*
 ProfileImplIOData::AcquireMediaRequestContext() const {
   DCHECK(media_request_context_.get());
   return media_request_context_.get();
 }
 
 ChromeURLRequestContext*
 ProfileImplIOData::AcquireIsolatedAppRequestContext(
     ChromeURLRequestContext* main_context,
-    const std::string& app_id) const {
+    const std::string& app_id,
+    scoped_ptr<net::URLRequestJobFactory::Interceptor>
+        protocol_handler_interceptor) const {
   // We create per-app contexts on demand, unlike the others above.
   ChromeURLRequestContext* app_request_context =
-      InitializeAppRequestContext(main_context, app_id);
+      InitializeAppRequestContext(main_context, app_id,
+                                  protocol_handler_interceptor.Pass());
   DCHECK(app_request_context);
   return app_request_context;
 }
 
 ChromeURLRequestContext*
 ProfileImplIOData::AcquireIsolatedMediaRequestContext(
     ChromeURLRequestContext* app_context,
     const std::string& app_id) const {
   // We create per-app media contexts on demand, unlike the others above.
   ChromeURLRequestContext* media_request_context =
       InitializeMediaRequestContext(app_context, app_id);
   DCHECK(media_request_context);
   return media_request_context;
 }
 
 chrome_browser_net::LoadTimeStats* ProfileImplIOData::GetLoadTimeStats(
     IOThread::Globals* io_thread_globals) const {
   return io_thread_globals->load_time_stats.get();
 }
 
-void ProfileImplIOData::CreateFtpProtocolHandler(
+void ProfileImplIOData::SetUpJobFactory(
     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 {
-#if !defined(DISABLE_FTP_SUPPORT)
-  job_factory->SetProtocolHandler(
-      chrome::kFtpScheme,
-      new net::FtpProtocolHandler(ftp_factory_.get(),
-                                  ftp_auth_cache));
-#endif  // !defined(DISABLE_FTP_SUPPORT)
+  SetUpJobFactoryDefaults(job_factory, protocol_handler_interceptor.Pass(),
+                          network_delegate, ftp_transaction_factory,
+                          ftp_auth_cache);
+
+  job_factory->AddInterceptor(
+      new chrome_browser_net::ConnectInterceptor(predictor_.get()));
 }
 
 void ProfileImplIOData::ClearNetworkingHistorySinceOnIOThread(
     base::Time time) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   LazyInitialize();
 
   DCHECK(transport_security_state());
   transport_security_state()->DeleteSince(time);
   DCHECK(http_server_properties_manager());
   http_server_properties_manager()->Clear();
 }