********** Chromium Blob hacking

content/browser/storage_partition_impl_map.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/storage_partition_impl_map.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
@@ skipping 15 matching lines @@
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/common/content_constants.h"
 #include "content/public/common/url_constants.h"
 #include "crypto/sha2.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_context.h"
 #include "webkit/appcache/view_appcache_internals_job.h"
 #include "webkit/blob/blob_data.h"
+#include "webkit/blob/blob_storage_context.h"
 #include "webkit/blob/blob_url_request_job_factory.h"
 #include "webkit/fileapi/file_system_url_request_job_factory.h"
 
 using appcache::AppCacheService;
 using fileapi::FileSystemContext;
-using webkit_blob::BlobStorageController;
+using webkit_blob::BlobStorageContext;
 
 namespace content {
 
 namespace {
 
-class BlobProtocolHandler : public webkit_blob::BlobProtocolHandler {
- public:
-  BlobProtocolHandler(
-      webkit_blob::BlobStorageController* blob_storage_controller,
-      fileapi::FileSystemContext* file_system_context,
-      base::MessageLoopProxy* loop_proxy)
-      : webkit_blob::BlobProtocolHandler(blob_storage_controller,
-                                         file_system_context,
-                                         loop_proxy) {}
-
-  virtual ~BlobProtocolHandler() {}
-
- private:
-  virtual scoped_refptr<webkit_blob::BlobData>
-      LookupBlobData(net::URLRequest* request) const {
-    const ResourceRequestInfoImpl* info =
-        ResourceRequestInfoImpl::ForRequest(request);
-    if (!info)
-      return NULL;
-    return info->requested_blob_data();
-  }
-
-  DISALLOW_COPY_AND_ASSIGN(BlobProtocolHandler);
-};
-
 // Adds a bunch of debugging urls. We use an interceptor instead of a protocol
 // handler because we want to reuse the chrome://scheme (everyone is familiar
 // with it, and no need to expose the content/chrome separation through our UI).
 class DeveloperProtocolHandler
     : public net::URLRequestJobFactory::Interceptor {
  public:
   DeveloperProtocolHandler(
       AppCacheService* appcache_service,
-      BlobStorageController* blob_storage_controller)
+      BlobStorageContext* blob_storage_context)
       : appcache_service_(appcache_service),
-        blob_storage_controller_(blob_storage_controller) {}
+        blob_storage_context_(blob_storage_context) {}
   virtual ~DeveloperProtocolHandler() {}
 
   virtual net::URLRequestJob* MaybeIntercept(
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate) const OVERRIDE {
     // Check for chrome://view-http-cache/*, which uses its own job type.
     if (ViewHttpCacheJobFactory::IsSupportedURL(request->url()))
       return ViewHttpCacheJobFactory::CreateJobForRequest(request,
                                                           network_delegate);
 
     // Next check for chrome://appcache-internals/, which uses its own job type.
     if (request->url().SchemeIs(chrome::kChromeUIScheme) &&
         request->url().host() == chrome::kChromeUIAppCacheInternalsHost) {
       return appcache::ViewAppCacheInternalsJobFactory::CreateJobForRequest(
           request, network_delegate, appcache_service_);
     }
 
-    // Next check for chrome://blob-internals/, which uses its own job type.
-    if (ViewBlobInternalsJobFactory::IsSupportedURL(request->url())) {
-      return ViewBlobInternalsJobFactory::CreateJobForRequest(
-          request, network_delegate, blob_storage_controller_);
-    }
+    //// Next check for chrome://blob-internals/, which uses its own job type.
+    //if (ViewBlobInternalsJobFactory::IsSupportedURL(request->url())) {
+    //  return ViewBlobInternalsJobFactory::CreateJobForRequest(
+    //      request, network_delegate, blob_storage_controller_);
+    //}
 
 #if defined(USE_TCMALLOC)
     // Next check for chrome://tcmalloc/, which uses its own job type.
     if (request->url().SchemeIs(chrome::kChromeUIScheme) &&
         request->url().host() == chrome::kChromeUITcmallocHost) {
       return new TcmallocInternalsRequestJob(request, network_delegate);
     }
 #endif
 
     // Next check for chrome://histograms/, which uses its own job type.
@@ skipping 17 matching lines @@
       net::NetworkDelegate* network_delegate) const OVERRIDE {
     return NULL;
   }
 
   virtual bool WillHandleProtocol(const std::string& protocol) const {
     return protocol == chrome::kChromeUIScheme;
   }
 
  private:
   AppCacheService* appcache_service_;
-  BlobStorageController* blob_storage_controller_;
+  BlobStorageContext* blob_storage_context_;
 };
 
 void InitializeURLRequestContext(
     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.
@@ skipping 11 matching lines @@
       const_cast<net::URLRequestJobFactory*>(context->job_factory());
 
   // Note: if this is called twice with 2 request contexts that share one job
   // factory (as is the case with a media request context and its related
   // normal request context) then this will early exit.
   if (job_factory->IsHandledProtocol(chrome::kBlobScheme))
     return;  // Already initialized this JobFactory.
 
   bool set_protocol = job_factory->SetProtocolHandler(
       chrome::kBlobScheme,
-      new BlobProtocolHandler(
-          blob_storage_context->controller(),
+      new webkit_blob::BlobProtocolHandler(
+          blob_storage_context->context(),
           file_system_context,
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE)));
   DCHECK(set_protocol);
   set_protocol = job_factory->SetProtocolHandler(
       chrome::kFileSystemScheme,
       CreateFileSystemProtocolHandler(file_system_context));
   DCHECK(set_protocol);
 
   job_factory->AddInterceptor(
       new DeveloperProtocolHandler(appcache_service,
-                                   blob_storage_context->controller()));
+                                   blob_storage_context->context()));
 
   // TODO(jam): Add the ProtocolHandlerRegistryIntercepter here!
 }
 
 // These constants are used to create the directory structure under the profile
 // where renderers with a non-default storage partition keep their persistent
 // state. This will contain a set of directories that partially mirror the
 // directory structure of BrowserContext::GetPath().
 //
 // The kStoragePartitionDirname contains an extensions directory which is
@@ skipping 309 matching lines @@
 
     // We do not call InitializeURLRequestContext() for media contexts because,
     // other than the HTTP cache, the media contexts share the same backing
     // objects as their associated "normal" request context.  Thus, the previous
     // call serves to initialize the media request context for this storage
     // partition as well.
   }
 }
 
 }  // namespace content