Remove the Extensions URLRequestContext

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"
@@ skipping 56 matching lines @@
   io_data_->ShutdownOnUIThread();
 }
 
 void ProfileImplIOData::Handle::Init(
       const base::FilePath& cookie_path,
       const base::FilePath& server_bound_cert_path,
       const base::FilePath& cache_path,
       int cache_max_size,
       const base::FilePath& media_cache_path,
       int media_cache_max_size,
-      const base::FilePath& extensions_cookie_path,
+      const base::FilePath& extension_cookie_path,
       const base::FilePath& profile_path,
       const base::FilePath& infinite_cache_path,
       chrome_browser_net::Predictor* predictor,
       bool restore_old_session_cookies,
       quota::SpecialStoragePolicy* special_storage_policy) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!io_data_->lazy_params_.get());
   DCHECK(predictor);
 
   LazyParams* lazy_params = new LazyParams;
 
   lazy_params->cookie_path = cookie_path;
   lazy_params->server_bound_cert_path = server_bound_cert_path;
   lazy_params->cache_path = cache_path;
   lazy_params->cache_max_size = cache_max_size;
   lazy_params->media_cache_path = media_cache_path;
   lazy_params->media_cache_max_size = media_cache_max_size;
-  lazy_params->extensions_cookie_path = extensions_cookie_path;
+  lazy_params->extension_cookie_path = extension_cookie_path;
   lazy_params->infinite_cache_path = infinite_cache_path;
   lazy_params->restore_old_session_cookies = restore_old_session_cookies;
   lazy_params->special_storage_policy = special_storage_policy;
 
   io_data_->lazy_params_.reset(lazy_params);
 
   // Keep track of profile path and cache sizes separately so we can use them
   // on demand when creating storage isolated URLRequestContextGetters.
   io_data_->profile_path_ = profile_path;
   io_data_->app_cache_max_size_ = cache_max_size;
@@ skipping 60 matching lines @@
   LazyInitialize();
   if (!media_request_context_getter_) {
     media_request_context_getter_ =
         ChromeURLRequestContextGetter::CreateOriginalForMedia(
             profile_, io_data_);
   }
   return media_request_context_getter_;
 }
 
 scoped_refptr<ChromeURLRequestContextGetter>
-ProfileImplIOData::Handle::GetExtensionsRequestContextGetter() const {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  LazyInitialize();
-  if (!extensions_request_context_getter_) {
-    extensions_request_context_getter_ =
-        ChromeURLRequestContextGetter::CreateOriginalForExtensions(
-            profile_, io_data_);
-  }
-  return extensions_request_context_getter_;
-}
-
-scoped_refptr<ChromeURLRequestContextGetter>
 ProfileImplIOData::Handle::CreateIsolatedAppRequestContextGetter(
     const base::FilePath& partition_path,
     bool in_memory,
     scoped_ptr<net::URLRequestJobFactory::ProtocolHandler>
         blob_protocol_handler,
     scoped_ptr<net::URLRequestJobFactory::ProtocolHandler>
         file_system_protocol_handler,
     scoped_ptr<net::URLRequestJobFactory::ProtocolHandler>
         developer_protocol_handler,
     scoped_ptr<net::URLRequestJobFactory::ProtocolHandler>
@@ skipping 266 matching lines @@
       main_job_factory.Pass(),
       profile_params->protocol_handler_interceptor.Pass(),
       network_delegate(),
       main_context->ftp_transaction_factory(),
       main_context->ftp_auth_cache());
   main_job_factory_.reset(new net::ProtocolInterceptJobFactory(
       main_job_factory_.Pass(), developer_protocol_handler.Pass()));
   main_context->set_job_factory(main_job_factory_.get());
 
 #if defined(ENABLE_EXTENSIONS)
-  InitializeExtensionsRequestContext(profile_params);
+  extension_cookie_store_ =
+    new net::CookieMonster(
+        new SQLitePersistentCookieStore(
+            lazy_params_->extension_cookie_path,
+            BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO),
+            BrowserThread::GetBlockingPool()->GetSequencedTaskRunner(
+                BrowserThread::GetBlockingPool()->GetSequenceToken()),
+            lazy_params_->restore_old_session_cookies, NULL), NULL);
 #endif
 
   // Create a media request context based on the main context, but using a
   // media cache.  It shares the same job factory as the main context.
   StoragePartitionDescriptor details(profile_path_, false);
   media_request_context_.reset(InitializeMediaRequestContext(main_context,
                                                              details));
 
   lazy_params_.reset();
 }
 
-void ProfileImplIOData::
-    InitializeExtensionsRequestContext(ProfileParams* profile_params) const {
-  ChromeURLRequestContext* extensions_context = extensions_request_context();
-  IOThread* const io_thread = profile_params->io_thread;
-  IOThread::Globals* const io_thread_globals = io_thread->globals();
-  ApplyProfileParamsToContext(extensions_context);
-
-  extensions_context->set_transport_security_state(transport_security_state());
-
-  extensions_context->set_net_log(io_thread->net_log());
-
-  extensions_context->set_throttler_manager(
-      io_thread_globals->throttler_manager.get());
-
-  net::CookieMonster* extensions_cookie_store =
-      new net::CookieMonster(
-          new SQLitePersistentCookieStore(
-              lazy_params_->extensions_cookie_path,
-              BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO),
-              BrowserThread::GetBlockingPool()->GetSequencedTaskRunner(
-                  BrowserThread::GetBlockingPool()->GetSequenceToken()),
-              lazy_params_->restore_old_session_cookies, NULL), NULL);
-  // Enable cookies for devtools and extension URLs.
-  const char* schemes[] = {chrome::kChromeDevToolsScheme,
-                           extensions::kExtensionScheme};
-  extensions_cookie_store->SetCookieableSchemes(schemes, 2);
-  extensions_context->set_cookie_store(extensions_cookie_store);
-
-#if !defined(DISABLE_FTP_SUPPORT)
-  DCHECK(ftp_factory_.get());
-  extensions_context->set_ftp_transaction_factory(ftp_factory_.get());
-#endif  // !defined(DISABLE_FTP_SUPPORT)
-
-  scoped_ptr<net::URLRequestJobFactoryImpl> extensions_job_factory(
-      new net::URLRequestJobFactoryImpl());
-  // 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. We pass NULL in to
-  // SetUpJobFactory() to get this effect.
-  extensions_job_factory_ = SetUpJobFactoryDefaults(
-      extensions_job_factory.Pass(),
-      scoped_ptr<ProtocolHandlerRegistry::JobInterceptorFactory>(NULL),
-      NULL,
-      extensions_context->ftp_transaction_factory(),
-      extensions_context->ftp_auth_cache());
-  extensions_context->set_job_factory(extensions_job_factory_.get());
-}
-
 ChromeURLRequestContext*
 ProfileImplIOData::InitializeAppRequestContext(
     ChromeURLRequestContext* main_context,
     const StoragePartitionDescriptor& partition_descriptor,
     scoped_ptr<ProtocolHandlerRegistry::JobInterceptorFactory>
         protocol_handler_interceptor,
     scoped_ptr<net::URLRequestJobFactory::ProtocolHandler>
         blob_protocol_handler,
     scoped_ptr<net::URLRequestJobFactory::ProtocolHandler>
         file_system_protocol_handler,
@@ skipping 212 matching lines @@
     const base::Closure& completion) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(initialized());
 
   DCHECK(transport_security_state());
   // Completes synchronously.
   transport_security_state()->DeleteAllDynamicDataSince(time);
   DCHECK(http_server_properties_manager_);
   http_server_properties_manager_->Clear(completion);
 }