Remove retrial of reading from a cached file.

chrome/browser/chromeos/drive/drive_url_request_job.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_url_request_job.h"
 
 #include <algorithm>
 #include <cstring>
 #include <string>
 
@@ skipping 398 matching lines @@
   // Keep track of the buffer.
   DCHECK(!read_buf_);
   read_buf_ = dest;
   read_buf_remaining_.set(dest->data(), dest_size);
 
   bool rc = false;
   if (streaming_download_)
     rc = ContinueReadFromDownloadData(bytes_read);
   else
     rc = ContinueReadFromFile(bytes_read);
+
   DVLOG(1) << "ReadRawData: out with "
            << (rc ? "has" : "no")
            << "_data, bytes_read=" << *bytes_read
            << ", buf_remaining="
            << (read_buf_ ? read_buf_remaining_.size() : 0)
            << ", " << (streaming_download_ ? "download" : "file")
            << "_remaining=" << remaining_bytes_;
   return rc;
 }
 
@@ skipping 182 matching lines @@
 
   // Otherwise, we have data in read buffer, return true with number of bytes
   // read.
   *bytes_read = BytesReadCompleted();
   DVLOG(1) << "Has data: bytes_read=" << *bytes_read
            << ", buf_remaining=0, file_remaining=" << remaining_bytes_;
   return true;
 }
 
 void DriveURLRequestJob::ReadFromFile() {
-  int bytes_to_read = std::min(read_buf_remaining_.size(),
-                               static_cast<size_t>(remaining_bytes_));
-
   // If the stream already exists, keep reading from it.
   if (stream_.get()) {
-    ReadFileStream(bytes_to_read);
+    ReadFileStream();
     return;
   }
 
   // Otherwise, open the stream for file.
   stream_.reset(new net::FileStream(NULL));
   int result = stream_->Open(
       local_file_path_,
       base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_READ |
       base::PLATFORM_FILE_ASYNC,
       base::Bind(&DriveURLRequestJob::OnFileOpen,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 bytes_to_read));
+                 weak_ptr_factory_.GetWeakPtr()));
 
   if (result == net::ERR_IO_PENDING) {
     DVLOG(1) << "IO is pending for opening "
              << local_file_path_.BaseName().RemoveExtension().value();
     SetStatus(net::URLRequestStatus(net::URLRequestStatus::IO_PENDING, 0));
   } else {
     DCHECK_NE(result, net::OK);
     LOG(WARNING) << "Failed to open " << local_file_path_.value();
     NotifyFailure(net::ERR_FILE_NOT_FOUND);
   }
 }
 
-void DriveURLRequestJob::OnFileOpen(int bytes_to_read, int open_result) {
+void DriveURLRequestJob::OnFileOpen(int open_result) {
   if (open_result != net::OK) {
     LOG(WARNING) << "Failed to open " << local_file_path_.value();
     NotifyFailure(net::ERR_FILE_NOT_FOUND);
     return;
   }
 
   DVLOG(1) << "Successfully opened " << local_file_path_.value();
 
   // Read from opened file stream.
   DCHECK(stream_.get());
-  ReadFileStream(bytes_to_read);
+  ReadFileStream();
 }
 
-void DriveURLRequestJob::ReadFileStream(int bytes_to_read) {
+void DriveURLRequestJob::ReadFileStream() {
   DCHECK(stream_.get());
   DCHECK(stream_->IsOpen());
-  DCHECK_GE(static_cast<int>(read_buf_remaining_.size()), bytes_to_read);
 
+  int bytes_to_read = std::min(
+      read_buf_remaining_.size(), static_cast<size_t>(remaining_bytes_));
   int result = stream_->Read(read_buf_, bytes_to_read,
                              base::Bind(&DriveURLRequestJob::OnReadFileStream,
                                         weak_ptr_factory_.GetWeakPtr()));
 
   // If IO is pending, we just need to wait.
   if (result == net::ERR_IO_PENDING) {
     DVLOG(1) << "IO pending: bytes_to_read=" << bytes_to_read
              << ", buf_remaining=" << read_buf_remaining_.size()
              << ", file_remaining=" << remaining_bytes_;
     SetStatus(net::URLRequestStatus(net::URLRequestStatus::IO_PENDING, 0));
   } else {  // For all other errors, bail out.
     // Asynchronous read should not return result >= 0;
     // refer to net/base/file_stream_posix.cc.
     DCHECK(result < 0);
     LOG(WARNING) << "Failed to read " << local_file_path_.value();
     NotifyFailure(net::ERR_FAILED);
   }
 }
 
 void DriveURLRequestJob::OnReadFileStream(int bytes_read) {
   if (bytes_read <= 0) {
     LOG(WARNING) << "Failed to read " << local_file_path_.value();
     NotifyFailure(net::ERR_FAILED);
     return;
   }
 
   SetStatus(net::URLRequestStatus());  // Clear the IO_PENDING status.
-
   RecordBytesRead(bytes_read);
-
   DVLOG(1) << "Cleared IO pending: bytes_read=" << bytes_read
            << ", buf_remaining=" << read_buf_remaining_.size()
            << ", file_remaining=" << remaining_bytes_;
 
-  // If the read buffer is completely filled, we're done.
-  if (read_buf_remaining_.empty()) {
-    int bytes_read = BytesReadCompleted();
-    DVLOG(1) << "Completed read: bytes_read=" << bytes_read
-             << ", file_remaining=" << remaining_bytes_;
-    NotifyReadComplete(bytes_read);
-    return;
-  }
-
-  // Otherwise, continue the reading.
-  int new_bytes_read = 0;
-  if (ContinueReadFromFile(&new_bytes_read)) {
-    DVLOG(1) << "Completed read: bytes_read=" << bytes_read
-             << ", file_remaining=" << remaining_bytes_;
-    NotifyReadComplete(new_bytes_read);
-  }
+  // Regardless of whether the buffer is still remaining or not,
+  // notify the client that some data is available in the buffer.
+  BytesReadCompleted();  // Release |read_buf_|.
+  DVLOG(1) << "Completed read: bytes_read=" << bytes_read
+           << ", file_remaining=" << remaining_bytes_;
+  NotifyReadComplete(bytes_read);
 }
 
 int DriveURLRequestJob::BytesReadCompleted() {
   int bytes_read = read_buf_remaining_.data() - read_buf_->data();
   read_buf_ = NULL;
   read_buf_remaining_.clear();
   return bytes_read;
 }
 
 void DriveURLRequestJob::RecordBytesRead(int bytes_read) {
@@ skipping 77 matching lines @@
   response_info_.reset(new net::HttpResponseInfo());
   response_info_->headers = headers;
 
   set_expected_content_size(remaining_bytes_);
   headers_set_ = true;
 
   NotifyHeadersComplete();
 }
 
 }  // namespace drive