Add StoragePartition's ProtocolHandlers at URLRequestContext construction time.

content/shell/shell_browser_context.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 "content/shell/shell_browser_context.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/environment.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/threading/thread.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/resource_context.h"
+#include "content/public/common/content_switches.h"
 #include "content/shell/shell_download_manager_delegate.h"
-#include "content/shell/shell_resource_context.h"
 #include "content/shell/shell_switches.h"
 #include "content/shell/shell_url_request_context_getter.h"
-#include "content/public/common/content_switches.h"
 
 #if defined(OS_WIN)
 #include "base/base_paths_win.h"
 #elif defined(OS_LINUX)
 #include "base/nix/xdg_util.h"
 #elif defined(OS_MACOSX)
 #include "base/base_paths_mac.h"
 #endif
 
 namespace content {
 
+class ShellResourceContext : public ResourceContext {

[awong, 2012/12/13 23:53:08]

I see what you mean by it being referenced.  In that case, it might actually be
better to just put it back into its own file.

[pauljensen, 2012/12/14 16:16:20]

Well if I move it into its own file then I think I'm violating the style guide's
recommendation that friends be defined in the same file.  I've moved it back to
being a private sub-class of ShellBrowserContext but incompletely defined in the
header.  This way its out of the global namespace and its private so others
aren't tempted to use it and its not cluttering up the interface/header file.

[awong, 2012/12/14 16:44:24]

I don't feel too strongly about having keeping friend classes in the same file,
but having it be a private class in this situation is indeed nicer.  Thanks for
thinking it through.

+ public:
+  ShellResourceContext() : getter_(NULL) {}
+  virtual ~ShellResourceContext() {}
+
+ private:
+  friend class ShellBrowserContext;
+
+  // ResourceContext implementation:
+  virtual net::HostResolver* GetHostResolver() OVERRIDE {
+    CHECK(getter_);
+    return getter_->host_resolver();
+  }
+  virtual net::URLRequestContext* GetRequestContext() OVERRIDE {
+    CHECK(getter_);
+    return getter_->GetURLRequestContext();
+  }
+
+  ShellURLRequestContextGetter* getter_;
+
+  DISALLOW_COPY_AND_ASSIGN(ShellResourceContext);
+};
+
 ShellBrowserContext::ShellBrowserContext(bool off_the_record)
     : off_the_record_(off_the_record),
-      ignore_certificate_errors_(false) {
+      ignore_certificate_errors_(false),
+      resource_context_(new ShellResourceContext()) {
   InitWhileIOAllowed();
 }
 
 ShellBrowserContext::~ShellBrowserContext() {
   if (resource_context_.get()) {
     BrowserThread::DeleteSoon(
       BrowserThread::IO, FROM_HERE, resource_context_.release());
   }
 }
 
@@ skipping 44 matching lines @@
 
   if (!download_manager_delegate_.get()) {
     download_manager_delegate_ = new ShellDownloadManagerDelegate();
     download_manager_delegate_->SetDownloadManager(manager);
   }
 
   return download_manager_delegate_.get();
 }
 
 net::URLRequestContextGetter* ShellBrowserContext::GetRequestContext()  {
-  if (!url_request_getter_) {
-    url_request_getter_ = new ShellURLRequestContextGetter(
-        ignore_certificate_errors_,
-        GetPath(),
-        BrowserThread::UnsafeGetMessageLoopForThread(BrowserThread::IO),
-        BrowserThread::UnsafeGetMessageLoopForThread(BrowserThread::FILE));
-  }
-  return url_request_getter_;
+  CHECK(url_request_getter_.get());
+  return url_request_getter_.get();
+}
+
+net::URLRequestContextGetter* ShellBrowserContext::CreateRequestContext(
+    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) {
+  DCHECK(!url_request_getter_.get());
+  url_request_getter_ = new ShellURLRequestContextGetter(
+      ignore_certificate_errors_,
+      GetPath(),
+      BrowserThread::UnsafeGetMessageLoopForThread(BrowserThread::IO),
+      BrowserThread::UnsafeGetMessageLoopForThread(BrowserThread::FILE),
+      blob_protocol_handler.Pass(),
+      file_system_protocol_handler.Pass(),
+      developer_protocol_handler.Pass());
+  resource_context_->getter_ = url_request_getter_.get();
+  return url_request_getter_.get();
 }
 
 net::URLRequestContextGetter*
     ShellBrowserContext::GetRequestContextForRenderProcess(
         int renderer_child_id)  {
   return GetRequestContext();
 }
 
 net::URLRequestContextGetter*
     ShellBrowserContext::GetMediaRequestContext()  {
   return GetRequestContext();
 }
 
 net::URLRequestContextGetter*
     ShellBrowserContext::GetMediaRequestContextForRenderProcess(
         int renderer_child_id)  {
   return GetRequestContext();
 }
 
 net::URLRequestContextGetter*
     ShellBrowserContext::GetMediaRequestContextForStoragePartition(
         const FilePath& partition_path,
         bool in_memory) {
   return GetRequestContext();
 }
 
 net::URLRequestContextGetter*
-    ShellBrowserContext::GetRequestContextForStoragePartition(
+    ShellBrowserContext::CreateRequestContextForStoragePartition(
         const FilePath& partition_path,
-        bool in_memory) {
+        bool in_memory,
+        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) {
   return NULL;
 }
 
 ResourceContext* ShellBrowserContext::GetResourceContext()  {
-  if (!resource_context_.get()) {
-    resource_context_.reset(new ShellResourceContext(
-        static_cast<ShellURLRequestContextGetter*>(GetRequestContext())));
-  }
   return resource_context_.get();
 }
 
 GeolocationPermissionContext*
     ShellBrowserContext::GetGeolocationPermissionContext()  {
   return NULL;
 }
 
 SpeechRecognitionPreferences*
     ShellBrowserContext::GetSpeechRecognitionPreferences() {
   return NULL;
 }
 
 quota::SpecialStoragePolicy* ShellBrowserContext::GetSpecialStoragePolicy() {
   return NULL;
 }
 
 }  // namespace content