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 321 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())) {
+  // Note: both boundary of |byte_range| are inclusive.
+  // Convert it to half-exclusive range with missing bounds filled.

[hashimoto, 2013/12/19 08:53:40]

Is it OK to ignore suffix byte range?

[kinaba, 2013/12/20 03:57:55]

Good catch. Recovered the support for suffix range by
delegating the impl to HttpByteRange except for the corner case.

+  const int64 range_start = byte_range.HasFirstBytePosition() ?
+      byte_range.first_byte_position() : 0;
+  const int64 range_end = byte_range.HasLastBytePosition() ?
+      byte_range.last_byte_position() + 1 : entry->file_info().size();
+
+  if (range_start > range_end || entry->file_info().size() < range_end) {
     // 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_end - range_start,
             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,
+          range_end - range_start,
           callback,
           base::Passed(&entry),
           base::Passed(&file_reader)));
 }
 
 void DriveFileStreamReader::InitializeAfterLocalFileOpen(
     int64 length,
     const InitializeCompletionCallback& callback,
     scoped_ptr<ResourceEntry> entry,
     scoped_ptr<util::LocalFileReader> file_reader,
@@ skipping 35 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