drive: Discard stream reader canceller as soon as the required data is obtained.

chrome/browser/chromeos/drive/drive_file_stream_reader_unittest.cc

 // Copyright 2013 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 "chrome/browser/chromeos/drive/drive_file_stream_reader.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
@@ skipping 92 matching lines @@
 class NetworkReaderProxyTest : public ::testing::Test {
  protected:
   NetworkReaderProxyTest()
       : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP) {
   }
 
   content::TestBrowserThreadBundle thread_bundle_;
 };
 
 TEST_F(NetworkReaderProxyTest, EmptyFile) {
-  NetworkReaderProxy proxy(0, 0, base::Bind(&base::DoNothing));
+  NetworkReaderProxy proxy(0, 0, 0, base::Bind(&base::DoNothing));
 
   net::TestCompletionCallback callback;
   const int kBufferSize = 10;
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kBufferSize));
   int result = proxy.Read(buffer.get(), kBufferSize, callback.callback());
 
   // For empty file, Read() should return 0 immediately.
   EXPECT_EQ(0, result);
 }
 
 TEST_F(NetworkReaderProxyTest, Read) {
-  NetworkReaderProxy proxy(0, 10, base::Bind(&base::DoNothing));
+  int cancel_called = 0;
+  {
+    NetworkReaderProxy proxy(0, 10, 10,
+                             base::Bind(&IncrementCallback, &cancel_called));
+
+    net::TestCompletionCallback callback;
+    const int kBufferSize = 3;
+    scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kBufferSize));
+
+    // If no data is available yet, ERR_IO_PENDING should be returned.
+    int result = proxy.Read(buffer.get(), kBufferSize, callback.callback());
+    EXPECT_EQ(net::ERR_IO_PENDING, result);
+
+    // And when the data is supplied, the callback will be called.
+    scoped_ptr<std::string> data(new std::string("abcde"));
+    proxy.OnGetContent(data.Pass());
+
+    // The returned data should be fit to the buffer size.
+    result = callback.GetResult(result);
+    EXPECT_EQ(3, result);
+    EXPECT_EQ("abc", std::string(buffer->data(), result));
+
+    // The next Read should return immediately because there is pending data
+    result = proxy.Read(buffer.get(), kBufferSize, callback.callback());
+    EXPECT_EQ(2, result);
+    EXPECT_EQ("de", std::string(buffer->data(), result));
+
+    // Supply the data before calling Read operation.
+    data.reset(new std::string("fg"));
+    proxy.OnGetContent(data.Pass());
+    data.reset(new std::string("hij"));
+    proxy.OnGetContent(data.Pass());  // Now 10 bytes are supplied.
+
+    // The data should be concatenated if possible.
+    result = proxy.Read(buffer.get(), kBufferSize, callback.callback());
+    EXPECT_EQ(3, result);
+    EXPECT_EQ("fgh", std::string(buffer->data(), result));
+
+    result = proxy.Read(buffer.get(), kBufferSize, callback.callback());
+    EXPECT_EQ(2, result);
+    EXPECT_EQ("ij", std::string(buffer->data(), result));
+
+    // The whole data is read, so Read() should return 0 immediately by then.
+    result = proxy.Read(buffer.get(), kBufferSize, callback.callback());
+    EXPECT_EQ(0, result);
+  }
+
+  // Proxy is deleted without any called to OnCompleted(). Even in the case,
+  // cancel callback should not be invoked.
+  EXPECT_EQ(0, cancel_called);
+}
+
+TEST_F(NetworkReaderProxyTest, ReadWithLimit) {
+  NetworkReaderProxy proxy(10, 10, 10, base::Bind(&base::DoNothing));
 
   net::TestCompletionCallback callback;
   const int kBufferSize = 3;
-  scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kBufferSize));
-
-  // If no data is available yet, ERR_IO_PENDING should be returned.
-  int result = proxy.Read(buffer.get(), kBufferSize, callback.callback());
-  EXPECT_EQ(net::ERR_IO_PENDING, result);
-
-  // And when the data is supplied, the callback will be called.
-  scoped_ptr<std::string> data(new std::string("abcde"));
-  proxy.OnGetContent(data.Pass());
-
-  // The returned data should be fit to the buffer size.
-  result = callback.GetResult(result);
-  EXPECT_EQ(3, result);
-  EXPECT_EQ("abc", std::string(buffer->data(), result));
-
-  // The next Read should return immediately because there is pending data
-  result = proxy.Read(buffer.get(), kBufferSize, callback.callback());
-  EXPECT_EQ(2, result);
-  EXPECT_EQ("de", std::string(buffer->data(), result));
-
-  // Supply the data before calling Read operation.
-  data.reset(new std::string("fg"));
-  proxy.OnGetContent(data.Pass());
-  data.reset(new std::string("hij"));
-  proxy.OnGetContent(data.Pass());  // Now 10 bytes are supplied.
-
-  // The data should be concatenated if possible.
-  result = proxy.Read(buffer.get(), kBufferSize, callback.callback());
-  EXPECT_EQ(3, result);
-  EXPECT_EQ("fgh", std::string(buffer->data(), result));
-
-  result = proxy.Read(buffer.get(), kBufferSize, callback.callback());
-  EXPECT_EQ(2, result);
-  EXPECT_EQ("ij", std::string(buffer->data(), result));
-
-  // The whole data is read, so Read() should return 0 immediately by then.
-  result = proxy.Read(buffer.get(), kBufferSize, callback.callback());
-  EXPECT_EQ(0, result);
-}
-
-TEST_F(NetworkReaderProxyTest, ReadWithLimit) {
-  NetworkReaderProxy proxy(10, 10, base::Bind(&base::DoNothing));
-
-  net::TestCompletionCallback callback;
-  const int kBufferSize = 3;
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kBufferSize));
 
   // If no data is available yet, ERR_IO_PENDING should be returned.
   int result = proxy.Read(buffer.get(), kBufferSize, callback.callback());
   EXPECT_EQ(net::ERR_IO_PENDING, result);
 
   // And when the data is supplied, the callback will be called.
   scoped_ptr<std::string> data(new std::string("abcde"));
   proxy.OnGetContent(data.Pass());
   data.reset(new std::string("fgh"));
