[BlobAsync] Moving async handling into BlobStorageContext & quota out.

content/child/blob_storage/blob_transport_controller_unittest.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 <stddef.h>
 #include <stdint.h>
 #include <tuple>
 
@@ skipping 19 matching lines @@
 #include "storage/common/blob_storage/blob_item_bytes_request.h"
 #include "storage/common/blob_storage/blob_item_bytes_response.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::File;
 using base::FilePath;
 using base::TestSimpleTaskRunner;
 using storage::BlobItemBytesRequest;
 using storage::BlobItemBytesResponse;
+using storage::BlobStatus;
 using storage::DataElement;
-using storage::IPCBlobCreationCancelCode;
 
 namespace content {
 namespace {
 
 class OtherThreadTestSimpleTaskRunner : public base::TestSimpleTaskRunner {
  public:
   bool RunsTasksOnCurrentThread() const override { return false; }
 
  protected:
   ~OtherThreadTestSimpleTaskRunner() override {}
@@ skipping 70 matching lines @@
     FilePath path;
     EXPECT_TRUE(base::CreateTemporaryFile(&path));
     files_opened_.push_back(path);
     return path;
   }
 
   void ExpectRegisterAndStartMessage(const std::string& expected_uuid,
                                      const std::string& expected_content_type,
                                      std::vector<DataElement>* descriptions) {
     const IPC::Message* register_message =
-        sink_.GetUniqueMessageMatching(BlobStorageMsg_RegisterBlobUUID::ID);
-    const IPC::Message* start_message =
-        sink_.GetUniqueMessageMatching(BlobStorageMsg_StartBuildingBlob::ID);
+        sink_.GetUniqueMessageMatching(BlobStorageMsg_RegisterBlob::ID);
     ASSERT_TRUE(register_message);
-    ASSERT_TRUE(start_message);
-    std::tuple<std::string, std::string, std::string, std::set<std::string>>
+    std::tuple<std::string, std::string, std::string, std::vector<DataElement>>
         register_contents;
-    std::tuple<std::string, std::vector<DataElement>> start_contents;
-    BlobStorageMsg_RegisterBlobUUID::Read(register_message, &register_contents);
-    BlobStorageMsg_StartBuildingBlob::Read(start_message, &start_contents);
+    BlobStorageMsg_RegisterBlob::Read(register_message, &register_contents);
     EXPECT_EQ(expected_uuid, std::get<0>(register_contents));
-    EXPECT_EQ(expected_uuid, std::get<0>(start_contents));
     EXPECT_EQ(expected_content_type, std::get<1>(register_contents));
     if (descriptions)
-      *descriptions = std::get<1>(start_contents);
+      *descriptions = std::get<3>(register_contents);
     // We don't have dispositions from the renderer.
     EXPECT_TRUE(std::get<2>(register_contents).empty());
     sink_.ClearMessages();
   }
 
   void ExpectMemoryResponses(
       const std::string& expected_uuid,
       std::vector<storage::BlobItemBytesResponse> expected_responses) {
     const IPC::Message* responses_message =
         sink_.GetUniqueMessageMatching(BlobStorageMsg_MemoryItemResponse::ID);
     ASSERT_TRUE(responses_message);
     std::tuple<std::string, std::vector<storage::BlobItemBytesResponse>>
         responses_content;
     BlobStorageMsg_MemoryItemResponse::Read(responses_message,
                                             &responses_content);
     EXPECT_EQ(expected_uuid, std::get<0>(responses_content));
     EXPECT_EQ(expected_responses, std::get<1>(responses_content));
     sink_.ClearMessages();
   }
 
   void ExpectCancel(const std::string& expected_uuid,
-                    storage::IPCBlobCreationCancelCode expected_code) {
+                    storage::BlobStatus expected_code) {
     const IPC::Message* cancel_message =
-        sink_.GetUniqueMessageMatching(BlobStorageMsg_CancelBuildingBlob::ID);
+        sink_.GetUniqueMessageMatching(BlobStorageMsg_SendBlobStatus::ID);
     ASSERT_TRUE(cancel_message);
-    std::tuple<std::string, storage::IPCBlobCreationCancelCode> cancel_content;
-    BlobStorageMsg_CancelBuildingBlob::Read(cancel_message, &cancel_content);
+    std::tuple<std::string, storage::BlobStatus> cancel_content;
+    BlobStorageMsg_SendBlobStatus::Read(cancel_message, &cancel_content);
     EXPECT_EQ(expected_uuid, std::get<0>(cancel_content));
     EXPECT_EQ(expected_code, std::get<1>(cancel_content));
   }
 
   void TearDown() override {
     BlobTransportController::GetInstance()->CancelAllBlobTransfers();
     for (const FilePath& path : files_opened_) {
       EXPECT_TRUE(base::DeleteFile(path, false));
     }
     EXPECT_FALSE(io_thread_runner_->HasPendingTask());
@@ skipping 193 matching lines @@
   EXPECT_FALSE(file2.IsValid());
   file_handles.push_back(IPC::TakePlatformFileForTransit(std::move(file2)));
   OnMemoryRequest(holder, kBlobUUID, requests, &memory_handles, file_handles);
   EXPECT_TRUE(file_thread_runner_->HasPendingTask());
   file_thread_runner_->RunPendingTasks();
   EXPECT_TRUE(io_thread_runner_->HasPendingTask());
   io_thread_runner_->RunPendingTasks();
   // Clear the main thread task, as it has the AddRef job.
   EXPECT_TRUE(main_thread_runner_->HasPendingTask());
   main_thread_runner_->ClearPendingTasks();
-  ExpectCancel(kBlobUUID, IPCBlobCreationCancelCode::FILE_WRITE_FAILED);
+  ExpectCancel(kBlobUUID, BlobStatus::ERR_FILE_WRITE_FAILED);
 }
 
 TEST_F(BlobTransportControllerTest, PublicMethods) {
   const std::string kBlobUUID = "uuid";
   const std::string kBlobContentType = "content_type";
   const std::string kBlob2UUID = "uuid2";
   const std::string kBlob2ContentType = "content_type2";
   const std::string KRefBlobUUID = "refuuid";
   const std::string kDataPart1 = "Hello";
   const std::string kDataPart2 = "Hello2";
@@ skipping 18 matching lines @@
   main_thread_runner_->ClearPendingTasks();
 
   // Check that we got the correct start message.
   EXPECT_FALSE(holder->IsTransporting(kBlobUUID));
   io_thread_runner_->RunPendingTasks();
   EXPECT_TRUE(holder->IsTransporting(kBlobUUID));
   std::tuple<std::string, std::vector<DataElement>> message_contents;
   EXPECT_TRUE(holder->IsTransporting(kBlobUUID));
   EXPECT_EQ(MakeBlobElement(KRefBlobUUID, 10, 10), message_descriptions[0]);
 
-  holder->OnCancel(kBlobUUID, IPCBlobCreationCancelCode::OUT_OF_MEMORY);
+  holder->OnBlobFinalStatus(kBlobUUID, BlobStatus::ERR_OUT_OF_MEMORY);
   EXPECT_FALSE(holder->IsTransporting(kBlobUUID));
   // Check we have the 'decrease ref' task.
   EXPECT_TRUE(main_thread_runner_->HasPendingTask());
   main_thread_runner_->ClearPendingTasks();
   sink_.ClearMessages();
 
   // Add the second.
   scoped_refptr<BlobConsolidation> consolidation2 = new BlobConsolidation();
   consolidation2->AddBlobItem(KRefBlobUUID, 10, 10);
   // These items should be combined.
@@ skipping 31 matching lines @@
   OnMemoryRequest(holder, kBlob2UUID, requests, &memory_handles, file_handles);
 
   std::vector<BlobItemBytesResponse> expected_responses;
   BlobItemBytesResponse expected(0);
   expected.inline_data = std::vector<char>(kData.begin(), kData.end());
   expected_responses.push_back(expected);
   ExpectMemoryResponses(kBlob2UUID, expected_responses);
   EXPECT_FALSE(main_thread_runner_->HasPendingTask());
 
   // Finish the second one.
-  holder->OnDone(kBlob2UUID);
+  holder->OnBlobFinalStatus(kBlob2UUID, BlobStatus::DONE);
   EXPECT_FALSE(holder->IsTransporting(kBlob2UUID));
   EXPECT_TRUE(main_thread_runner_->HasPendingTask());
   main_thread_runner_->ClearPendingTasks();
 }
 
 }  // namespace content