[BlobReader] Correct IsInMemory = false when async constructing

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 406 matching lines @@
   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,
             reader_->CalculateSize(base::Bind(&SetValue<int>, &size_result)));
+  EXPECT_TRUE(reader_->IsInMemory());
   CheckSizeCalculatedSynchronously(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());
@@ skipping 10 matching lines @@
   b.AppendFile(kPath, 0, kData.size(), kTime);
   this->InitializeReader(&b);
 
   // Non-async reader.
   ExpectLocalFileCall(kPath, kTime, 0, new FakeFileStreamReader(kData));
 
   int size_result = -1;
   EXPECT_FALSE(IsReaderTotalSizeCalculated());
   EXPECT_EQ(BlobReader::Status::DONE,
             reader_->CalculateSize(base::Bind(&SetValue<int>, &size_result)));
+  EXPECT_FALSE(reader_->IsInMemory());
   CheckSizeCalculatedSynchronously(kData.size(), size_result);
 
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kData.size()));
 
   int bytes_read = 0;
   int async_bytes_read = 0;
   EXPECT_EQ(BlobReader::Status::DONE,
             reader_->Read(buffer.get(), kData.size(), &bytes_read,
                           base::Bind(&SetValue<int>, &async_bytes_read)));
   EXPECT_EQ(net::OK, reader_->net_error());
   EXPECT_EQ(kData.size(), static_cast<size_t>(bytes_read));
   EXPECT_EQ(0, async_bytes_read);
   EXPECT_EQ(0, memcmp(buffer->data(), "FileData!!!", kData.size()));
 }
 
 TEST_F(BlobReaderTest, BasicFileSystem) {
   BlobDataBuilder b("uuid");
   const GURL kURL("file://test_file/here.txt");
   const std::string kData = "FileData!!!";
   const base::Time kTime = base::Time::Now();
   b.AppendFileSystemFile(kURL, 0, kData.size(), kTime);
   this->InitializeReader(&b);
-
   // Non-async reader.
   ExpectFileSystemCall(kURL, 0, kData.size(), kTime,
                        new FakeFileStreamReader(kData));
 
   int size_result = -1;
   EXPECT_FALSE(IsReaderTotalSizeCalculated());
   EXPECT_EQ(BlobReader::Status::DONE,
             reader_->CalculateSize(base::Bind(&SetValue<int>, &size_result)));
+  EXPECT_FALSE(reader_->IsInMemory());
+
   CheckSizeCalculatedSynchronously(kData.size(), size_result);
 
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kData.size()));
 
   int bytes_read = 0;
   int async_bytes_read = 0;
   EXPECT_EQ(BlobReader::Status::DONE,
             reader_->Read(buffer.get(), kData.size(), &bytes_read,
                           base::Bind(&SetValue<int>, &async_bytes_read)));
   EXPECT_EQ(net::OK, reader_->net_error());
@@ skipping 214 matching lines @@
 
   std::unique_ptr<FakeFileStreamReader> reader(new FakeFileStreamReader(kData));
   reader->SetAsyncRunner(message_loop_.task_runner().get());
 
   ExpectLocalFileCall(kPath, kTime, 0, reader.release());
 
   int size_result = -1;
   EXPECT_FALSE(IsReaderTotalSizeCalculated());
   EXPECT_EQ(BlobReader::Status::IO_PENDING,
             reader_->CalculateSize(base::Bind(&SetValue<int>, &size_result)));
+  EXPECT_FALSE(reader_->IsInMemory());
   CheckSizeNotCalculatedYet(size_result);
   message_loop_.RunUntilIdle();
   CheckSizeCalculatedAsynchronously(kData.size(), size_result);
 
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kData.size()));
 
   int bytes_read = 0;
   int async_bytes_read = 0;
   EXPECT_EQ(BlobReader::Status::IO_PENDING,
             reader_->Read(buffer.get(), kData.size(), &bytes_read,
@@ skipping 16 matching lines @@
   std::unique_ptr<FakeFileStreamReader> reader(new FakeFileStreamReader(kData));
   reader->SetAsyncRunner(message_loop_.task_runner().get());
 
   ExpectFileSystemCall(kURL, 0, kData.size(), kTime, reader.release());
 
   int size_result = -1;
   EXPECT_FALSE(IsReaderTotalSizeCalculated());
   EXPECT_EQ(BlobReader::Status::IO_PENDING,
             reader_->CalculateSize(base::Bind(&SetValue<int>, &size_result)));
   CheckSizeNotCalculatedYet(size_result);
+  EXPECT_FALSE(reader_->IsInMemory());
   message_loop_.RunUntilIdle();
   CheckSizeCalculatedAsynchronously(kData.size(), size_result);
 
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kData.size()));
 
   int bytes_read = 0;
   int async_bytes_read = 0;
   EXPECT_EQ(BlobReader::Status::IO_PENDING,
             reader_->Read(buffer.get(), kData.size(), &bytes_read,
                           base::Bind(&SetValue<int>, &async_bytes_read)));
@@ skipping 403 matching lines @@
   const std::string kUuid("uuid1");
 
   context_.CreatePendingBlob(kUuid, "", "");
   blob_handle_ = context_.GetBlobDataFromUUID(kUuid);
   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);
   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(), 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);
   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