Refactor BaseFile class to support sparse files

content/browser/download/base_file.cc

 // Copyright (c) 2012 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 "content/browser/download/base_file.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/file.h"
@@ skipping 26 matching lines @@
   else
     Cancel();  // Will delete the file.
 }
 
 DownloadInterruptReason BaseFile::Initialize(
     const base::FilePath& full_path,
     const base::FilePath& default_directory,
     base::File file,
     int64_t bytes_so_far,
     const std::string& hash_so_far,
-    std::unique_ptr<crypto::SecureHash> hash_state) {
+    std::unique_ptr<crypto::SecureHash> hash_state,
+    bool is_sparse_file) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   DCHECK(!detached_);
 
   if (full_path.empty()) {
     base::FilePath initial_directory(default_directory);
     base::FilePath temp_file;
     if (initial_directory.empty()) {
       initial_directory =
           GetContentClient()->browser()->GetDefaultDownloadDirectory();
     }
     // |initial_directory| can still be empty if ContentBrowserClient returned
     // an empty path for the downloads directory.
     if ((initial_directory.empty() ||
          !base::CreateTemporaryFileInDir(initial_directory, &temp_file)) &&
         !base::CreateTemporaryFile(&temp_file)) {
       return LogInterruptReason("Unable to create", 0,
                                 DOWNLOAD_INTERRUPT_REASON_FILE_FAILED);
     }
     full_path_ = temp_file;
   } else {
     full_path_ = full_path;
   }
 
   bytes_so_far_ = bytes_so_far;
   secure_hash_ = std::move(hash_state);
+  is_sparse_file_ = is_sparse_file;
+  DCHECK(!is_sparse_file_ || !secure_hash_);
   file_ = std::move(file);
 
   return Open(hash_so_far);
 }
 
 DownloadInterruptReason BaseFile::AppendDataToFile(const char* data,
                                                    size_t data_len) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
-  DCHECK(!detached_);
+  DCHECK(!is_sparse_file_);
+  return WriteDataToFile(bytes_so_far_, data, data_len);
+}
 
+DownloadInterruptReason BaseFile::WriteDataToFile(int64_t offset,
+                                                  const char* data,
+                                                  size_t data_len) {
   // NOTE(benwells): The above DCHECK won't be present in release builds,
   // so we log any occurences to see how common this error is in the wild.
   if (detached_)
     RecordDownloadCount(APPEND_TO_DETACHED_FILE_COUNT);
 
   if (!file_.IsValid())
     return LogInterruptReason("No file stream on append", 0,
                               DOWNLOAD_INTERRUPT_REASON_FILE_FAILED);
 
   // TODO(phajdan.jr): get rid of this check.
   if (data_len == 0)
     return DOWNLOAD_INTERRUPT_REASON_NONE;
 
-  // The Write call below is not guaranteed to write all the data.
-  size_t write_count = 0;
-  size_t len = data_len;
-  const char* current_data = data;
   net_log_.BeginEvent(net::NetLogEventType::DOWNLOAD_FILE_WRITTEN);
-  while (len > 0) {
-    write_count++;
-    int write_result = file_.WriteAtCurrentPos(current_data, len);
-    DCHECK_NE(0, write_result);
+  int write_result = file_.Write(offset, data, data_len);
+  DCHECK_NE(0, write_result);
 
-    // Report errors on file writes.
-    if (write_result < 0)
-      return LogSystemError("Write", logging::GetLastSystemErrorCode());
+  // Report errors on file writes.
+  if (write_result < 0)
+    return LogSystemError("Write", logging::GetLastSystemErrorCode());
 
-    // Update status.
-    size_t write_size = static_cast<size_t>(write_result);
-    DCHECK_LE(write_size, len);
-    len -= write_size;
-    current_data += write_size;
-    bytes_so_far_ += write_size;
-  }
+  DCHECK_EQ(static_cast<size_t>(write_result), data_len);
+  bytes_so_far_ += data_len;
   net_log_.EndEvent(net::NetLogEventType::DOWNLOAD_FILE_WRITTEN,
                     net::NetLog::Int64Callback("bytes", data_len));
 
   if (secure_hash_)
     secure_hash_->Update(data, data_len);
 
   return DOWNLOAD_INTERRUPT_REASON_NONE;
 }
 
 DownloadInterruptReason BaseFile::Rename(const base::FilePath& new_path) {
@@ skipping 52 matching lines @@
   if (!full_path_.empty()) {
     net_log_.AddEvent(net::NetLogEventType::DOWNLOAD_FILE_DELETED);
     base::DeleteFile(full_path_, false);
   }
 
   Detach();
 }
 
 std::unique_ptr<crypto::SecureHash> BaseFile::Finish() {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+
+  // TODO(qinmin): verify that all the holes have been filled.
+  if (is_sparse_file_)
+    CalculatePartialHash(std::string());
   Close();
   return std::move(secure_hash_);
 }
 
 std::string BaseFile::DebugString() const {
   return base::StringPrintf(
       "{ "
       " full_path_ = \"%" PRFilePath
       "\""
       " bytes_so_far_ = %" PRId64 " detached_ = %c }",
@@ skipping 82 matching lines @@
     if (!file_.IsValid()) {
       return LogNetError("Open/Initialize File",
                          net::FileErrorToNetError(file_.error_details()));
     }
   }
 
   net_log_.BeginEvent(
       net::NetLogEventType::DOWNLOAD_FILE_OPENED,
       base::Bind(&FileOpenedNetLogCallback, &full_path_, bytes_so_far_));
 
+  // For sparse file, skip hash validation.
+  if (is_sparse_file_) {
+    if (file_.GetLength() < bytes_so_far_) {
+      ClearFile();
+      return LogInterruptReason("File has fewer written bytes than expected", 0,
+                                DOWNLOAD_INTERRUPT_REASON_FILE_TOO_SHORT);
+    }
+    return DOWNLOAD_INTERRUPT_REASON_NONE;
+  }
+
   if (!secure_hash_) {
     DownloadInterruptReason reason = CalculatePartialHash(hash_so_far);
     if (reason != DOWNLOAD_INTERRUPT_REASON_NONE) {
       ClearFile();
       return reason;
     }
   }
 
   int64_t file_size = file_.Seek(base::File::FROM_END, 0);
   if (file_size < 0) {
@@ skipping 155 matching lines @@
 #else  // !OS_WIN && !OS_MACOSX && !OS_LINUX
 DownloadInterruptReason BaseFile::AnnotateWithSourceInformation(
     const std::string& client_guid,
     const GURL& source_url,
     const GURL& referrer_url) {
   return DOWNLOAD_INTERRUPT_REASON_NONE;
 }
 #endif
 
 }  // namespace content