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 156 matching lines @@
   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
   // method, so we create the url job factory here, then save it for
-  // later delivery to the job factory in LazyInitialize.
+  // later delivery to the job factory in Init().
   params->protocol_handler_interceptor =
       protocol_handler_registry->CreateJobInterceptorFactory();
 
   ChromeProxyConfigService* proxy_config_service =
       ProxyServiceFactory::CreateProxyConfigService();
   params->proxy_config_service.reset(proxy_config_service);
   profile->GetProxyConfigTracker()->SetChromeProxyConfigService(
       proxy_config_service);
   params->profile = profile;
   profile_params_.reset(params.release());
@@ skipping 171 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();
+ChromeURLRequestContext* ProfileIOData::GetMainRequestContext() const {
+  DCHECK(initialized_);
   return main_request_context_.get();
 }
 
-ChromeURLRequestContext*
-ProfileIOData::GetMediaRequestContext() const {
-  LazyInitialize();
-  ChromeURLRequestContext* context =
-      AcquireMediaRequestContext();
+ChromeURLRequestContext* ProfileIOData::GetMediaRequestContext() const {
+  DCHECK(initialized_);
+  ChromeURLRequestContext* context = AcquireMediaRequestContext();
   DCHECK(context);
   return context;
 }
 
-ChromeURLRequestContext*
-ProfileIOData::GetExtensionsRequestContext() const {
-  LazyInitialize();
+ChromeURLRequestContext* ProfileIOData::GetExtensionsRequestContext() const {
+  DCHECK(initialized_);
   return extensions_request_context_.get();
 }
 
-ChromeURLRequestContext*
-ProfileIOData::GetIsolatedAppRequestContext(
+ChromeURLRequestContext* ProfileIOData::GetIsolatedAppRequestContext(
     ChromeURLRequestContext* main_context,
     const StoragePartitionDescriptor& partition_descriptor,
     scoped_ptr<ProtocolHandlerRegistry::JobInterceptorFactory>
-        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* 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;
 }
 
 ExtensionInfoMap* ProfileIOData::GetExtensionInfoMap() const {
-  DCHECK(extension_info_map_) << "ExtensionSystem not initialized";
+  DCHECK(initialized_) << "ExtensionSystem not initialized";
   return extension_info_map_;
 }
 
 CookieSettings* ProfileIOData::GetCookieSettings() const {
+  // Allow either Init() or SetCookieSettingsForTesting() to initialize.
+  DCHECK(initialized_ || cookie_settings_);
   return cookie_settings_;
 }
 
 #if defined(ENABLE_NOTIFICATIONS)
 DesktopNotificationService* ProfileIOData::GetNotificationService() const {
+  DCHECK(initialized_);
   return notification_service_;
 }
 #endif
 
 void ProfileIOData::InitializeMetricsEnabledStateOnUIThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 #if defined(OS_CHROMEOS)
   // Just fetch the value from ChromeOS' settings while we're on the UI thread.
   // TODO(stevet): For now, this value is only set on profile initialization.
   // We will want to do something similar to the PrefMember method below in the
@@ skipping 30 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();
-}
-
 net::HostResolver* ProfileIOData::ResourceContext::GetHostResolver()  {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  EnsureInitialized();
+  DCHECK(io_data_->initialized_);
   return host_resolver_;
 }
 
 net::URLRequestContext* ProfileIOData::ResourceContext::GetRequestContext()  {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  EnsureInitialized();
+  DCHECK(io_data_->initialized_);
   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 {
+void ProfileIOData::Init(
+    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 {
+  // 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));
-  if (initialized_)
-    return;
+  DCHECK(!initialized_);
 
   startup_metric_utils::ScopedSlowStartupUMA
       scoped_timer("Startup.SlowStartupProfileIODataInit");
 
   // 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());
 
@@ skipping 54 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());
+  InitializeInternal(profile_params_.get(),
+                     blob_protocol_handler.Pass(),
+                     file_system_protocol_handler.Pass(),
+                     developer_protocol_handler.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);
@@ skipping 10 matching lines @@
   // ProfileIOData::IsHandledProtocol().
   bool set_protocol = job_factory->SetProtocolHandler(
       chrome::kFileScheme, new net::FileProtocolHandler());
   DCHECK(set_protocol);
 
   set_protocol = job_factory->SetProtocolHandler(
       chrome::kChromeDevToolsScheme,
       CreateDevToolsProtocolHandler(chrome_url_data_manager_backend(),
                                     network_delegate, is_incognito()));
   DCHECK(set_protocol);
+  DCHECK(extension_info_map_);
   set_protocol = job_factory->SetProtocolHandler(
       extensions::kExtensionScheme,
-      CreateExtensionProtocolHandler(is_incognito(), GetExtensionInfoMap()));
+      CreateExtensionProtocolHandler(is_incognito(), extension_info_map_));
   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(),
           is_incognito()));
@@ skipping 96 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);
 }