[BlobAsync] Asynchronous Blob Construction Final Patch

content/browser/fileapi/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 <utility>
 
 #include "base/bind.h"
@@ skipping 309 matching lines @@
     reader_.reset();
     blob_handle_.reset();
     message_loop_.RunUntilIdle();
     base::RunLoop().RunUntilIdle();
   }
 
  protected:
   void InitializeReader(BlobDataBuilder* builder) {
     blob_handle_ = builder ? context_.AddFinishedBlob(builder) : nullptr;
     provider_ = new MockFileStreamReaderProvider();
-    scoped_ptr<BlobReader::FileStreamReaderProvider> temp_ptr(provider_);
-    reader_.reset(new BlobReader(blob_handle_.get(), std::move(temp_ptr),
+    reader_.reset(new BlobReader(blob_handle_.get(), make_scoped_ptr(provider_),
                                  message_loop_.task_runner().get()));
   }
 
   // Takes ownership of the file reader (the blob reader takes ownership).
   void ExpectLocalFileCall(const FilePath& file_path,
                            base::Time modification_time,
                            uint64_t initial_offset,
                            FakeFileStreamReader* reader) {
     EXPECT_CALL(*provider_, CreateForLocalFileMock(
                                 message_loop_.task_runner().get(), file_path,
@@ skipping 46 matching lines @@
   BlobStorageContext context_;
   scoped_ptr<BlobDataHandle> blob_handle_;
   MockFileStreamReaderProvider* provider_ = nullptr;
   base::MessageLoop message_loop_;
   scoped_ptr<BlobReader> reader_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BlobReaderTest);
 };
 
-namespace {
-
 TEST_F(BlobReaderTest, BasicMemory) {
   BlobDataBuilder b("uuid");
   const std::string kData("Hello!!!");
   const size_t kDataSize = 8ul;
   b.AppendData(kData);
   this->InitializeReader(&b);
 
   int size_result = -1;
   EXPECT_FALSE(IsReaderTotalSizeCalculated());
   EXPECT_EQ(BlobReader::Status::DONE,
@@ skipping 696 matching lines @@
   this->InitializeReader(&b2);
   size_result = -1;
   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());
 }
 
-}  // namespace
+TEST_F(BlobReaderTest, HandleBeforeAsyncCancel) {
+  const std::string kUuid("uuid1");
+
+  context_.CreatePendingBlob(kUuid, "", "");
+  blob_handle_ = context_.GetBlobDataFromUUID(kUuid);
+  provider_ = new MockFileStreamReaderProvider();
+  reader_.reset(new BlobReader(blob_handle_.get(), make_scoped_ptr(provider_),
+                               message_loop_.task_runner().get()));
+  int size_result = -1;
+  EXPECT_EQ(BlobReader::Status::IO_PENDING,
+            reader_->CalculateSize(base::Bind(&SetValue<int>, &size_result)));
+  context_.CancelPendingBlob(kUuid, IPCBlobCreationCancelCode::UNKNOWN);
+  message_loop_.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;
+
+  BlobDataBuilder b(kUuid);
+  b.AppendData(kData);
+  context_.CreatePendingBlob(kUuid, "", "");
+  blob_handle_ = context_.GetBlobDataFromUUID(kUuid);
+  provider_ = new MockFileStreamReaderProvider();
+  reader_.reset(new BlobReader(blob_handle_.get(), make_scoped_ptr(provider_),
+                               message_loop_.task_runner().get()));
+  int size_result = -1;
+  EXPECT_EQ(BlobReader::Status::IO_PENDING,
+            reader_->CalculateSize(base::Bind(&SetValue<int>, &size_result)));
+  context_.CompletePendingBlob(b);
+  message_loop_.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