[fsp] Improve performance for reading small chunks of data.

chrome/browser/chromeos/file_system_provider/fileapi/buffering_file_stream_reader_unittest.cc

Index: chrome/browser/chromeos/file_system_provider/fileapi/buffering_file_stream_reader_unittest.cc
diff --git a/chrome/browser/chromeos/file_system_provider/fileapi/buffering_file_stream_reader_unittest.cc b/chrome/browser/chromeos/file_system_provider/fileapi/buffering_file_stream_reader_unittest.cc
index ff3ac4b49d42ec9b50e71e81ee7b3e5d64b919f7..1a3ea7e0c76074a88d7ad1593750fe8a0f919226 100644
--- a/chrome/browser/chromeos/file_system_provider/fileapi/buffering_file_stream_reader_unittest.cc
+++ b/chrome/browser/chromeos/file_system_provider/fileapi/buffering_file_stream_reader_unittest.cc
@@ -10,6 +10,7 @@
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/run_loop.h"
 #include "chrome/browser/chromeos/file_system_provider/fileapi/buffering_file_stream_reader.h"
+#include "chrome/browser/chromeos/fileapi/file_system_backend.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
@@ -23,7 +24,7 @@ namespace {
 const int kFileSize = 1024;
 
 // Size of the preloading buffer in bytes.
-const int kBufferSize = 8;
+const int kPreloadingBufferLength = 8;
 
 // Number of bytes requested per BufferingFileStreamReader::Read().
 const int kChunkSize = 3;
@@ -91,7 +92,8 @@ TEST_F(FileSystemProviderBufferingFileStreamReaderTest, Read) {
   BufferingFileStreamReader reader(
       scoped_ptr<storage::FileStreamReader>(
           new FakeFileStreamReader(&inner_read_log, net::OK)),
-      kBufferSize);
+      kPreloadingBufferLength,
+      kFileSize);
 
   // For the first read, the internal file stream reader is fired, as there is
   // no data in the preloading buffer.
@@ -104,7 +106,7 @@ TEST_F(FileSystemProviderBufferingFileStreamReaderTest, Read) {
 
     EXPECT_EQ(net::ERR_IO_PENDING, result);
     ASSERT_EQ(1u, inner_read_log.size());
-    EXPECT_EQ(kBufferSize, inner_read_log[0]);
+    EXPECT_EQ(kPreloadingBufferLength, inner_read_log[0]);
     ASSERT_EQ(1u, read_log.size());
     EXPECT_EQ(kChunkSize, read_log[0]);
   }
@@ -135,7 +137,7 @@ TEST_F(FileSystemProviderBufferingFileStreamReaderTest, Read) {
         buffer.get(), kChunkSize, base::Bind(&LogValue<int>, &read_log));
     base::RunLoop().RunUntilIdle();
 
-    EXPECT_EQ(kBufferSize - 2 * kChunkSize, result);
+    EXPECT_EQ(kPreloadingBufferLength - 2 * kChunkSize, result);
     EXPECT_EQ(0u, inner_read_log.size());
     // Results returned synchronously, so no new read result events.
     EXPECT_EQ(0u, read_log.size());
@@ -153,7 +155,7 @@ TEST_F(FileSystemProviderBufferingFileStreamReaderTest, Read) {
 
     EXPECT_EQ(net::ERR_IO_PENDING, result);
     ASSERT_EQ(1u, inner_read_log.size());
-    EXPECT_EQ(kBufferSize, inner_read_log[0]);
+    EXPECT_EQ(kPreloadingBufferLength, inner_read_log[0]);
     ASSERT_EQ(1u, read_log.size());
     EXPECT_EQ(kChunkSize, read_log[0]);
   }
@@ -164,7 +166,8 @@ TEST_F(FileSystemProviderBufferingFileStreamReaderTest, Read_Directly) {
   BufferingFileStreamReader reader(
       scoped_ptr<storage::FileStreamReader>(
           new FakeFileStreamReader(&inner_read_log, net::OK)),
-      kBufferSize);
+      kPreloadingBufferLength,
+      kFileSize);
 
   // First read couple of bytes, so the internal buffer is filled out.
   {
@@ -176,12 +179,12 @@ TEST_F(FileSystemProviderBufferingFileStreamReaderTest, Read_Directly) {
 
     EXPECT_EQ(net::ERR_IO_PENDING, result);
     ASSERT_EQ(1u, inner_read_log.size());
-    EXPECT_EQ(kBufferSize, inner_read_log[0]);
+    EXPECT_EQ(kPreloadingBufferLength, inner_read_log[0]);
     ASSERT_EQ(1u, read_log.size());
     EXPECT_EQ(kChunkSize, read_log[0]);
   }
 
-  const int read_bytes = kBufferSize * 2;
+  const int read_bytes = kPreloadingBufferLength * 2;
   ASSERT_GT(kFileSize, read_bytes);
 
   // Reading more than the internal buffer size would cause fetching only
@@ -194,7 +197,7 @@ TEST_F(FileSystemProviderBufferingFileStreamReaderTest, Read_Directly) {
         buffer.get(), read_bytes, base::Bind(&LogValue<int>, &read_log));
     base::RunLoop().RunUntilIdle();
 
-    EXPECT_EQ(kBufferSize - kChunkSize, result);
+    EXPECT_EQ(kPreloadingBufferLength - kChunkSize, result);
     EXPECT_EQ(0u, inner_read_log.size());
     EXPECT_EQ(0u, read_log.size());
   }
@@ -224,7 +227,8 @@ TEST_F(FileSystemProviderBufferingFileStreamReaderTest,
   BufferingFileStreamReader reader(
       scoped_ptr<storage::FileStreamReader>(
           new FakeFileStreamReader(&inner_read_log, net::OK)),
-      kBufferSize);
+      kPreloadingBufferLength,
+      kFileSize);
   // First read couple of bytes, so the internal buffer is filled out.
   {
     scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kChunkSize));
