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

chrome/browser/chromeos/drive/drive_file_stream_reader.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 <algorithm>
 #include <cstring>
 
 #include "base/callback_helpers.h"
@@ skipping 134 matching lines @@
   } else {
     // An error occurs. Close the |file_reader_|.
     file_reader_.reset();
   }
   callback.Run(read_result);
 }
 
 NetworkReaderProxy::NetworkReaderProxy(
     int64 offset,
     int64 content_length,
+    int64 full_content_length,
     const base::Closure& job_canceller)
     : remaining_offset_(offset),
       remaining_content_length_(content_length),
+      is_full_download_(offset + content_length == full_content_length),
       error_code_(net::OK),
       buffer_length_(0),
       job_canceller_(job_canceller) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 }
 
 NetworkReaderProxy::~NetworkReaderProxy() {
   if (!job_canceller_.is_null()) {
     job_canceller_.Run();
   }
@@ skipping 30 matching lines @@
     // No data is available. Keep the arguments, and return pending status.
     buffer_ = buffer;
     buffer_length_ = buffer_length;
     callback_ = callback;
     return net::ERR_IO_PENDING;
   }
 
   int result = ReadInternal(&pending_data_, buffer, buffer_length);
   remaining_content_length_ -= result;
   DCHECK_GE(remaining_content_length_, 0);
+
+  // Although OnCompleted() should reset |job_canceller_| when download is done,
+  // due to timing issues the ReaderProxy instance may be destructed before the
+  // notification. To fix the case we reset here earlier.
+  if (is_full_download_ && remaining_content_length_ == 0)
+    job_canceller_.Reset();
+
   return result;
 }
 
 void NetworkReaderProxy::OnGetContent(scoped_ptr<std::string> data) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(data && !data->empty());
 
   if (remaining_offset_ >= static_cast<int64>(data->length())) {
     // Skip unneeded leading data.
     remaining_offset_ -= data->length();
     return;
   }
 
   if (remaining_offset_ > 0) {
     // Erase unnecessary leading bytes.
     data->erase(0, static_cast<size_t>(remaining_offset_));
     remaining_offset_ = 0;
   }
 
   pending_data_.push_back(data.release());
   if (!buffer_.get()) {
     // No pending Read operation.
     return;
   }
 
   int result = ReadInternal(&pending_data_, buffer_.get(), buffer_length_);
   remaining_content_length_ -= result;
   DCHECK_GE(remaining_content_length_, 0);
 
+  if (is_full_download_ && remaining_content_length_ == 0)
+    job_canceller_.Reset();
+
   buffer_ = NULL;
   buffer_length_ = 0;
   DCHECK(!callback_.is_null());
   base::ResetAndReturn(&callback_).Run(result);
 }
 
 void NetworkReaderProxy::OnCompleted(FileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   // The downloading is completed, so we do not need to cancel the job
   // in the destructor.
@@ skipping 151 matching lines @@
     weak_ptr_factory_.InvalidateWeakPtrs();
     callback.Run(
         net::ERR_REQUEST_RANGE_NOT_SATISFIABLE, scoped_ptr<ResourceEntry>());
     return;
   }
 
   if (local_cache_file_path.empty()) {
     // The file is not cached, and being downloaded.
     reader_proxy_.reset(
         new internal::NetworkReaderProxy(
-            range_start, range_length, cancel_download_closure_));
+            range_start, range_length,
+            entry->file_info().size(), cancel_download_closure_));
     callback.Run(net::OK, entry.Pass());
     return;
   }
 
   // Otherwise, open the stream for file.
   scoped_ptr<util::LocalFileReader> file_reader(
       new util::LocalFileReader(file_task_runner_.get()));
   util::LocalFileReader* file_reader_ptr = file_reader.get();
   file_reader_ptr->Open(
       local_cache_file_path,
@@ skipping 50 matching lines @@
     // Note: due to the same reason, LocalReaderProxy::OnCompleted may
     // or may not be called. This is timing issue, and it is difficult to avoid
     // unfortunately.
     if (error != FILE_ERROR_OK) {
       callback.Run(FileErrorToNetError(error), scoped_ptr<ResourceEntry>());
     }
   }
 }
 
 }  // namespace drive