[BlobAsync] Asynchronous Blob Construction Final Patch

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 <utility>
 #include <vector>
 
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/shared_memory.h"
 #include "base/stl_util.h"
 #include "content/child/blob_storage/blob_consolidation.h"
 #include "content/child/thread_safe_sender.h"
+#include "content/common/fileapi/webblob_messages.h"
 #include "ipc/ipc_sender.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"
 
 using base::SharedMemory;
 using base::SharedMemoryHandle;
 using storage::BlobItemBytesRequest;
 using storage::BlobItemBytesResponse;
 using storage::IPCBlobItemRequestStrategy;
@@ skipping 13 matching lines @@
 }  // namespace
 
 BlobTransportController* BlobTransportController::GetInstance() {
   return g_controller.Pointer();
 }
 
 BlobTransportController::~BlobTransportController() {}
 
 void BlobTransportController::InitiateBlobTransfer(
     const std::string& uuid,
-    const std::string& type,
     scoped_ptr<BlobConsolidation> consolidation,
     IPC::Sender* sender) {
   BlobConsolidation* consolidation_ptr = consolidation.get();
-  blob_storage_.insert(std::make_pair(uuid, std::move(consolidation)));
+  blob_storage_[uuid] = std::move(consolidation);
   std::vector<storage::DataElement> descriptions;
   GetDescriptions(consolidation_ptr, kLargeThresholdBytes, &descriptions);
-  // TODO(dmurph): Uncomment when IPC messages are added.
-  // sender->Send(new BlobStorageMsg_StartBuildingBlob(uuid, type,
-  // descriptions));
+  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,
     IPC::Sender* sender) {
   std::vector<storage::BlobItemBytesResponse> responses;
   ResponsesStatus status =
       GetResponses(uuid, requests, memory_handles, file_handles, &responses);
 
   switch (status) {
     case ResponsesStatus::BLOB_NOT_FOUND:
       // sender->Send(new BlobStorageMsg_CancelBuildingBlob(uuid,
       // IPCBlobCreationCancelCode::UNKNOWN));
       return;
     case ResponsesStatus::SHARED_MEMORY_MAP_FAILED:
       // This would happen if the renderer process doesn't have enough memory
       // to map the shared memory, which is possible if we don't have much
       // memory. If this scenario happens often, we could delay the response
       // until we have enough memory.  For now we just fail.
       CHECK(false) << "Unable to map shared memory to send blob " << uuid
                    << ".";
       break;
     case ResponsesStatus::SUCCESS:
       break;
   }
 
-  // TODO(dmurph): Uncomment when IPC messages are added.
-  // sender->Send(new BlobStorageMsg_MemoryItemResponse(uuid, responses));
+  sender->Send(new BlobStorageMsg_MemoryItemResponse(uuid, responses));
 }
 
 void BlobTransportController::OnCancel(
     const std::string& uuid,
     storage::IPCBlobCreationCancelCode code) {
   DVLOG(1) << "Received blob cancel for blob " << uuid << " with reason:";
   switch (code) {
     case IPCBlobCreationCancelCode::UNKNOWN:
       DVLOG(1) << "Unknown.";
       break;
     case IPCBlobCreationCancelCode::OUT_OF_MEMORY:
       DVLOG(1) << "Out of Memory.";
       break;
+    case IPCBlobCreationCancelCode::SOURCE_DIED_IN_TRANSIT:
+      DVLOG(1)
+          << "Source died in transit. Invalid cancel reason from the Browser.";
+      break;
     case IPCBlobCreationCancelCode::FILE_WRITE_FAILED:
-      DVLOG(1) << "File Write Failed (Invalid cancel reason!).";
+      DVLOG(1) << "File Write Failed.";
+      break;
+    case IPCBlobCreationCancelCode::BLOB_DEREFERENCED_WHILE_BUILDING:
+      DVLOG(1) << "Blob was dereferenced before building finished, and no one "
+               << "was waiting to read it.";
+      break;
+    case IPCBlobCreationCancelCode::REFERENCED_BLOB_BROKEN:
+      DVLOG(1) << "Referenced blob was broken.";
       break;
   }
   ReleaseBlobConsolidation(uuid);
 }
 
 void BlobTransportController::OnDone(const std::string& uuid) {
   ReleaseBlobConsolidation(uuid);
 }
 
 void BlobTransportController::Clear() {
   blob_storage_.clear();
 }
 
 BlobTransportController::BlobTransportController() {}
 
 void BlobTransportController::CancelBlobTransfer(const std::string& uuid,
                                                  IPCBlobCreationCancelCode code,
                                                  IPC::Sender* sender) {
-  // TODO(dmurph): Uncomment when IPC messages are added.
-  // sender->Send(new BlobStorageMsg_CancelBuildingBlob(uuid, code));
+  sender->Send(new BlobStorageMsg_CancelBuildingBlob(uuid, code));
   ReleaseBlobConsolidation(uuid);
 }
 
 void BlobTransportController::GetDescriptions(
     BlobConsolidation* consolidation,
     size_t max_data_population,
     std::vector<storage::DataElement>* out) {
   DCHECK(out->empty());
   DCHECK(consolidation);
   const auto& consolidated_items = consolidation->consolidated_items();
@@ skipping 117 matching lines @@
   }
   return ResponsesStatus::SUCCESS;
 }
 
 void BlobTransportController::ReleaseBlobConsolidation(
     const std::string& uuid) {
   blob_storage_.erase(uuid);
 }
 
 }  // namespace content