@@ skipping 25 matching lines @@
   result = proxy.Read(buffer.get(), kBufferSize, callback.callback());
   EXPECT_EQ(2, result);
   EXPECT_EQ("st", std::string(buffer->data(), result));
 
   // The whole data is read, so Read() should return 0 immediately by then.
   result = proxy.Read(buffer.get(), kBufferSize, callback.callback());
   EXPECT_EQ(0, result);
 }
 
 TEST_F(NetworkReaderProxyTest, ErrorWithPendingCallback) {
-  NetworkReaderProxy proxy(0, 10, base::Bind(&base::DoNothing));
+  NetworkReaderProxy proxy(0, 10, 10, base::Bind(&base::DoNothing));
 
   net::TestCompletionCallback callback;
   const int kBufferSize = 3;
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kBufferSize));
 
   // Set pending callback.
   int result = proxy.Read(buffer.get(), kBufferSize, callback.callback());
   EXPECT_EQ(net::ERR_IO_PENDING, result);
 
   // Emulate that an error is found. The callback should be called internally.
   proxy.OnCompleted(FILE_ERROR_FAILED);
   result = callback.GetResult(result);
   EXPECT_EQ(net::ERR_FAILED, result);
 
   // The next Read call should also return the same error code.
   EXPECT_EQ(net::ERR_FAILED,
             proxy.Read(buffer.get(), kBufferSize, callback.callback()));
 }
 
 TEST_F(NetworkReaderProxyTest, ErrorWithPendingData) {
-  NetworkReaderProxy proxy(0, 10, base::Bind(&base::DoNothing));
+  NetworkReaderProxy proxy(0, 10, 10, base::Bind(&base::DoNothing));
 
   net::TestCompletionCallback callback;
   const int kBufferSize = 3;
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kBufferSize));
 
   // Supply the data before an error.
   scoped_ptr<std::string> data(new std::string("abcde"));
   proxy.OnGetContent(data.Pass());
 
   // Emulate that an error is found.
   proxy.OnCompleted(FILE_ERROR_FAILED);
 
   // The next Read call should return the error code, even if there is
   // pending data (the pending data should be released in OnCompleted.
   EXPECT_EQ(net::ERR_FAILED,
             proxy.Read(buffer.get(), kBufferSize, callback.callback()));
 }
 
 TEST_F(NetworkReaderProxyTest, CancelJob) {
   int num_called = 0;
   {
     NetworkReaderProxy proxy(
-        0, 0, base::Bind(&IncrementCallback, &num_called));
+        0, 0, 0, base::Bind(&IncrementCallback, &num_called));
     proxy.OnCompleted(FILE_ERROR_OK);
     // Destroy the instance after the network operation is completed.
     // The cancelling callback shouldn't be called.
   }
   EXPECT_EQ(0, num_called);
 
   num_called = 0;
   {
     NetworkReaderProxy proxy(
-        0, 0, base::Bind(&IncrementCallback, &num_called));
+        0, 0, 0, base::Bind(&IncrementCallback, &num_called));
     // Destroy the instance before the network operation is completed.
     // The cancelling callback should be called.
   }
   EXPECT_EQ(1, num_called);
 }
 
 }  // namespace internal
 
 class DriveFileStreamReaderTest : public ::testing::Test {
  protected:
@@ skipping 267 matching lines @@
   ASSERT_TRUE(entry);
   EXPECT_TRUE(reader->IsInitialized());
 
   // Read data from the reader, again.
   std::string second_content;
   ASSERT_EQ(net::OK, test_util::ReadAllData(reader.get(), &second_content));
   EXPECT_EQ(0u, second_content.size());
 }
 
 }  // namespace drive