[WIP] Hack on Blob mojom

content/child/blob_storage/blob_transport_controller.cc

 // Copyright 2015 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/child/blob_storage/blob_transport_controller.h"
 
+#include <algorithm>
 #include <limits>
 #include <memory>
+#include <set>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/files/file.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/shared_memory.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/optional.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/task_runner.h"
 #include "base/task_runner_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "content/child/blob_storage/blob_consolidation.h"
 #include "content/child/child_process.h"
 #include "content/child/thread_safe_sender.h"
 #include "content/common/fileapi/webblob_messages.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_sender.h"
+#include "ipc/ipc_sync_message_filter.h"
 #include "storage/common/blob_storage/blob_item_bytes_request.h"
 #include "storage/common/blob_storage/blob_item_bytes_response.h"
 #include "storage/common/data_element.h"
 #include "third_party/WebKit/public/platform/Platform.h"
 
 using base::File;
 using base::SharedMemory;
 using base::SharedMemoryHandle;
 using storage::BlobItemBytesRequest;
 using storage::BlobItemBytesResponse;
@@ skipping 117 matching lines @@
     scoped_refptr<BlobConsolidation> consolidation,
     scoped_refptr<ThreadSafeSender> sender,
     base::SingleThreadTaskRunner* io_runner,
     scoped_refptr<base::SingleThreadTaskRunner> main_runner) {
   if (main_runner->BelongsToCurrentThread()) {
     IncChildProcessRefCount();
   } else {
     main_runner->PostTask(FROM_HERE, base::Bind(&IncChildProcessRefCount));
   }
 
-  std::vector<storage::DataElement> descriptions;
-  std::set<std::string> referenced_blobs = consolidation->referenced_blobs();
-  BlobTransportController::GetDescriptions(
-      consolidation.get(), kBlobStorageIPCThresholdBytes, &descriptions);
-  // I post the task first to make sure that we store our consolidation before
-  // we get a request back from the browser.
   io_runner->PostTask(
       FROM_HERE,
       base::Bind(&BlobTransportController::StoreBlobDataForRequests,
                  base::Unretained(BlobTransportController::GetInstance()), uuid,
-                 base::Passed(std::move(consolidation)),
+                 content_type, base::Passed(std::move(consolidation)),
+                 sender->sync_message_filter(),
                  base::Passed(std::move(main_runner))));
-  // TODO(dmurph): Merge register and start messages.
-  sender->Send(new BlobStorageMsg_RegisterBlobUUID(uuid, content_type, "",
-                                                   referenced_blobs));
-  sender->Send(new BlobStorageMsg_StartBuildingBlob(uuid, descriptions));
 }
 
 void BlobTransportController::OnMemoryRequest(
     const std::string& uuid,
     const std::vector<storage::BlobItemBytesRequest>& requests,
     std::vector<base::SharedMemoryHandle>* memory_handles,
     const std::vector<IPC::PlatformFileForTransit>& file_handles,
     base::TaskRunner* file_runner,
     IPC::Sender* sender) {
   std::vector<BlobItemBytesResponse> responses;
@@ skipping 98 matching lines @@
         base::Bind(&WriteDiskRequests, make_scoped_refptr(consolidation),
                    base::Passed(&file_requests), file_handles),
         base::Bind(&BlobTransportController::OnFileWriteComplete,
                    weak_factory_.GetWeakPtr(), sender, uuid));
   }
 
   if (!responses.empty())
     sender->Send(new BlobStorageMsg_MemoryItemResponse(uuid, responses));
 }
 
-void BlobTransportController::OnCancel(
+void BlobTransportController::OnBuildBlobComplete(
     const std::string& uuid,
-    storage::IPCBlobCreationCancelCode code) {
-  DVLOG(1) << "Received blob cancel for blob " << uuid
-           << " with code: " << static_cast<int>(code);
-  ReleaseBlobConsolidation(uuid);
-}
-
-void BlobTransportController::OnDone(const std::string& uuid) {
-  ReleaseBlobConsolidation(uuid);
+    mojom::BlobAssociatedPtr blob,
+    mojom::BlobCreationCancelCode cancel_code) {
+  if (blob) {
+    ReleaseBlobConsolidation(uuid);
+    blob_proxies_.insert(uuid, std::move(blob));
+  } else {
+    DVLOG(1) << "Received blob cancel for blob " << uuid
+             << " with code: " << static_cast<int>(code);
+    ReleaseBlobConsolidation(uuid);
+  }
 }
 
 void BlobTransportController::CancelAllBlobTransfers() {
   weak_factory_.InvalidateWeakPtrs();
   if (!blob_storage_.empty() && main_thread_runner_) {
     main_thread_runner_->PostTask(
         FROM_HERE,
         base::Bind(&DecChildProcessRefCountTimes, blob_storage_.size()));
   }
   main_thread_runner_ = nullptr;
@@ skipping 68 matching lines @@
   if (!result.first.empty()) {
     sender->Send(new BlobStorageMsg_MemoryItemResponse(uuid, result.first));
     return;
   }
   sender->Send(new BlobStorageMsg_CancelBuildingBlob(uuid, result.second));
   ReleaseBlobConsolidation(uuid);
 }
 
 void BlobTransportController::StoreBlobDataForRequests(
     const std::string& uuid,
+    const std::string& content_type,
     scoped_refptr<BlobConsolidation> consolidation,
+    scoped_refptr<IPC::SyncMessageFilter> sync_message_filter,
     scoped_refptr<base::SingleThreadTaskRunner> main_runner) {
   if (!main_thread_runner_.get()) {
+    DCHECK(!blob_factory_.is_bound());
     main_thread_runner_ = std::move(main_runner);
+    sync_message_filter->GetRemoteAssociatedInterface(&blob_factory_);
   }
+
+  std::set<std::string> referenced_blob_set = consolidation->referenced_blobs();
+  std::vector<std::string> referenced_blobs;
+  std::copy(referenced_blob_set.begin(), referenced_blob_set.end(),
+            std::back_inserter(referenced_blobs));
+
+  std::vector<storage::DataElement> descriptions;
+  BlobTransportController::GetDescriptions(
+      consolidation.get(), kBlobStorageIPCThresholdBytes, &descriptions);
+
+  blob_factory_->BuildBlob(
+      uuid, content_type, "", referenced_blobs, descriptions,
+      base::Bind(&OnBuildBlobComplete, base::Unretained(this), uuid));
   blob_storage_[uuid] = std::move(consolidation);
 }
 
 void BlobTransportController::ReleaseBlobConsolidation(
     const std::string& uuid) {
   if (blob_storage_.erase(uuid)) {
     main_thread_runner_->PostTask(FROM_HERE,
                                   base::Bind(&DecChildProcessRefCount));
   }
 }
 
 }  // namespace content