Chromium Blob hacking

Start using BlobStorageContext (and family) as a replacement for BlobStorageController. The new class manages blob data by uuid and seperately maintains a mapping from of public blob urls to uuids.

Added a methods to create an additional mapping of old-style 'private urls' to new-style uuids to help with transitioning, blink needs to be retrofitted too, but that has to happen separately.

Changed blob processing classes to take BlobDataHandles as input instead of GURLs. Not long after IPC deserizliation, get a BlobDataHandle and pass that around. 
- FileSystemOperation.Write (and famlity) for FileWriter support 
- ResourceDispatcherHost (and famility) for blob url requests 
- (PostMessage handling and WebIntent plumbing ultimately needs to be treated in this way too) 


Switched to using string uuids instead of urls in IPC messages (and structs carried in ipc messages).
Until blink is retrofitted, the chromiums side supports both forms of identifying blobs (old-style private urls and new-style uuids).
- FileSystemHostMsg_Write 
- webkit_base::DataElement (and consumers: BlobData, ResourceRequestBody) 
- blob registry/building ipc messages 

Implemented the WebKit::WebBlobRegistryImpl such that it can be invoked on any renderer/worker thread. 

Got more explicit about naming: FileSystemURL vs BlobUUID vs PublicBlobURL.

Note: There are corresponding changes to be made in Blink, after which, the things annotated as deprecated in this CL can be removed.

TBR=inferno
BUG=174200

Review URL: https://chromiumcodereview.appspot.com/23223003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@220754 0039d316-1c4b-4281-b951-d872f2087c98

15 files changed, 222 insertions, 233 deletions

diff --git a/content/browser/fileapi/chrome_blob_storage_context.cc b/content/browser/fileapi/chrome_blob_storage_context.cc
index 728b0d5..97151a8 100644
--- a/content/browser/fileapi/chrome_blob_storage_context.cc
+++ b/content/browser/fileapi/chrome_blob_storage_context.cc
@@ -7,10 +7,10 @@
 #include "base/bind.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
-#include "webkit/browser/blob/blob_storage_controller.h"
+#include "webkit/browser/blob/blob_storage_context.h"
 
 using base::UserDataAdapter;
