[Blob] Fix for resetting reader.

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 "storage/browser/blob/blob_reader.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
@@ skipping 399 matching lines @@
   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(0, memcmp(buffer->data(), "Hello!!!", kDataSize));
 }
 
+TEST_F(BlobReaderTest, BasicMemoryWithResets) {
+  BlobDataBuilder b("uuid");
+  const std::string kData("Hello!!!");
+  const size_t kDataSize = 8ul;
+  b.AppendData(kData);
+  this->InitializeReader(&b);
+  EXPECT_FALSE(reader_->reader_used());
+
+  int size_result = -1;
+  EXPECT_FALSE(IsReaderTotalSizeCalculated());
+  EXPECT_EQ(BlobReader::Status::DONE,
+            reader_->CalculateSize(base::Bind(&SetValue<int>, &size_result)));
+  EXPECT_TRUE(reader_->reader_used());
+
+  // Case 1: Reset after calculate size.
+  reader_->Reset();
+  EXPECT_FALSE(reader_->reader_used());
+  EXPECT_FALSE(IsReaderTotalSizeCalculated());
+
+  EXPECT_EQ(BlobReader::Status::DONE,
+            reader_->CalculateSize(base::Bind(&SetValue<int>, &size_result)));
+  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());
+
+  // Case 2: Reset after Read call.
+  reader_->Reset();
+  EXPECT_FALSE(reader_->reader_used());
+  EXPECT_FALSE(IsReaderTotalSizeCalculated());
+
+  EXPECT_EQ(BlobReader::Status::DONE,
+            reader_->CalculateSize(base::Bind(&SetValue<int>, &size_result)));
+  EXPECT_EQ(BlobReader::Status::DONE,
+            reader_->Read(buffer.get(), kDataSize, &bytes_read,
+                          base::Bind(&SetValue<int>, &async_bytes_read)));
+  EXPECT_EQ(0, memcmp(buffer->data(), "Hello!!!", kDataSize));
+}
+
 TEST_F(BlobReaderTest, BasicFile) {
   BlobDataBuilder b("uuid");
   const FilePath kPath = FilePath::FromUTF8Unsafe("/fake/file.txt");
   const std::string kData = "FileData!!!";
   const base::Time kTime = base::Time::Now();
   b.AppendFile(kPath, 0, kData.size(), kTime);
   this->InitializeReader(&b);
 
   // Non-async reader.
   ExpectLocalFileCall(kPath, kTime, 0, new FakeFileStreamReader(kData));
@@ skipping 241 matching lines @@
   EXPECT_EQ(BlobReader::Status::IO_PENDING,
             reader_->Read(buffer.get(), kData.size(), &bytes_read,
                           base::Bind(&SetValue<int>, &async_bytes_read)));
   message_loop_.RunUntilIdle();
   EXPECT_EQ(net::OK, reader_->net_error());
   EXPECT_EQ(kData.size(), static_cast<size_t>(async_bytes_read));
   EXPECT_EQ(0, bytes_read);
   EXPECT_EQ(0, memcmp(buffer->data(), "FileData!!!", kData.size()));
 }
 
+TEST_F(BlobReaderTest, FileAsyncWithResets) {
+  BlobDataBuilder b("uuid");
+  const FilePath kPath = FilePath::FromUTF8Unsafe("/fake/file.txt");
+  const std::string kData = "FileData!!!";
+  const base::Time kTime = base::Time::Now();
+  b.AppendFile(kPath, 0, kData.size(), kTime);
+  this->InitializeReader(&b);
+
+  scoped_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)));
+  CheckSizeNotCalculatedYet(size_result);
+
+  // Case 1: Reset after calculate size, but before callbacks are run.
+  reader_->Reset();
+  message_loop_.RunUntilIdle();
+  EXPECT_FALSE(IsReaderTotalSizeCalculated());
+
+  EXPECT_EQ(BlobReader::Status::IO_PENDING,
+            reader_->CalculateSize(base::Bind(&SetValue<int>, &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,
+                          base::Bind(&SetValue<int>, &async_bytes_read)));
+
+  // Case 2: Reset after read, but before callbacks are run.
+  reader_->Reset();
+  message_loop_.RunUntilIdle();
+  EXPECT_FALSE(IsReaderTotalSizeCalculated());
+  EXPECT_EQ(0, async_bytes_read);
+}
+
 TEST_F(BlobReaderTest, FileSystemAsync) {
   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);
 
   scoped_ptr<FakeFileStreamReader> reader(new FakeFileStreamReader(kData));
   reader->SetAsyncRunner(message_loop_.task_runner().get());
@@ skipping 411 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());
 }
 
 }  // namespace
 }  // namespace storage