Add StoragePartition's ProtocolHandlers at URLRequestContext construction time.

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 347 matching lines @@
 
   return IsHandledProtocol(url.scheme());
 }
 
 content::ResourceContext* ProfileIOData::GetResourceContext() const {
   return resource_context_.get();
 }
 
 ChromeURLDataManagerBackend*
 ProfileIOData::GetChromeURLDataManagerBackend() const {
-  LazyInitialize();
+  DCHECK(initialized_);
   return chrome_url_data_manager_backend_.get();
 }
 
 ChromeURLRequestContext*
-ProfileIOData::GetMainRequestContext() const {
-  LazyInitialize();
-  return main_request_context_.get();
-}
-
-ChromeURLRequestContext*
 ProfileIOData::GetMediaRequestContext() const {
-  LazyInitialize();
+  DCHECK(initialized_);
   ChromeURLRequestContext* context =
       AcquireMediaRequestContext();
   DCHECK(context);
   return context;
 }
 
 ChromeURLRequestContext*
 ProfileIOData::GetExtensionsRequestContext() const {
-  LazyInitialize();
+  DCHECK(initialized_);
   return extensions_request_context_.get();
 }
 
 ChromeURLRequestContext*
 ProfileIOData::GetIsolatedAppRequestContext(
     ChromeURLRequestContext* main_context,
     const StoragePartitionDescriptor& partition_descriptor,
     scoped_ptr<net::URLRequestJobFactory::Interceptor>
-        protocol_handler_interceptor) const {
-  LazyInitialize();
+        protocol_handler_interceptor,
+    scoped_ptr<net::URLRequestJobFactory::ProtocolHandler>
+        blob_protocol_handler,
+    scoped_ptr<net::URLRequestJobFactory::ProtocolHandler>
+        file_system_protocol_handler,
+    scoped_ptr<net::URLRequestJobFactory::Interceptor>
+        developer_protocol_handler) 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());
+        main_context, partition_descriptor, protocol_handler_interceptor.Pass(),
+        blob_protocol_handler.Pass(), file_system_protocol_handler.Pass(),
+        developer_protocol_handler.Pass());
     app_request_context_map_[partition_descriptor] = context;
   }
   DCHECK(context);
   return context;
 }
 
 ChromeURLRequestContext*
 ProfileIOData::GetIsolatedMediaRequestContext(
     ChromeURLRequestContext* app_context,
     const StoragePartitionDescriptor& partition_descriptor) const {
-  LazyInitialize();
+  DCHECK(initialized_);
   ChromeURLRequestContext* context = NULL;
   if (ContainsKey(isolated_media_request_context_map_, partition_descriptor)) {
     context = isolated_media_request_context_map_[partition_descriptor];
   } else {
     context = AcquireIsolatedMediaRequestContext(app_context,
                                                  partition_descriptor);
     isolated_media_request_context_map_[partition_descriptor] = context;
   }
   DCHECK(context);
   return context;
@@ skipping 54 matching lines @@
 ProfileIOData::ResourceContext::ResourceContext(ProfileIOData* io_data)
     : io_data_(io_data),
       host_resolver_(NULL),
       request_context_(NULL) {
   DCHECK(io_data);
 }
 
 ProfileIOData::ResourceContext::~ResourceContext() {}
 
 void ProfileIOData::ResourceContext::EnsureInitialized() {
-  io_data_->LazyInitialize();
+  DCHECK(io_data_->initialized_);
 }
 
 net::HostResolver* ProfileIOData::ResourceContext::GetHostResolver()  {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   EnsureInitialized();
   return host_resolver_;
 }
 
 net::URLRequestContext* ProfileIOData::ResourceContext::GetRequestContext()  {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   EnsureInitialized();
   return request_context_;
 }
 
 // static
 std::string ProfileIOData::GetSSLSessionCacheShard() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   // 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 StringPrintf("profile/%u", ssl_session_cache_instance++);
 }
 
-void ProfileIOData::LazyInitialize() const {
+ChromeURLRequestContext* ProfileIOData::GetMainRequestContext(
+    scoped_ptr<net::URLRequestJobFactory::ProtocolHandler>
+        blob_protocol_handler,
+    scoped_ptr<net::URLRequestJobFactory::ProtocolHandler>
+        file_system_protocol_handler,
+    scoped_ptr<net::URLRequestJobFactory::Interceptor>
+        developer_protocol_handler) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  if (initialized_)
-    return;
+  DCHECK(!initialized_);
 
   // TODO(jhawkins): Remove once crbug.com/102004 is fixed.
   CHECK(initialized_on_UI_thread_);
 
   // TODO(jhawkins): Return to DCHECK once crbug.com/102004 is fixed.
   CHECK(profile_params_.get());
 
   IOThread* const io_thread = profile_params_->io_thread;
   IOThread::Globals* const io_thread_globals = io_thread->globals();
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
@@ skipping 51 matching lines @@
   extension_info_map_ = profile_params_->extension_info_map;
 
   resource_context_->host_resolver_ = io_thread_globals->host_resolver.get();
   resource_context_->request_context_ = main_request_context_.get();
 
   if (profile_params_->resource_prefetch_predictor_observer_.get()) {
     resource_prefetch_predictor_observer_.reset(
         profile_params_->resource_prefetch_predictor_observer_.release());
   }
 
-  LazyInitializeInternal(profile_params_.get());
+  LazyInitializeInternal(profile_params_.get(),
+                         blob_protocol_handler.Pass(),
+                         file_system_protocol_handler.Pass(),
+                         developer_protocol_handler.Pass());
 
   profile_params_.reset();
   initialized_ = true;
+
+  return main_request_context_.get();
 }
 
 void ProfileIOData::ApplyProfileParamsToContext(
     ChromeURLRequestContext* context) const {
   context->set_is_incognito(is_incognito());
   context->set_http_user_agent_settings(
       chrome_http_user_agent_settings_.get());
   context->set_ssl_config_service(profile_params_->ssl_config_service);
 }
 
@@ skipping 121 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);
 }