[fsp] Introduce BufferingFileStreamReader to read files in bigger chunks.

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

+// Copyright 2014 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/file_system_provider/fileapi/buffering_file_stream_reader.h"
+
+#include "net/base/net_errors.h"
+
+namespace chromeos {
+namespace file_system_provider {
+
+BufferingFileStreamReader::BufferingFileStreamReader(
+    scoped_ptr<webkit_blob::FileStreamReader> file_stream_reader,
+    int buffer_size)
+    : file_stream_reader_(file_stream_reader.Pass()),
+      buffer_size_(buffer_size),
+      preloading_buffer_(new net::IOBuffer(buffer_size_)),
+      preloading_buffer_offset_(0),
+      buffered_bytes_(0),
+      weak_ptr_factory_(this) {
+}
+
+BufferingFileStreamReader::~BufferingFileStreamReader() {
+}
+
+int BufferingFileStreamReader::Read(net::IOBuffer* buffer,
+                                    int buffer_length,
+                                    const net::CompletionCallback& callback) {
+  // Return as much as available in the internal buffer. It may be less than
+  // |buffer_length|, what is valid.
+  const int bytes_read =
+      CopyFromBuffer(make_scoped_refptr(buffer), buffer_length);
+  if (bytes_read)
+    return bytes_read;
+
+  // Nothing copied, so contents have to be preloaded.
+  Preload(base::Bind(&BufferingFileStreamReader::OnPreloadCompleted,
+                     weak_ptr_factory_.GetWeakPtr(),
+                     make_scoped_refptr(buffer),
+                     buffer_length,
+                     callback));
+
+  return net::ERR_IO_PENDING;
+}
+
+int64 BufferingFileStreamReader::GetLength(
+    const net::Int64CompletionCallback& callback) {
+  return file_stream_reader_->GetLength(callback);
+}
+
+int BufferingFileStreamReader::CopyFromBuffer(
+    scoped_refptr<net::IOBuffer> buffer,
+    int buffer_length) {
+  const int read_bytes =
+      buffer_length <= buffered_bytes_ ? buffer_length : buffered_bytes_;

[hashimoto, 2014/06/05 03:18:36]

nit: std::min(buffer_length, buffered_bytes_)?

[mtomasz, 2014/06/05 09:22:27]

Done.

+
+  memcpy(buffer->data(),
+         preloading_buffer_->data() + preloading_buffer_offset_,
+         read_bytes);
+  preloading_buffer_offset_ += read_bytes;
+  buffered_bytes_ -= read_bytes;
+
+  return read_bytes;
+}
+
+void BufferingFileStreamReader::Preload(
+    const net::CompletionCallback& callback) {
+  // TODO(mtomasz): Dynamically calculate the chunk size. Start from a small
+  // one, then increase for consecutive requests. That would improve performance
+  // when reading just small chunks, instead of the entire file.
+  const int preload_bytes = buffer_size_;
+
+  const int result =
+      file_stream_reader_->Read(preloading_buffer_, preload_bytes, callback);
+
+  if (result != net::ERR_IO_PENDING)
+    callback.Run(result);

[hashimoto, 2014/06/05 03:18:36]

Return the result as a return value, or post a task to run the callback.
Returning ERR_IO_PENDING after running the callback with the result may cause
problems in user code.
(e.g. BlobURLRequestJob::ReadFileItem() may call SetStatus() with
net::URLRequestStatus::IO_PENDING after the result was returning through the
callback
https://code.google.com/p/chromium/codesearch#chromium/src/webkit/browser/blo...)

[mtomasz, 2014/06/05 09:22:27]

Done.

+}
+
+void BufferingFileStreamReader::OnPreloadCompleted(
+    scoped_refptr<net::IOBuffer> buffer,
+    int buffer_length,
+    const net::CompletionCallback& callback,
+    int result) {
+  if (result < 0) {
+    callback.Run(result);
+    return;
+  }
+
+  preloading_buffer_offset_ = 0;
+  buffered_bytes_ = result;
+
+  callback.Run(CopyFromBuffer(buffer, buffer_length));
+}
+
+}  // namespace file_system_provider
+}  // namespace chromeos