Fix failure of reading zero-byte files on Drive via StreamReader.

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 17 matching lines @@
 int FileErrorToNetError(FileError error) {
   return net::PlatformFileErrorToNetError(FileErrorToPlatformError(error));
 }
 
 // Runs task on UI thread.
 void RunTaskOnUIThread(const base::Closure& task) {
   google_apis::RunTaskOnThread(
       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI), task);
 }
 
+// Computes the concrete |start| offset and the |length| of |range| in a file
+// of |total| size.
+//
+// This is a thin wrapper of HttpByteRange::ComputeBounds, extended to allow
+// an empty range at the end of the file, like "Range: bytes 0-" on a zero byte
+// file. This is for convenience in unifying implementation with the seek
+// operation of stream reader. HTTP doesn't allow such ranges but we want to
+// treat such seeking as valid.
+bool ComputeConcretePosition(net::HttpByteRange range, int64 total,
+                             int64* start, int64* length) {
+  // The special case when empty range in the end of the file is selected.
+  if (range.HasFirstBytePosition() && range.first_byte_position() == total) {
+    *start = range.first_byte_position();
+    *length = 0;
+    return true;
+  }
+
+  // Otherwise forward to HttpByteRange::ComputeBounds.
+  if (!range.ComputeBounds(total))
+    return false;
+  *start = range.first_byte_position();
+  *length = range.last_byte_position() - range.first_byte_position() + 1;
+  return true;
+}
+
 }  // namespace
 
 namespace internal {
 namespace {
 
 // Copies the content in |pending_data| into |buffer| at most
 // |buffer_length| bytes, and erases the copied data from
 // |pending_data|. Returns the number of copied bytes.
 int ReadInternal(ScopedVector<std::string>* pending_data,
                  net::IOBuffer* buffer, int buffer_length) {
@@ skipping 284 matching lines @@
 int DriveFileStreamReader::Read(net::IOBuffer* buffer, int buffer_length,
                                 const net::CompletionCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(reader_proxy_);
   DCHECK(buffer);
   DCHECK(!callback.is_null());
   return reader_proxy_->Read(buffer, buffer_length, callback);
 }
 
 void DriveFileStreamReader::InitializeAfterGetFileContentInitialized(
-    const net::HttpByteRange& in_byte_range,
+    const net::HttpByteRange& byte_range,
     const InitializeCompletionCallback& callback,
     FileError error,
     scoped_ptr<ResourceEntry> entry,
     const base::FilePath& local_cache_file_path,
     const base::Closure& ui_cancel_download_closure) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (error != FILE_ERROR_OK) {
     callback.Run(FileErrorToNetError(error), scoped_ptr<ResourceEntry>());
     return;
   }
   DCHECK(entry);
 
-  net::HttpByteRange byte_range = in_byte_range;
-  if (!byte_range.ComputeBounds(entry->file_info().size())) {
+  int64 range_start = 0, range_length = 0;
+  if (!ComputeConcretePosition(byte_range, entry->file_info().size(),
+                               &range_start, &range_length)) {
     // If |byte_range| is invalid (e.g. out of bounds), return with an error.
     // At the same time, we cancel the in-flight downloading operation if
     // needed and and invalidate weak pointers so that we won't
     // receive unwanted callbacks.
     if (!ui_cancel_download_closure.is_null())
       RunTaskOnUIThread(ui_cancel_download_closure);
     weak_ptr_factory_.InvalidateWeakPtrs();
     callback.Run(
         net::ERR_REQUEST_RANGE_NOT_SATISFIABLE, scoped_ptr<ResourceEntry>());
     return;
   }
 
-  // Note: both boundary of |byte_range| are inclusive.
-  int64 range_length =
-      byte_range.last_byte_position() - byte_range.first_byte_position() + 1;
-  DCHECK_GE(range_length, 0);
-
   if (local_cache_file_path.empty()) {
     // The file is not cached, and being downloaded.
     DCHECK(!ui_cancel_download_closure.is_null());
     reader_proxy_.reset(
         new internal::NetworkReaderProxy(
-            byte_range.first_byte_position(), range_length,
+            range_start, range_length,
             base::Bind(&RunTaskOnUIThread, ui_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,
-      byte_range.first_byte_position(),
+      range_start,
       base::Bind(
           &DriveFileStreamReader::InitializeAfterLocalFileOpen,
           weak_ptr_factory_.GetWeakPtr(),
           range_length,
           callback,
           base::Passed(&entry),
           base::Passed(&file_reader)));
 }
 
 void DriveFileStreamReader::InitializeAfterLocalFileOpen(
@@ skipping 39 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