-using webkit_blob::BlobStorageController;
+using webkit_blob::BlobStorageContext;
 
 namespace content {
 
@@ -40,7 +40,7 @@ ChromeBlobStorageContext* ChromeBlobStorageContext::GetFor(
 
 void ChromeBlobStorageContext::InitializeOnIOThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  controller_.reset(new BlobStorageController());
+  context_.reset(new BlobStorageContext());
 }
 
 ChromeBlobStorageContext::~ChromeBlobStorageContext() {}
diff --git a/content/browser/fileapi/chrome_blob_storage_context.h b/content/browser/fileapi/chrome_blob_storage_context.h
index 3992e0e..641e235 100644
--- a/content/browser/fileapi/chrome_blob_storage_context.h
+++ b/content/browser/fileapi/chrome_blob_storage_context.h
@@ -11,7 +11,7 @@
 #include "content/common/content_export.h"
 
 namespace webkit_blob {
-class BlobStorageController;
+class BlobStorageContext;
 }
 
 namespace content {
@@ -36,8 +36,8 @@ class CONTENT_EXPORT ChromeBlobStorageContext
 
   void InitializeOnIOThread();
 
-  webkit_blob::BlobStorageController* controller() const {
-    return controller_.get();
+  webkit_blob::BlobStorageContext* context() const {
+    return context_.get();
   }
 
  protected:
@@ -51,7 +51,7 @@ class CONTENT_EXPORT ChromeBlobStorageContext
 
   void DeleteOnCorrectThread() const;
 
-  scoped_ptr<webkit_blob::BlobStorageController> controller_;
+  scoped_ptr<webkit_blob::BlobStorageContext> context_;
 };
 
 struct ChromeBlobStorageContextDeleter {
diff --git a/content/browser/fileapi/fileapi_message_filter.cc b/content/browser/fileapi/fileapi_message_filter.cc
index b4b5aef..8025f40 100644
--- a/content/browser/fileapi/fileapi_message_filter.cc
+++ b/content/browser/fileapi/fileapi_message_filter.cc
@@ -28,7 +28,8 @@
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "url/gurl.h"
-#include "webkit/browser/blob/blob_storage_controller.h"
+#include "webkit/browser/blob/blob_storage_context.h"
+#include "webkit/browser/blob/blob_storage_host.h"
 #include "webkit/browser/fileapi/file_observers.h"
 #include "webkit/browser/fileapi/file_permission_policy.h"
 #include "webkit/browser/fileapi/file_system_context.h"
@@ -47,7 +48,8 @@ using fileapi::FileSystemURL;
 using fileapi::FileUpdateObserver;
 using fileapi::UpdateObserverList;
 using webkit_blob::BlobData;
-using webkit_blob::BlobStorageController;
+using webkit_blob::BlobStorageContext;
+using webkit_blob::BlobStorageHost;
 
 namespace content {
 
@@ -106,6 +108,9 @@ void FileAPIMessageFilter::OnChannelConnected(int32 peer_pid) {
     DCHECK(request_context_);
   }
 
+  blob_storage_host_.reset(
+      new BlobStorageHost(blob_storage_context_->context()));
+
   operation_runner_ = context_->CreateFileSystemOperationRunner();
 }
 
@@ -115,10 +120,7 @@ void FileAPIMessageFilter::OnChannelClosing() {
 
   // Unregister all the blob and stream URLs that are previously registered in
   // this process.
-  for (base::hash_set<std::string>::const_iterator iter = blob_urls_.begin();
-       iter != blob_urls_.end(); ++iter) {
-    blob_storage_context_->controller()->RemoveBlob(GURL(*iter));
-  }
+  blob_storage_host_.reset();
   for (base::hash_set<std::string>::const_iterator iter = stream_urls_.begin();
        iter != stream_urls_.end(); ++iter) {
     stream_context_->registry()->UnregisterStream(GURL(*iter));
@@ -168,6 +170,7 @@ bool FileAPIMessageFilter::OnMessageReceived(
     IPC_MESSAGE_HANDLER(FileSystemHostMsg_Exists, OnExists)
     IPC_MESSAGE_HANDLER(FileSystemHostMsg_ReadDirectory, OnReadDirectory)
     IPC_MESSAGE_HANDLER(FileSystemHostMsg_Write, OnWrite)
+    IPC_MESSAGE_HANDLER(FileSystemHostMsg_WriteDeprecated, OnWriteDeprecated)
     IPC_MESSAGE_HANDLER(FileSystemHostMsg_Truncate, OnTruncate)
     IPC_MESSAGE_HANDLER(FileSystemHostMsg_TouchFile, OnTouchFile)
     IPC_MESSAGE_HANDLER(FileSystemHostMsg_CancelWrite, OnCancel)
@@ -187,8 +190,19 @@ bool FileAPIMessageFilter::OnMessageReceived(
     IPC_MESSAGE_HANDLER(BlobHostMsg_SyncAppendSharedMemory,
                         OnAppendSharedMemoryToBlob)
     IPC_MESSAGE_HANDLER(BlobHostMsg_FinishBuilding, OnFinishBuildingBlob)
-    IPC_MESSAGE_HANDLER(BlobHostMsg_Clone, OnCloneBlob)
-    IPC_MESSAGE_HANDLER(BlobHostMsg_Remove, OnRemoveBlob)
+    IPC_MESSAGE_HANDLER(BlobHostMsg_IncrementRefCount,
+                        OnIncrementBlobRefCount)
+    IPC_MESSAGE_HANDLER(BlobHostMsg_DecrementRefCount,
+                        OnDecrementBlobRefCount)
+    IPC_MESSAGE_HANDLER(BlobHostMsg_RegisterPublicURL,
+                        OnRegisterPublicBlobURL)
+    IPC_MESSAGE_HANDLER(BlobHostMsg_RevokePublicURL, OnRevokePublicBlobURL)
+    IPC_MESSAGE_HANDLER(BlobHostMsg_DeprecatedRegisterBlobURL,
+                        OnDeprecatedRegisterBlobURL)
+    IPC_MESSAGE_HANDLER(BlobHostMsg_DeprecatedRevokeBlobURL,
+                        OnDeprecatedRevokeBlobURL)
+    IPC_MESSAGE_HANDLER(BlobHostMsg_DeprecatedCloneBlobURL,
+                        OnDeprecatedCloneBlobURL)
     IPC_MESSAGE_HANDLER(StreamHostMsg_StartBuilding, OnStartBuildingStream)
     IPC_MESSAGE_HANDLER(StreamHostMsg_AppendBlobDataItem,
                         OnAppendBlobDataItemToStream)
@@ -361,11 +375,21 @@ void FileAPIMessageFilter::OnReadDirectory(
                       this, request_id));
 }
 
-void FileAPIMessageFilter::OnWrite(
+void FileAPIMessageFilter::OnWriteDeprecated(
     int request_id,
     const GURL& path,
     const GURL& blob_url,
     int64 offset) {
+  std::string uuid =
+      blob_storage_context_->context()->LookupUuidFromDeprecatedURL(blob_url);
+  OnWrite(request_id, path, uuid, offset);
+}
+
+void FileAPIMessageFilter::OnWrite(
+    int request_id,
+    const GURL& path,
+    const std::string& blob_uuid,
+    int64 offset) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!request_context_) {
     // We can't write w/o a request context, trying to do so will crash.
@@ -380,8 +404,11 @@ void FileAPIMessageFilter::OnWrite(
     return;
   }
 
+  scoped_ptr<webkit_blob::BlobDataHandle> blob =
+      blob_storage_context_->context()->GetBlobDataFromUUID(blob_uuid);
+
   operations_[request_id] = operation_runner()->Write(
-      request_context_, url, blob_url, offset,
+      request_context_, url, blob.Pass(), offset,
       base::Bind(&FileAPIMessageFilter::DidWrite, this, request_id));
 }
 
@@ -537,39 +564,40 @@ void FileAPIMessageFilter::OnDidReceiveSnapshotFile(int request_id) {
   in_transit_snapshot_files_.erase(request_id);
 }
 
-void FileAPIMessageFilter::OnStartBuildingBlob(const GURL& url) {
+void FileAPIMessageFilter::OnStartBuildingBlob(const std::string& uuid) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  blob_storage_context_->controller()->StartBuildingBlob(url);
-  blob_urls_.insert(url.spec());
+  ignore_result(blob_storage_host_->StartBuildingBlob(uuid));
 }
 
 void FileAPIMessageFilter::OnAppendBlobDataItemToBlob(
-    const GURL& url, const BlobData::Item& item) {
+    const std::string& uuid, const BlobData::Item& item) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (item.type() == BlobData::Item::TYPE_FILE_FILESYSTEM) {
     base::PlatformFileError error;
-    FileSystemURL filesystem_url(context_->CrackURL(item.url()));
+    FileSystemURL filesystem_url(context_->CrackURL(item.filesystem_url()));
     if (!HasPermissionsForFile(filesystem_url,
                                fileapi::kReadFilePermissions, &error)) {
-      OnRemoveBlob(url);
+      ignore_result(blob_storage_host_->CancelBuildingBlob(uuid));
       return;
     }
   }
   if (item.type() == BlobData::Item::TYPE_FILE &&
       !ChildProcessSecurityPolicyImpl::GetInstance()->CanReadFile(
           process_id_, item.path())) {
-    OnRemoveBlob(url);
+    ignore_result(blob_storage_host_->CancelBuildingBlob(uuid));
     return;
   }
   if (item.length() == 0) {
     BadMessageReceived();
     return;
   }
-  blob_storage_context_->controller()->AppendBlobDataItem(url, item);
+  ignore_result(blob_storage_host_->AppendBlobDataItem(uuid, item));
 }
 
 void FileAPIMessageFilter::OnAppendSharedMemoryToBlob(
-    const GURL& url, base::SharedMemoryHandle handle, size_t buffer_size) {
+    const std::string& uuid,
+    base::SharedMemoryHandle handle,
+    size_t buffer_size) {
   DCHECK(base::SharedMemory::IsHandleValid(handle));
   if (!buffer_size) {
     BadMessageReceived();
@@ -581,33 +609,59 @@ void FileAPIMessageFilter::OnAppendSharedMemoryToBlob(
   base::SharedMemory shared_memory(handle, true);
 #endif
   if (!shared_memory.Map(buffer_size)) {
-    OnRemoveBlob(url);
+    ignore_result(blob_storage_host_->CancelBuildingBlob(uuid));
     return;
   }
 
   BlobData::Item item;
   item.SetToSharedBytes(static_cast<char*>(shared_memory.memory()),
                         buffer_size);
-  blob_storage_context_->controller()->AppendBlobDataItem(url, item);
+  ignore_result(blob_storage_host_->AppendBlobDataItem(uuid, item));
 }
 
 void FileAPIMessageFilter::OnFinishBuildingBlob(
-    const GURL& url, const std::string& content_type) {
+    const std::string& uuid, const std::string& content_type) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  ignore_result(blob_storage_host_->FinishBuildingBlob(uuid, content_type));
+  // TODO(michaeln): check return values once blink has migrated, crbug/174200
+}
+
+void FileAPIMessageFilter::OnIncrementBlobRefCount(const std::string& uuid) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  ignore_result(blob_storage_host_->IncrementBlobRefCount(uuid));
+}
+
+void FileAPIMessageFilter::OnDecrementBlobRefCount(const std::string& uuid) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  ignore_result(blob_storage_host_->DecrementBlobRefCount(uuid));
+}
+
+void FileAPIMessageFilter::OnRegisterPublicBlobURL(
+    const GURL& public_url, const std::string& uuid) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  ignore_result(blob_storage_host_->RegisterPublicBlobURL(public_url, uuid));
+}
+
+void FileAPIMessageFilter::OnRevokePublicBlobURL(const GURL& public_url) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  ignore_result(blob_storage_host_->RevokePublicBlobURL(public_url));
+}
+
+void FileAPIMessageFilter::OnDeprecatedRegisterBlobURL(
+    const GURL& url, const std::string& uuid) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  blob_storage_context_->controller()->FinishBuildingBlob(url, content_type);
+  blob_storage_host_->DeprecatedRegisterBlobURL(url, uuid);
 }
 