@@ -235,7 +239,7 @@ TEST_F(FileSystemProviderBufferingFileStreamReaderTest,
 
     EXPECT_EQ(net::ERR_IO_PENDING, result);
     ASSERT_EQ(1u, inner_read_log.size());
-    EXPECT_EQ(kBufferSize, inner_read_log[0]);
+    EXPECT_EQ(kPreloadingBufferLength, inner_read_log[0]);
     ASSERT_EQ(1u, read_log.size());
     EXPECT_EQ(kChunkSize, read_log[0]);
   }
@@ -245,7 +249,7 @@ TEST_F(FileSystemProviderBufferingFileStreamReaderTest,
   {
     inner_read_log.clear();
     const int chunk_size = 20;
-    ASSERT_LT(kBufferSize, chunk_size);
+    ASSERT_LT(kPreloadingBufferLength, chunk_size);
     scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(chunk_size));
     std::vector<int> read_log;
     const int result = reader.Read(
@@ -258,12 +262,70 @@ TEST_F(FileSystemProviderBufferingFileStreamReaderTest,
   }
 }
 
+TEST_F(FileSystemProviderBufferingFileStreamReaderTest,
+       Read_LessThanBufferSize) {
+  std::vector<int> inner_read_log;
+  const int total_bytes_to_read = 3;
+  ASSERT_LT(total_bytes_to_read, kPreloadingBufferLength);
+  BufferingFileStreamReader reader(
+      scoped_ptr<storage::FileStreamReader>(
+          new FakeFileStreamReader(&inner_read_log, net::OK)),
+      kPreloadingBufferLength,
+      total_bytes_to_read);
+
+  // For the first read, the internal file stream reader is fired, as there is
+  // no data in the preloading buffer.
+  const int read_bytes = 2;
+  ASSERT_LT(read_bytes, kPreloadingBufferLength);
+  ASSERT_LE(read_bytes, total_bytes_to_read);
+
+  scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(read_bytes));
+  std::vector<int> read_log;
+  const int result =
+      reader.Read(buffer, read_bytes, base::Bind(&LogValue<int>, &read_log));
+  base::RunLoop().RunUntilIdle();
+
+  EXPECT_EQ(net::ERR_IO_PENDING, result);
+  ASSERT_EQ(1u, inner_read_log.size());
+  EXPECT_EQ(total_bytes_to_read, inner_read_log[0]);
+  ASSERT_EQ(1u, read_log.size());
+  EXPECT_EQ(read_bytes, read_log[0]);
+}
+
+TEST_F(FileSystemProviderBufferingFileStreamReaderTest,
+       Read_LessThanBufferSize_WithoutSpecifiedLength) {
+  std::vector<int> inner_read_log;
+  BufferingFileStreamReader reader(
+      scoped_ptr<storage::FileStreamReader>(
+          new FakeFileStreamReader(&inner_read_log, net::OK)),
+      kPreloadingBufferLength,
+      storage::kMaximumLength);
+
+  // For the first read, the internal file stream reader is fired, as there is
+  // no data in the preloading buffer.
+  const int read_bytes = 2;
+  ASSERT_LT(read_bytes, kPreloadingBufferLength);
+
+  scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(read_bytes));
+  std::vector<int> read_log;
+  const int result =
+      reader.Read(buffer, read_bytes, base::Bind(&LogValue<int>, &read_log));
+  base::RunLoop().RunUntilIdle();
+
+  EXPECT_EQ(net::ERR_IO_PENDING, result);
+  ASSERT_EQ(1u, inner_read_log.size());
+  EXPECT_EQ(kPreloadingBufferLength, inner_read_log[0]);
+  ASSERT_EQ(1u, read_log.size());
+  EXPECT_EQ(read_bytes, read_log[0]);
+}
+
 TEST_F(FileSystemProviderBufferingFileStreamReaderTest, Read_WithError) {
   std::vector<int> inner_read_log;
   BufferingFileStreamReader reader(
       scoped_ptr<storage::FileStreamReader>(
           new FakeFileStreamReader(&inner_read_log, net::ERR_ACCESS_DENIED)),
-      kBufferSize);
+      kPreloadingBufferLength,
+      kFileSize);
 
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kChunkSize));
   std::vector<int> read_log;
@@ -273,7 +335,7 @@ TEST_F(FileSystemProviderBufferingFileStreamReaderTest, Read_WithError) {
 
   EXPECT_EQ(net::ERR_IO_PENDING, result);
   ASSERT_EQ(1u, inner_read_log.size());
-  EXPECT_EQ(kBufferSize, inner_read_log[0]);
+  EXPECT_EQ(kPreloadingBufferLength, inner_read_log[0]);
   ASSERT_EQ(1u, read_log.size());
   EXPECT_EQ(net::ERR_ACCESS_DENIED, read_log[0]);
 }
@@ -281,7 +343,8 @@ TEST_F(FileSystemProviderBufferingFileStreamReaderTest, Read_WithError) {
 TEST_F(FileSystemProviderBufferingFileStreamReaderTest, GetLength) {
   BufferingFileStreamReader reader(scoped_ptr<storage::FileStreamReader>(
                                        new FakeFileStreamReader(NULL, net::OK)),
-                                   kBufferSize);
+                                   kPreloadingBufferLength,
+                                   kFileSize);
 
   std::vector<int64> get_length_log;
   const int64 result =