WIP POC blob transport over mojo

content/browser/blob_storage/chrome_blob_storage_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/browser/blob_storage/chrome_blob_storage_context.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/file.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/guid.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/task_runner.h"
 #include "base/task_scheduler/post_task.h"
 #include "content/browser/resource_context_impl.h"
 #include "content/common/resource_request_body_impl.h"
 #include "content/public/browser/blob_handle.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "storage/browser/blob/blob_data_builder.h"
 #include "storage/browser/blob/blob_data_handle.h"
 #include "storage/browser/blob/blob_memory_controller.h"
+#include "storage/browser/blob/blob_registry_impl.h"
 #include "storage/browser/blob/blob_storage_context.h"
 
 using base::FilePath;
 using base::UserDataAdapter;
 using storage::BlobStorageContext;
 
 namespace content {
 
 namespace {
 const FilePath::CharType kBlobStorageContextKeyName[] =
@@ skipping 87 matching lines @@
   return UserDataAdapter<ChromeBlobStorageContext>::Get(
       context, kBlobStorageContextKeyName);
 }
 
 void ChromeBlobStorageContext::InitializeOnIOThread(
     FilePath blob_storage_dir,
     scoped_refptr<base::TaskRunner> file_task_runner) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   context_.reset(new BlobStorageContext(std::move(blob_storage_dir),
                                         std::move(file_task_runner)));
+  blob_registry_ = base::MakeUnique<storage::BlobRegistryImpl>(context_.get());
   // Signal the BlobMemoryController when it's appropriate to calculate its
   // storage limits.
   BrowserThread::PostAfterStartupTask(
       FROM_HERE, BrowserThread::GetTaskRunnerForThread(BrowserThread::IO),
       base::Bind(&storage::BlobMemoryController::CalculateBlobStorageLimits,
                  context_->mutable_memory_controller()->GetWeakPtr()));
 }
 
 std::unique_ptr<BlobHandle> ChromeBlobStorageContext::CreateMemoryBackedBlob(
     const char* data,
@@ skipping 28 matching lines @@
   std::unique_ptr<storage::BlobDataHandle> blob_data_handle =
       context_->AddFinishedBlob(&blob_data_builder);
   if (!blob_data_handle)
     return std::unique_ptr<BlobHandle>();
 
   std::unique_ptr<BlobHandle> blob_handle(
       new BlobHandleImpl(std::move(blob_data_handle)));
   return blob_handle;
 }
 
+void ChromeBlobStorageContext::BindBlobRegistry(
+    const service_manager::BindSourceInfo& source_info,
+    storage::mojom::BlobRegistryRequest request) {
+  blob_registry_->Bind(source_info, std::move(request));
+}
+
 ChromeBlobStorageContext::~ChromeBlobStorageContext() {}
 
 void ChromeBlobStorageContext::DeleteOnCorrectThread() const {
   if (BrowserThread::IsMessageLoopValid(BrowserThread::IO) &&
       !BrowserThread::CurrentlyOn(BrowserThread::IO)) {
     BrowserThread::DeleteSoon(BrowserThread::IO, FROM_HERE, this);
     return;
   }
   delete this;
 }
@@ skipping 21 matching lines @@
     if (!handle)
       continue;
     // 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, std::move(handle));
   }
 }
 
 }  // namespace content