Remove silly uses of ResourceContext that unnecessarily violate the Law of Demeter.

content/browser/resource_context_impl.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/browser/resource_context_impl.h"
 
 #include "base/logging.h"
 #include "content/browser/appcache/chrome_appcache_service.h"
 #include "content/browser/fileapi/browser_file_system_helper.h"
 #include "content/browser/fileapi/chrome_blob_storage_context.h"
@@ skipping 136 matching lines @@
   virtual bool WillHandleProtocol(const std::string& protocol) const {
     return protocol == chrome::kChromeUIScheme;
   }
 
  private:
   AppCacheService* appcache_service_;
   BlobStorageController* blob_storage_controller_;
 };
 
 void InitializeRequestContext(
-    ResourceContext* resource_context,
-    scoped_refptr<net::URLRequestContextGetter> context_getter) {
+    scoped_refptr<net::URLRequestContextGetter> context_getter,
+    AppCacheService* appcache_service,
+    FileSystemContext* file_system_context,
+    ChromeBlobStorageContext* blob_storage_context) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!context_getter)
     return;  // tests.
   net::URLRequestContext* context = context_getter->GetURLRequestContext();
   net::URLRequestJobFactory* job_factory =
       const_cast<net::URLRequestJobFactory*>(context->job_factory());
   if (job_factory->IsHandledProtocol(chrome::kBlobScheme))
     return;  // Already initialized this RequestContext.
 
   bool set_protocol = job_factory->SetProtocolHandler(
       chrome::kBlobScheme,
       new BlobProtocolHandler(
-          GetBlobStorageControllerForResourceContext(resource_context),
+          blob_storage_context->controller(),
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE)));
   DCHECK(set_protocol);
   set_protocol = job_factory->SetProtocolHandler(
       chrome::kFileSystemScheme,
-      CreateFileSystemProtocolHandler(
-          GetFileSystemContextForResourceContext(resource_context)));
+      CreateFileSystemProtocolHandler(file_system_context));
   DCHECK(set_protocol);
 
-  job_factory->AddInterceptor(new DeveloperProtocolHandler(
-      ResourceContext::GetAppCacheService(resource_context),
-      GetBlobStorageControllerForResourceContext(resource_context)));
+  job_factory->AddInterceptor(
+      new DeveloperProtocolHandler(appcache_service, blob_storage_context->controller()));

[michaeln, 2012/08/25 01:18:09]

line length

 
   // TODO(jam): Add the ProtocolHandlerRegistryIntercepter here!
 }
 
 }  // namespace
 
 AppCacheService* ResourceContext::GetAppCacheService(ResourceContext* context) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   return UserDataAdapter<ChromeAppCacheService>::Get(
       context, kAppCacheServiceKeyName);
@@ skipping 85 matching lines @@
   resource_context->SetUserData(
       kHostZoomMapKeyName,
       new NonOwningZoomData(
           HostZoomMap::GetForBrowserContext(browser_context)));
 
   // Add content's URLRequestContext's hooks.
   // Check first to avoid memory leak in unittests.
   // TODO(creis): Do equivalent initializations for isolated app and isolated
   // media request contexts.
   if (BrowserThread::IsMessageLoopValid(BrowserThread::IO)) {
+    // TODO(ajwong): Move this whole block into
+    // StoragePartitionImplMap::PostCreateInitialization after we're certain
+    // this is safe to happen before InitializeResourceContext, and after we've
+    // found the right URLRequestContext for a storage partition.  Otherwise,
+    // our isolated URLRequestContext getters will do the wrong thing for blobs,
+    // and FileSystemContext.
+    //
+    // http://crbug.com/85121
+
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
-        base::Bind(&InitializeRequestContext,
-                   resource_context,
-                   make_scoped_refptr(browser_context->GetRequestContext())));
+        base::Bind(
+            &InitializeRequestContext,
+            make_scoped_refptr(browser_context->GetRequestContext()),
+            BrowserContext::GetAppCacheService(browser_context),

[michaeln, 2012/08/25 01:18:09]

specifically, i wonder if BrowserContext::GetAppCacheService's return value
should be of type ChromeAppCacheService which is a content layer (despite the
class name) wrapper around the appcache::AppCacheService that adds refcounting
semantics... ditto for StoragePartition::GetAppCacheService()...

then when posting tasks across thread, we could use scoped_refptr args

+            make_scoped_refptr(
+                BrowserContext::GetFileSystemContext(browser_context)),
+            make_scoped_refptr(
+                ChromeBlobStorageContext::GetFor(browser_context))));
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
-        base::Bind(&InitializeRequestContext,
-                   resource_context,
-                   make_scoped_refptr(
-                       browser_context->GetMediaRequestContext())));
+        base::Bind(
+            &InitializeRequestContext,
+            make_scoped_refptr(browser_context->GetMediaRequestContext()),
+            BrowserContext::GetAppCacheService(browser_context),
+            make_scoped_refptr(
+                BrowserContext::GetFileSystemContext(browser_context)),
+            make_scoped_refptr(
+                ChromeBlobStorageContext::GetFor(browser_context))));
   }
 }
 
 }  // namespace content