[BlobAsync] Disk support for blob storage

content/browser/blob_storage/blob_reader_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 <stddef.h>
 #include <stdint.h>
 #include <string.h>
 
 #include <memory>
 #include <utility>
@@ skipping 25 matching lines @@
 #include "storage/browser/fileapi/file_system_context.h"
 #include "storage/browser/fileapi/file_system_file_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 using base::FilePath;
 using content::AsyncFileTestHelper;
 using net::DrainableIOBuffer;
 using net::IOBuffer;
+using FileCreationInfo = storage::BlobMemoryController::FileCreationInfo;
 
 namespace storage {
 namespace {
 
 const int kTestDiskCacheStreamIndex = 0;
 const int kTestDiskCacheSideStreamIndex = 1;
 
+void SaveBlobStatusAndFiles(BlobStatus* status_ptr,
+                            std::vector<FileCreationInfo>* files_ptr,
+                            BlobStatus status,
+                            std::vector<FileCreationInfo> files) {
+  *status_ptr = status;
+  for (FileCreationInfo& info : files) {
+    files_ptr->push_back(std::move(info));
+  }
+}
+
 // Our disk cache tests don't need a real data handle since the tests themselves
 // scope the disk cache and entries.
 class EmptyDataHandle : public storage::BlobDataBuilder::DataHandle {
  private:
   ~EmptyDataHandle() override {}
 };
 
 // A disk_cache::Entry that arbitrarily delays the completion of a read
 // operation to allow testing some races without flake. This is particularly
 // relevant in this unit test, which uses the always-synchronous MEMORY_CACHE.
@@ skipping 839 matching lines @@
   const size_t kItemSize = 6;
   const size_t kBufferSize = 10;
   const size_t kTotalSize = kNumItems * kItemSize;
   char current_value = 0;
   // Create blob and reader.
   for (size_t i = 0; i < kNumItems; i++) {
     current_value += kItemSize;
     FilePath path = kPathBase.Append(
         FilePath::FromUTF8Unsafe(base::StringPrintf("%d", current_value)));
     uint64_t offset = i % 3 == 0 ? 1 : 0;
-    uint64_t size =
-        i % 2 == 0 ? kItemSize : std::numeric_limits<uint64_t>::max();
+    uint64_t size = kItemSize;
     b.AppendFile(path, offset, size, kTime);
   }
   this->InitializeReader(&b);
 
   // Set expectations.
   current_value = 0;
   for (size_t i = 0; i < kNumItems; i++) {
     uint64_t offset = i % 3 == 0 ? 1 : 0;
     std::unique_ptr<char[]> buf(new char[kItemSize + offset]);
     if (offset > 0) {
@@ skipping 243 matching lines @@
   EXPECT_EQ(BlobReader::Status::DONE,
             reader_->CalculateSize(base::Bind(&SetValue<int>, &size_result)));
   buffer = CreateBuffer(kDataSize + 1);
   EXPECT_EQ(BlobReader::Status::NET_ERROR,
             reader_->SetReadRange(0, kDataSize + 1));
   EXPECT_EQ(net::ERR_FILE_NOT_FOUND, reader_->net_error());
 }
 
 TEST_F(BlobReaderTest, HandleBeforeAsyncCancel) {
   const std::string kUuid("uuid1");
+  const std::string kData("Hello!!!");
+  const size_t kDataSize = 8ul;
+  std::vector<FileCreationInfo> files;
 
-  context_.CreatePendingBlob(kUuid, "", "");
-  blob_handle_ = context_.GetBlobDataFromUUID(kUuid);
+  BlobDataBuilder b(kUuid);
+  b.AppendFutureData(kDataSize);
+  BlobStatus can_populate_status =
+      BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS;
+  blob_handle_ = context_.BuildBlob(
+      b, base::Bind(&SaveBlobStatusAndFiles, &can_populate_status, &files));
+  EXPECT_EQ(BlobStatus::PENDING_TRANSPORT, can_populate_status);
   provider_ = new MockFileStreamReaderProvider();
   reader_.reset(new BlobReader(blob_handle_.get(), base::WrapUnique(provider_),
                                message_loop_.task_runner().get()));
   int size_result = -1;
   EXPECT_EQ(BlobReader::Status::IO_PENDING,
             reader_->CalculateSize(base::Bind(&SetValue<int>, &size_result)));
   EXPECT_FALSE(reader_->IsInMemory());
-  context_.CancelPendingBlob(kUuid, IPCBlobCreationCancelCode::UNKNOWN);
+  context_.BreakAndFinishPendingBlob(
+      kUuid, BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(net::ERR_FAILED, size_result);
 }
 
 TEST_F(BlobReaderTest, ReadFromIncompleteBlob) {
   const std::string kUuid("uuid1");
   const std::string kData("Hello!!!");
   const size_t kDataSize = 8ul;
+  std::vector<FileCreationInfo> files;
 
   BlobDataBuilder b(kUuid);
-  b.AppendData(kData);
-  context_.CreatePendingBlob(kUuid, "", "");
-  blob_handle_ = context_.GetBlobDataFromUUID(kUuid);
+  b.AppendFutureData(kDataSize);
+  BlobStatus can_populate_status =
+      BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS;
+  blob_handle_ = context_.BuildBlob(
+      b, base::Bind(&SaveBlobStatusAndFiles, &can_populate_status, &files));
+  EXPECT_EQ(BlobStatus::PENDING_TRANSPORT, can_populate_status);
   provider_ = new MockFileStreamReaderProvider();
   reader_.reset(new BlobReader(blob_handle_.get(), base::WrapUnique(provider_),
                                message_loop_.task_runner().get()));
   int size_result = -1;
   EXPECT_EQ(BlobReader::Status::IO_PENDING,
             reader_->CalculateSize(base::Bind(&SetValue<int>, &size_result)));
   EXPECT_FALSE(reader_->IsInMemory());
-  context_.CompletePendingBlob(b);
+  b.PopulateFutureData(0, kData.data(), 0, kDataSize);
+  context_.FinishedPopulatingPendingBlob(kUuid);
   base::RunLoop().RunUntilIdle();
   CheckSizeCalculatedAsynchronously(kDataSize, size_result);
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kDataSize));
 
   int bytes_read = 0;
   int async_bytes_read = 0;
   EXPECT_EQ(BlobReader::Status::DONE,
             reader_->Read(buffer.get(), kDataSize, &bytes_read,
                           base::Bind(&SetValue<int>, &async_bytes_read)));
   EXPECT_EQ(net::OK, reader_->net_error());
   EXPECT_EQ(kDataSize, static_cast<size_t>(bytes_read));
   EXPECT_EQ(0, async_bytes_read);
   EXPECT_EQ(kData, std::string(buffer->data(), kDataSize));
   EXPECT_EQ(net::OK, size_result);
 }
 
 }  // namespace storage