-void FileAPIMessageFilter::OnCloneBlob(
+void FileAPIMessageFilter::OnDeprecatedCloneBlobURL(
     const GURL& url, const GURL& src_url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  blob_storage_context_->controller()->CloneBlob(url, src_url);
-  blob_urls_.insert(url.spec());
+  blob_storage_host_->DeprecatedCloneBlobURL(url, src_url);
 }
 
-void FileAPIMessageFilter::OnRemoveBlob(const GURL& url) {
+void FileAPIMessageFilter::OnDeprecatedRevokeBlobURL(const GURL& url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  blob_storage_context_->controller()->RemoveBlob(url);
-  blob_urls_.erase(url.spec());
+  blob_storage_host_->DeprecatedRevokeBlobURL(url);
 }
 
 void FileAPIMessageFilter::OnStartBuildingStream(
diff --git a/content/browser/fileapi/fileapi_message_filter.h b/content/browser/fileapi/fileapi_message_filter.h
index 873d010..6a3b231 100644
--- a/content/browser/fileapi/fileapi_message_filter.h
+++ b/content/browser/fileapi/fileapi_message_filter.h
@@ -45,6 +45,7 @@ class URLRequestContextGetter;
 }  // namespace net
 
 namespace webkit_blob {
+class BlobStorageHost;
 class ShareableFileReference;
 }
 
@@ -111,6 +112,11 @@ class CONTENT_EXPORT FileAPIMessageFilter : public BrowserMessageFilter {
   void OnReadDirectory(int request_id, const GURL& path);
   void OnWrite(int request_id,
                const GURL& path,
+               const std::string& blob_uuid,
+               int64 offset);
+  void OnWriteDeprecated(
+               int request_id,
+               const GURL& path,
                const GURL& blob_url,
                int64 offset);
   void OnTruncate(int request_id, const GURL& path, int64 length);
@@ -131,14 +137,26 @@ class CONTENT_EXPORT FileAPIMessageFilter : public BrowserMessageFilter {
 
   // Handlers for BlobHostMsg_ family messages.
 
-  void OnStartBuildingBlob(const GURL& url);
-  void OnAppendBlobDataItemToBlob(
-      const GURL& url, const webkit_blob::BlobData::Item& item);
-  void OnAppendSharedMemoryToBlob(
-      const GURL& url, base::SharedMemoryHandle handle, size_t buffer_size);
-  void OnFinishBuildingBlob(const GURL& url, const std::string& content_type);
-  void OnCloneBlob(const GURL& url, const GURL& src_url);
-  void OnRemoveBlob(const GURL& url);
+  void OnStartBuildingBlob(const std::string& uuid);
+  void OnAppendBlobDataItemToBlob(const std::string& uuid,
+                                  const webkit_blob::BlobData::Item& item);
+  void OnAppendSharedMemoryToBlob(const std::string& uuid,
+                                  base::SharedMemoryHandle handle,
+                                  size_t buffer_size);
+  void OnFinishBuildingBlob(const std::string& uuid,
+                             const std::string& content_type);
+  void OnCancelBuildingBlob(const std::string& uuid);
+  void OnIncrementBlobRefCount(const std::string& uuid);
+  void OnDecrementBlobRefCount(const std::string& uuid);
+  void OnRegisterPublicBlobURL(const GURL& public_url, const std::string& uuid);
+  void OnRevokePublicBlobURL(const GURL& public_url);
+
+  // Extra methods to establish a mapping from old-style blobURLs to uuids,
+  // and to clone them. These won't be here for long, just during a
+  // transition period. See crbug/174200
+  void OnDeprecatedRegisterBlobURL(const GURL& url, const std::string& uuid);
+  void OnDeprecatedCloneBlobURL(const GURL& url, const GURL& existing_url);
+  void OnDeprecatedRevokeBlobURL(const GURL& url);
 
   // Handlers for StreamHostMsg_ family messages.
   //
@@ -225,9 +243,9 @@ class CONTENT_EXPORT FileAPIMessageFilter : public BrowserMessageFilter {
 
   scoped_ptr<fileapi::FileSystemOperationRunner> operation_runner_;
 
-  // Keep track of blob URLs registered in this process. Need to unregister
-  // all of them when the renderer process dies.
-  base::hash_set<std::string> blob_urls_;
+  // Keeps track of blobs used in this process and cleans up
+  // when the renderer process dies.
+  scoped_ptr<webkit_blob::BlobStorageHost> blob_storage_host_;
 
   // Keep track of stream URLs registered in this process. Need to unregister
   // all of them when the renderer process dies.
diff --git a/content/browser/fileapi/fileapi_message_filter_unittest.cc b/content/browser/fileapi/fileapi_message_filter_unittest.cc
index 06b112b..90e422c 100644
--- a/content/browser/fileapi/fileapi_message_filter_unittest.cc
+++ b/content/browser/fileapi/fileapi_message_filter_unittest.cc
@@ -23,7 +23,7 @@
 #include "content/public/test/test_browser_thread.h"
 #include "net/base/io_buffer.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "webkit/browser/blob/blob_storage_controller.h"
+#include "webkit/browser/blob/blob_storage_context.h"
 #include "webkit/browser/fileapi/file_system_context.h"
 #include "webkit/browser/fileapi/mock_file_system_context.h"
 #include "webkit/common/blob/blob_data.h"
@@ -95,34 +95,6 @@ class FileAPIMessageFilterTest : public testing::Test {
   scoped_refptr<FileAPIMessageFilter> filter_;
 };
 
-TEST_F(FileAPIMessageFilterTest, BuildEmptyBlob) {
-  webkit_blob::BlobStorageController* controller =
-      blob_storage_context_->controller();
-
-  const GURL kUrl("blob:foobar");
-  const GURL kDifferentUrl("blob:barfoo");
-
-  EXPECT_EQ(NULL, controller->GetBlobDataFromUrl(kUrl));
-
-  BlobHostMsg_StartBuilding start_message(kUrl);
-  EXPECT_TRUE(InvokeOnMessageReceived(start_message));
-
-  // Blob is still being built. Nothing should be returned.
-  EXPECT_EQ(NULL, controller->GetBlobDataFromUrl(kUrl));
-
-  BlobHostMsg_FinishBuilding finish_message(kUrl, kFakeContentType);
-  EXPECT_TRUE(InvokeOnMessageReceived(finish_message));
-
-  // Now, Blob is built.
-  webkit_blob::BlobData* blob_data = controller->GetBlobDataFromUrl(kUrl);
-  ASSERT_FALSE(blob_data == NULL);
-  EXPECT_EQ(0U, blob_data->items().size());
-  EXPECT_EQ(kFakeContentType, blob_data->content_type());
-
-  // Nothing should be returned for a URL we didn't use.
-  EXPECT_TRUE(controller->GetBlobDataFromUrl(kDifferentUrl) == NULL);
-}
-
 TEST_F(FileAPIMessageFilterTest, CloseChannelWithInflightRequest) {
   scoped_refptr<FileAPIMessageFilter> filter(
       new FileAPIMessageFilter(
@@ -190,14 +162,10 @@ TEST_F(FileAPIMessageFilterTest, MultipleFilters) {
 TEST_F(FileAPIMessageFilterTest, BuildEmptyStream) {
   StreamRegistry* stream_registry = stream_context_->registry();
 
-  webkit_blob::BlobStorageController* blob_controller =
-      blob_storage_context_->controller();
-
   const GURL kUrl(kFakeBlobInternalUrlSpec);
   const GURL kDifferentUrl("blob:barfoo");
 
   EXPECT_EQ(NULL, stream_registry->GetStream(kUrl).get());
-  EXPECT_EQ(NULL, blob_controller->GetBlobDataFromUrl(kUrl));
 
   StreamHostMsg_StartBuilding start_message(kUrl, kFakeContentType);
   EXPECT_TRUE(InvokeOnMessageReceived(start_message));
@@ -217,9 +185,6 @@ TEST_F(FileAPIMessageFilterTest, BuildEmptyStream) {
   StreamHostMsg_FinishBuilding finish_message(kUrl);
   EXPECT_TRUE(InvokeOnMessageReceived(finish_message));
 
-  // Blob controller shouldn't be affected.
-  EXPECT_EQ(NULL, blob_controller->GetBlobDataFromUrl(kUrl));
-
   stream = stream_registry->GetStream(kUrl);
   ASSERT_FALSE(stream.get() == NULL);
   EXPECT_EQ(Stream::STREAM_EMPTY,
diff --git a/content/browser/loader/resource_dispatcher_host_impl.cc b/content/browser/loader/resource_dispatcher_host_impl.cc
index 2a4ad9a..22912ed 100644
--- a/content/browser/loader/resource_dispatcher_host_impl.cc
+++ b/content/browser/loader/resource_dispatcher_host_impl.cc
@@ -87,7 +87,10 @@
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_job_factory.h"
 #include "webkit/browser/appcache/appcache_interceptor.h"
-#include "webkit/browser/blob/blob_storage_controller.h"
+#include "webkit/common/blob/blob_data.h"
+#include "webkit/browser/blob/blob_data_handle.h"
+#include "webkit/browser/blob/blob_storage_context.h"
+#include "webkit/browser/blob/blob_url_request_job_factory.h"
 #include "webkit/browser/fileapi/file_permission_policy.h"
 #include "webkit/browser/fileapi/file_system_context.h"
 #include "webkit/common/appcache/appcache_interfaces.h"
@@ -216,11 +219,12 @@ bool ShouldServiceRequest(int process_type,
         return false;
       }
       if (iter->type() == ResourceRequestBody::Element::TYPE_FILE_FILESYSTEM) {
-        fileapi::FileSystemURL url = file_system_context->CrackURL(iter->url());
+        fileapi::FileSystemURL url =
+            file_system_context->CrackURL(iter->filesystem_url());
         if (!policy->HasPermissionsForFileSystemFile(
                 child_id, url, fileapi::kReadFilePermissions)) {
           NOTREACHED() << "Denied unauthorized upload of "
-                       << iter->url().spec();
+                       << iter->filesystem_url().spec();
           return false;
         }
       }
@@ -502,6 +506,14 @@ net::Error ResourceDispatcherHostImpl::BeginDownload(
       CreateRequestInfo(child_id, route_id, true, context);
   extra_info->AssociateWithRequest(request.get());  // Request takes ownership.
 
+  if (request->url().SchemeIs(chrome::kBlobScheme)) {
+    ChromeBlobStorageContext* blob_context =
+        GetChromeBlobStorageContextForResourceContext(context);
+    webkit_blob::BlobProtocolHandler::SetRequestedBlobDataHandle(
+        request.get(),
+        blob_context->context()->GetBlobDataFromPublicURL(request->url()));
+  }
+
   // From this point forward, the |DownloadResourceHandler| is responsible for
   // |started_callback|.
   scoped_ptr<ResourceHandler> handler(
@@ -982,7 +994,7 @@ void ResourceDispatcherHostImpl::BeginRequest(
   if (request_data.request_body.get()) {
     request->set_upload(UploadDataStreamBuilder::Build(
         request_data.request_body.get(),
-        filter_->blob_storage_context()->controller(),
+        filter_->blob_storage_context()->context(),
         filter_->file_system_context(),
         BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE)
             .get()));
@@ -1017,9 +1029,10 @@ void ResourceDispatcherHostImpl::BeginRequest(
   if (request->url().SchemeIs(chrome::kBlobScheme)) {
     // Hang on to a reference to ensure the blob is not released prior
     // to the job being started.
-    extra_info->set_requested_blob_data(
-        filter_->blob_storage_context()->controller()->
-            GetBlobDataFromUrl(request->url()));
+    webkit_blob::BlobProtocolHandler::SetRequestedBlobDataHandle(
+        request,
+        filter_->blob_storage_context()->context()->
+            GetBlobDataFromPublicURL(request->url()));
   }
 
   // Have the appcache associate its extra info with the request.
diff --git a/content/browser/loader/resource_request_info_impl.cc b/content/browser/loader/resource_request_info_impl.cc
index 51e39ff..e7b2828 100644
--- a/content/browser/loader/resource_request_info_impl.cc
+++ b/content/browser/loader/resource_request_info_impl.cc
@@ -9,7 +9,6 @@
 #include "content/common/net/url_request_user_data.h"
 #include "content/public/browser/global_request_id.h"
 #include "net/url_request/url_request.h"
-#include "webkit/common/blob/blob_data.h"
 
 namespace content {
 
@@ -226,9 +225,4 @@ GlobalRoutingID ResourceRequestInfoImpl::GetGlobalRoutingID() const {
   return GlobalRoutingID(child_id_, route_id_);
 }
 
-void ResourceRequestInfoImpl::set_requested_blob_data(
-    webkit_blob::BlobData* data) {
-  requested_blob_data_ = data;
-}
-
 }  // namespace content
diff --git a/content/browser/loader/resource_request_info_impl.h b/content/browser/loader/resource_request_info_impl.h
index d9958653..e615116 100644
--- a/content/browser/loader/resource_request_info_impl.h
+++ b/content/browser/loader/resource_request_info_impl.h
@@ -16,10 +16,6 @@
 #include "net/base/load_states.h"
 #include "webkit/common/resource_type.h"
 
-namespace webkit_blob {
-class BlobData;
-}
-
 namespace content {
 class CrossSiteResourceHandler;
 class ResourceContext;
@@ -116,13 +112,6 @@ class ResourceRequestInfoImpl : public ResourceRequestInfo,
   int memory_cost() const { return memory_cost_; }
   void set_memory_cost(int cost) { memory_cost_ = cost; }
 
-  // We hold a reference to the requested blob data to ensure it doesn't
-  // get finally released prior to the net::URLRequestJob being started.
-  webkit_blob::BlobData* requested_blob_data() const {
-    return requested_blob_data_.get();
-  }
-  void set_requested_blob_data(webkit_blob::BlobData* data);
-
  private:
   // Non-owning, may be NULL.
   CrossSiteResourceHandler* cross_site_handler_;
@@ -144,7 +133,6 @@ class ResourceRequestInfoImpl : public ResourceRequestInfo,
   ResourceType::Type resource_type_;
   PageTransition transition_type_;
   int memory_cost_;
-  scoped_refptr<webkit_blob::BlobData> requested_blob_data_;
   WebKit::WebReferrerPolicy referrer_policy_;
   ResourceContext* context_;
   bool is_async_;
diff --git a/content/browser/loader/upload_data_stream_builder.cc b/content/browser/loader/upload_data_stream_builder.cc
index 1a7dfc3..c22a8a8 100644
--- a/content/browser/loader/upload_data_stream_builder.cc
+++ b/content/browser/loader/upload_data_stream_builder.cc
@@ -8,12 +8,14 @@
 #include "net/base/upload_bytes_element_reader.h"
 #include "net/base/upload_data_stream.h"
 #include "net/base/upload_file_element_reader.h"
-#include "webkit/browser/blob/blob_storage_controller.h"
+#include "webkit/browser/blob/blob_data_handle.h"
+#include "webkit/browser/blob/blob_storage_context.h"
 #include "webkit/browser/fileapi/upload_file_system_file_element_reader.h"
 #include "webkit/common/resource_request_body.h"
 
 using webkit_blob::BlobData;
-using webkit_blob::BlobStorageController;
+using webkit_blob::BlobDataHandle;
+using webkit_blob::BlobStorageContext;
 using webkit_glue::ResourceRequestBody;
 
 namespace content {
@@ -64,49 +66,51 @@ class FileElementReader : public net::UploadFileElementReader {
 
 void ResolveBlobReference(
     ResourceRequestBody* body,
-    webkit_blob::BlobStorageController* blob_controller,
-    const GURL& blob_url,
+    webkit_blob::BlobStorageContext* blob_context,
+    const ResourceRequestBody::Element& element,
     std::vector<const ResourceRequestBody::Element*>* resolved_elements) {
-  DCHECK(blob_controller);
-  BlobData* blob_data = blob_controller->GetBlobDataFromUrl(blob_url);
-  DCHECK(blob_data);
-  if (!blob_data)
+  DCHECK(blob_context);
+  std::string uuid = element.blob_uuid();
+  if (uuid.empty())
+    uuid = blob_context->LookupUuidFromDeprecatedURL(element.blob_url());
+  scoped_ptr<webkit_blob::BlobDataHandle> handle =
+      blob_context->GetBlobDataFromUUID(uuid);
+  DCHECK(handle);
+  if (!handle)
     return;
 
   // If there is no element in the referred blob data, just return.
-  if (blob_data->items().empty())
+  if (handle->data()->items().empty())
     return;
 
-  // Ensure the blob and any attached shareable files survive until
-  // upload completion.
-  body->SetUserData(blob_data, new base::UserDataAdapter<BlobData>(blob_data));
-
-  // Append the elements in the referred blob data.
-  for (size_t i = 0; i < blob_data->items().size(); ++i) {
-    const BlobData::Item& item = blob_data->items().at(i);
+  // Append the elements in the referenced blob data.
+  for (size_t i = 0; i < handle->data()->items().size(); ++i) {
+    const BlobData::Item& item = handle->data()->items().at(i);
     DCHECK_NE(BlobData::Item::TYPE_BLOB, item.type());
     resolved_elements->push_back(&item);
   }
+
+  // Ensure the blob and any attached shareable files survive until
+  // upload completion. The |body| takes ownership of |handle|.
+  const void* key = handle.get();
+  body->SetUserData(key, handle.release());
 }
 
 }  // namespace
 
 scoped_ptr<net::UploadDataStream> UploadDataStreamBuilder::Build(
     ResourceRequestBody* body,
-    BlobStorageController* blob_controller,
+    BlobStorageContext* blob_context,
     fileapi::FileSystemContext* file_system_context,
     base::TaskRunner* file_task_runner) {
   // Resolve all blob elements.
   std::vector<const ResourceRequestBody::Element*> resolved_elements;
   for (size_t i = 0; i < body->elements()->size(); ++i) {
     const ResourceRequestBody::Element& element = (*body->elements())[i];
-    if (element.type() == ResourceRequestBody::Element::TYPE_BLOB) {
-      ResolveBlobReference(body, blob_controller, element.url(),
-                           &resolved_elements);
-    } else {
-      // No need to resolve, just append the element.
+    if (element.type() == ResourceRequestBody::Element::TYPE_BLOB)
+      ResolveBlobReference(body, blob_context, element, &resolved_elements);
+    else
       resolved_elements.push_back(&element);
-    }
   }
 
   ScopedVector<net::UploadElementReader> element_readers;
@@ -124,7 +128,7 @@ scoped_ptr<net::UploadDataStream> UploadDataStreamBuilder::Build(
         element_readers.push_back(
             new fileapi::UploadFileSystemFileElementReader(
                 file_system_context,
-                element.url(),
+                element.filesystem_url(),
                 element.offset(),
                 element.length(),
                 element.expected_modification_time()));
diff --git a/content/browser/loader/upload_data_stream_builder.h b/content/browser/loader/upload_data_stream_builder.h
index b511546..e2b6ce3 100644
--- a/content/browser/loader/upload_data_stream_builder.h
+++ b/content/browser/loader/upload_data_stream_builder.h
@@ -21,7 +21,7 @@ class UploadDataStream;
 }
 
 namespace webkit_blob {
-class BlobStorageController;
+class BlobStorageContext;
 }
 
 namespace webkit_glue {
@@ -34,7 +34,7 @@ class CONTENT_EXPORT UploadDataStreamBuilder {
  public:
   // Creates a new UploadDataStream from this request body.
   //
-  // This also resolves any blob references using the given |blob_controller|
+  // This also resolves any blob references using the given |blob_context|
   // and binds those blob references to the ResourceRequestBody ensuring that
   // the blob data remains valid for the lifetime of the ResourceRequestBody
   // object.
@@ -44,7 +44,7 @@ class CONTENT_EXPORT UploadDataStreamBuilder {
   // when the data gets uploaded.
   static scoped_ptr<net::UploadDataStream> Build(
       webkit_glue::ResourceRequestBody* body,
-      webkit_blob::BlobStorageController* blob_controller,
+      webkit_blob::BlobStorageContext* blob_context,
       fileapi::FileSystemContext* file_system_context,
       base::TaskRunner* file_task_runner);
 };
diff --git a/content/browser/loader/upload_data_stream_builder_unittest.cc b/content/browser/loader/upload_data_stream_builder_unittest.cc
index 9972418..4c9661c 100644
--- a/content/browser/loader/upload_data_stream_builder_unittest.cc
+++ b/content/browser/loader/upload_data_stream_builder_unittest.cc
@@ -16,11 +16,12 @@
 #include "net/base/upload_file_element_reader.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
-#include "webkit/browser/blob/blob_storage_controller.h"
+#include "webkit/browser/blob/blob_storage_context.h"
 #include "webkit/common/resource_request_body.h"
 
 using webkit_blob::BlobData;
-using webkit_blob::BlobStorageController;
+using webkit_blob::BlobDataHandle;
+using webkit_blob::BlobStorageContext;
 using webkit_glue::ResourceRequestBody;
 
 namespace content {
@@ -98,24 +99,20 @@ TEST(UploadDataStreamBuilderTest, ResolveBlobAndCreateUploadDataStream) {
   base::Time::FromString("Tue, 15 Nov 1994, 12:45:26 GMT", &time1);
   base::Time::FromString("Mon, 14 Nov 1994, 11:30:49 GMT", &time2);
 
-  BlobStorageController blob_storage_controller;
-  scoped_refptr<BlobData> blob_data(new BlobData());
+  BlobStorageContext blob_storage_context;
 
-  GURL blob_url0("blob://url_0");
-  blob_storage_controller.AddFinishedBlob(blob_url0, blob_data.get());
+  const std::string blob_id0("id-0");
+  scoped_refptr<BlobData> blob_data(new BlobData(blob_id0));
+  scoped_ptr<BlobDataHandle> handle1 =
+      blob_storage_context.AddFinishedBlob(blob_data);
 
+  const std::string blob_id1("id-1");
+  blob_data = new BlobData(blob_id1);
   blob_data->AppendData("BlobData");
   blob_data->AppendFile(
       base::FilePath(FILE_PATH_LITERAL("BlobFile.txt")), 0, 20, time1);
-
-  GURL blob_url1("blob://url_1");
-  blob_storage_controller.AddFinishedBlob(blob_url1, blob_data.get());
-
-  GURL blob_url2("blob://url_2");
-  blob_storage_controller.CloneBlob(blob_url2, blob_url1);
-
-  GURL blob_url3("blob://url_3");
-  blob_storage_controller.CloneBlob(blob_url3, blob_url2);
+  scoped_ptr<BlobDataHandle> handle2 =
+      blob_storage_context.AddFinishedBlob(blob_data);
 
   // Setup upload data elements for comparison.
   ResourceRequestBody::Element blob_element1, blob_element2;
@@ -144,7 +141,7 @@ TEST(UploadDataStreamBuilderTest, ResolveBlobAndCreateUploadDataStream) {
 
   scoped_ptr<net::UploadDataStream> upload(
       UploadDataStreamBuilder::Build(request_body.get(),
-                                     &blob_storage_controller,
+                                     &blob_storage_context,
                                      NULL,
                                      base::MessageLoopProxy::current().get()));
 
@@ -154,22 +151,22 @@ TEST(UploadDataStreamBuilderTest, ResolveBlobAndCreateUploadDataStream) {
 
   // Test having only one blob reference that refers to empty blob data.
   request_body = new ResourceRequestBody();
-  request_body->AppendBlob(blob_url0);
+  request_body->AppendBlob(blob_id0);
 
   upload =
       UploadDataStreamBuilder::Build(request_body.get(),
-                                     &blob_storage_controller,
+                                     &blob_storage_context,
                                      NULL,
                                      base::MessageLoopProxy::current().get());
   ASSERT_EQ(0U, upload->element_readers().size());
 
   // Test having only one blob reference.
   request_body = new ResourceRequestBody();
-  request_body->AppendBlob(blob_url1);
+  request_body->AppendBlob(blob_id1);
 
   upload =
       UploadDataStreamBuilder::Build(request_body.get(),
-                                     &blob_storage_controller,
+                                     &blob_storage_context,
                                      NULL,
                                      base::MessageLoopProxy::current().get());
   ASSERT_EQ(2U, upload->element_readers().size());
@@ -178,7 +175,7 @@ TEST(UploadDataStreamBuilderTest, ResolveBlobAndCreateUploadDataStream) {
 
   // Test having one blob reference at the beginning.
   request_body = new ResourceRequestBody();
-  request_body->AppendBlob(blob_url1);
+  request_body->AppendBlob(blob_id1);
   request_body->AppendBytes(upload_element1.bytes(), upload_element1.length());
   request_body->AppendFileRange(upload_element2.path(),
                                 upload_element2.offset(),
@@ -187,7 +184,7 @@ TEST(UploadDataStreamBuilderTest, ResolveBlobAndCreateUploadDataStream) {
 
   upload =
       UploadDataStreamBuilder::Build(request_body.get(),
-                                     &blob_storage_controller,
+                                     &blob_storage_context,
                                      NULL,
                                      base::MessageLoopProxy::current().get());
   ASSERT_EQ(4U, upload->element_readers().size());
@@ -203,11 +200,11 @@ TEST(UploadDataStreamBuilderTest, ResolveBlobAndCreateUploadDataStream) {
                                 upload_element2.offset(),
                                 upload_element2.length(),
                                 upload_element2.expected_modification_time());
-  request_body->AppendBlob(blob_url1);
+  request_body->AppendBlob(blob_id1);
 
   upload =
       UploadDataStreamBuilder::Build(request_body.get(),
-                                     &blob_storage_controller,
+                                     &blob_storage_context,
                                      NULL,
                                      base::MessageLoopProxy::current().get());
   ASSERT_EQ(4U, upload->element_readers().size());
@@ -219,7 +216,7 @@ TEST(UploadDataStreamBuilderTest, ResolveBlobAndCreateUploadDataStream) {
   // Test having one blob reference in the middle.
   request_body = new ResourceRequestBody();
   request_body->AppendBytes(upload_element1.bytes(), upload_element1.length());
-  request_body->AppendBlob(blob_url1);
+  request_body->AppendBlob(blob_id1);
   request_body->AppendFileRange(upload_element2.path(),
                                 upload_element2.offset(),
                                 upload_element2.length(),
@@ -227,7 +224,7 @@ TEST(UploadDataStreamBuilderTest, ResolveBlobAndCreateUploadDataStream) {
 
   upload =
       UploadDataStreamBuilder::Build(request_body.get(),
-                                     &blob_storage_controller,
+                                     &blob_storage_context,
                                      NULL,
                                      base::MessageLoopProxy::current().get());
   ASSERT_EQ(4U, upload->element_readers().size());
@@ -238,10 +235,10 @@ TEST(UploadDataStreamBuilderTest, ResolveBlobAndCreateUploadDataStream) {
 
   // Test having multiple blob references.
   request_body = new ResourceRequestBody();
-  request_body->AppendBlob(blob_url1);
+  request_body->AppendBlob(blob_id1);
   request_body->AppendBytes(upload_element1.bytes(), upload_element1.length());
-  request_body->AppendBlob(blob_url2);
-  request_body->AppendBlob(blob_url3);
+  request_body->AppendBlob(blob_id1);
+  request_body->AppendBlob(blob_id1);
   request_body->AppendFileRange(upload_element2.path(),
                                 upload_element2.offset(),
                                 upload_element2.length(),
@@ -249,7 +246,7 @@ TEST(UploadDataStreamBuilderTest, ResolveBlobAndCreateUploadDataStream) {
 
   upload =
       UploadDataStreamBuilder::Build(request_body.get(),
-                                     &blob_storage_controller,
+                                     &blob_storage_context,
                                      NULL,
                                      base::MessageLoopProxy::current().get());
   ASSERT_EQ(8U, upload->element_readers().size());
diff --git a/content/browser/net/view_blob_internals_job_factory.cc b/content/browser/net/view_blob_internals_job_factory.cc
index e877a41..85356e5 100644
--- a/content/browser/net/view_blob_internals_job_factory.cc
+++ b/content/browser/net/view_blob_internals_job_factory.cc
@@ -21,9 +21,9 @@ bool ViewBlobInternalsJobFactory::IsSupportedURL(const GURL& url) {
 net::URLRequestJob* ViewBlobInternalsJobFactory::CreateJobForRequest(
     net::URLRequest* request,
     net::NetworkDelegate* network_delegate,
-    webkit_blob::BlobStorageController* blob_storage_controller) {
+    webkit_blob::BlobStorageContext* blob_storage_context) {
   return new webkit_blob::ViewBlobInternalsJob(
-      request, network_delegate, blob_storage_controller);
+      request, network_delegate, blob_storage_context);
 }
 
 }  // namespace content
diff --git a/content/browser/net/view_blob_internals_job_factory.h b/content/browser/net/view_blob_internals_job_factory.h
index 0843e06..4d4b60a 100644
--- a/content/browser/net/view_blob_internals_job_factory.h
+++ b/content/browser/net/view_blob_internals_job_factory.h
@@ -11,7 +11,7 @@ class URLRequest;
 class URLRequestJob;
 }  // namespace net
 namespace webkit_blob {
-class BlobStorageController;
+class BlobStorageContext;
 }  // webkit_blob
 
 class GURL;
@@ -24,7 +24,7 @@ class ViewBlobInternalsJobFactory {
   static net::URLRequestJob* CreateJobForRequest(
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate,
-      webkit_blob::BlobStorageController* blob_storage_controller);
+      webkit_blob::BlobStorageContext* blob_storage_context);
 };
 
 }  // namespace content
diff --git a/content/browser/storage_partition_impl_map.cc b/content/browser/storage_partition_impl_map.cc
index c5721ae..d02542c 100644
--- a/content/browser/storage_partition_impl_map.cc
+++ b/content/browser/storage_partition_impl_map.cc
@@ -34,96 +34,52 @@
 #include "crypto/sha2.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
+#include "webkit/browser/blob/blob_storage_context.h"
 #include "webkit/browser/blob/blob_url_request_job_factory.h"
 #include "webkit/browser/fileapi/file_system_url_request_job_factory.h"
 #include "webkit/common/blob/blob_data.h"
 
 using appcache::AppCacheService;
 using fileapi::FileSystemContext;
-using webkit_blob::BlobStorageController;
+using webkit_blob::BlobStorageContext;
 
 namespace content {
 
 namespace {
 
-class BlobProtocolHandler : public net::URLRequestJobFactory::ProtocolHandler {
+// A derivative that knows about Streams too.
+class BlobProtocolHandler : public webkit_blob::BlobProtocolHandler {
  public:
   BlobProtocolHandler(ChromeBlobStorageContext* blob_storage_context,
                       StreamContext* stream_context,
                       fileapi::FileSystemContext* file_system_context)
-      : blob_storage_context_(blob_storage_context),
+      : webkit_blob::BlobProtocolHandler(
+            file_system_context,
+            BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE)
+                .get()),
+        blob_storage_context_(blob_storage_context),
         stream_context_(stream_context),
-        file_system_context_(file_system_context) {}
+        file_system_context_(file_system_context) {
+  }
 
-  virtual ~BlobProtocolHandler() {}
+  virtual ~BlobProtocolHandler() {
+  }
 
   virtual net::URLRequestJob* MaybeCreateJob(
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate) const OVERRIDE {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-    if (!webkit_blob_protocol_handler_impl_) {
-      webkit_blob_protocol_handler_impl_.reset(
-          new WebKitBlobProtocolHandlerImpl(blob_storage_context_->controller(),
-                                            stream_context_.get(),
-                                            file_system_context_.get()));
-    }
-    return webkit_blob_protocol_handler_impl_->MaybeCreateJob(request,
-                                                              network_delegate);
+    scoped_refptr<Stream> stream =
+        stream_context_->registry()->GetStream(request->url());
+    if (stream.get())
+      return new StreamURLRequestJob(request, network_delegate, stream);
+    return webkit_blob::BlobProtocolHandler::MaybeCreateJob(
+        request, network_delegate);
   }
 
  private:
-  // An implementation of webkit_blob::BlobProtocolHandler that gets
-  // the BlobData from ResourceRequestInfoImpl.
-  class WebKitBlobProtocolHandlerImpl
-      : public webkit_blob::BlobProtocolHandler {
-   public:
-    WebKitBlobProtocolHandlerImpl(
-        webkit_blob::BlobStorageController* blob_storage_controller,
-        StreamContext* stream_context,
-        fileapi::FileSystemContext* file_system_context)
-        : webkit_blob::BlobProtocolHandler(
-              blob_storage_controller,
-              file_system_context,
-              BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE)
-                  .get()),
-          stream_context_(stream_context) {}
-
-    virtual ~WebKitBlobProtocolHandlerImpl() {}
-
-    virtual net::URLRequestJob* MaybeCreateJob(
-        net::URLRequest* request,
-        net::NetworkDelegate* network_delegate) const OVERRIDE {
-      scoped_refptr<Stream> stream =
-          stream_context_->registry()->GetStream(request->url());
-      if (stream.get())
-        return new StreamURLRequestJob(request, network_delegate, stream);
-
-      return webkit_blob::BlobProtocolHandler::MaybeCreateJob(
-          request, network_delegate);
-    }
-
-   private:
-    // webkit_blob::BlobProtocolHandler implementation.
-    virtual scoped_refptr<webkit_blob::BlobData>
-        LookupBlobData(net::URLRequest* request) const OVERRIDE {
-      const ResourceRequestInfoImpl* info =
-          ResourceRequestInfoImpl::ForRequest(request);
-      if (!info)
-        return NULL;
-      return info->requested_blob_data();
-    }
-
-    const scoped_refptr<StreamContext> stream_context_;
-    DISALLOW_COPY_AND_ASSIGN(WebKitBlobProtocolHandlerImpl);
-  };
-
   const scoped_refptr<ChromeBlobStorageContext> blob_storage_context_;
   const scoped_refptr<StreamContext> stream_context_;
   const scoped_refptr<fileapi::FileSystemContext> file_system_context_;
-
-  mutable scoped_ptr<WebKitBlobProtocolHandlerImpl>
-  webkit_blob_protocol_handler_impl_;
-
   DISALLOW_COPY_AND_ASSIGN(BlobProtocolHandler);
 };
 
diff --git a/content/browser/webui/url_data_manager_backend.cc b/content/browser/webui/url_data_manager_backend.cc
index 7c4c77b..1bcbdb7 100644
--- a/content/browser/webui/url_data_manager_backend.cc
+++ b/content/browser/webui/url_data_manager_backend.cc
@@ -388,7 +388,7 @@ class ChromeProtocolHandler
     // 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_context_->controller());
+          request, network_delegate, blob_storage_context_->context());
     }
 
 #if defined(USE_TCMALLOC)