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 24 matching lines @@
   if (detached_)
     Close();
   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,
+    int64_t offset,
     const std::string& hash_so_far,
-    std::unique_ptr<crypto::SecureHash> hash_state) {
+    std::unique_ptr<crypto::SecureHash> hash_state,
+    AccessMode access_mode) {
   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;
+  access_mode_ = access_mode;
+  offset_ = offset;
+  if (access_mode_ == EXCLUSIVE)
+    bytes_so_far_ = offset;
   secure_hash_ = std::move(hash_state);
   file_ = std::move(file);
 
   return Open(hash_so_far);
 }
 
-DownloadInterruptReason BaseFile::AppendDataToFile(const char* data,
-                                                   size_t data_len) {
+DownloadInterruptReason BaseFile::WriteDataToFile(const char* data,
+                                                  size_t data_len) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   DCHECK(!detached_);
 
   // 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,
@@ skipping 15 matching lines @@
 
     // 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;
+    offset_ += write_size;
     bytes_so_far_ += write_size;
   }
   net_log_.EndEvent(net::NetLogEventType::DOWNLOAD_FILE_WRITTEN,
                     net::NetLog::Int64Callback("bytes", data_len));
 
   if (secure_hash_)

[xingliu, 2017/02/15 19:13:20]

Maybe add DCHECK(access_mode_ == AccessMode::EXCLUSIVE);

[qinmin, 2017/02/15 20:00:43]

secure_hash_ is non null, so this should be in the if condition, rather than a
DCHECK.

[xingliu, 2017/02/15 20:43:57]

Got it, sorry I thought in EXCLUSIVE mode there will be no secure_hash_
computation.

     secure_hash_->Update(data, data_len);
 
   return DOWNLOAD_INTERRUPT_REASON_NONE;
 }
 
 DownloadInterruptReason BaseFile::Rename(const base::FilePath& new_path) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   DownloadInterruptReason rename_result = DOWNLOAD_INTERRUPT_REASON_NONE;
 
   // If the new path is same as the old one, there is no need to perform the
@@ skipping 57 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   Close();
   return std::move(secure_hash_);
 }
 
 std::string BaseFile::DebugString() const {
   return base::StringPrintf(
       "{ "
       " full_path_ = \"%" PRFilePath
       "\""
-      " bytes_so_far_ = %" PRId64 " detached_ = %c }",
-      full_path_.value().c_str(),
-      bytes_so_far_,
-      detached_ ? 'T' : 'F');
+      " offset_ = %" PRId64 " detached_ = %c }",
+      full_path_.value().c_str(), offset_, detached_ ? 'T' : 'F');
 }
 
 DownloadInterruptReason BaseFile::CalculatePartialHash(
     const std::string& hash_to_expect) {
   secure_hash_ = crypto::SecureHash::Create(crypto::SecureHash::SHA256);
 
-  if (bytes_so_far_ == 0)
+  if (access_mode_ == SHARED)
+    return DOWNLOAD_INTERRUPT_REASON_NONE;
+
+  if (offset_ == 0)
     return DOWNLOAD_INTERRUPT_REASON_NONE;
 
   if (file_.Seek(base::File::FROM_BEGIN, 0) != 0)
     return LogSystemError("Seek partial file",
                           logging::GetLastSystemErrorCode());
 
   const size_t kMinBufferSize = secure_hash_->GetHashLength();
   const size_t kMaxBufferSize = 1024 * 512;
   static_assert(kMaxBufferSize <= std::numeric_limits<int>::max(),
                 "kMaxBufferSize must fit on an int");
 
   // The size of the buffer is:
   // - at least kMinBufferSize so that we can use it to hold the hash as well.
   // - at most kMaxBufferSize so that there's a reasonable bound.
-  // - not larger than |bytes_so_far_| unless bytes_so_far_ is less than the
-  //   hash size.
+  // - not larger than |offset_| unless |offset_| is less than the hash size.
   std::vector<char> buffer(std::max<int64_t>(
-      kMinBufferSize, std::min<int64_t>(kMaxBufferSize, bytes_so_far_)));
+      kMinBufferSize, std::min<int64_t>(kMaxBufferSize, offset_)));
 
   int64_t current_position = 0;
-  while (current_position < bytes_so_far_) {
+  while (current_position < offset_) {
     // While std::min needs to work with int64_t, the result is always at most
     // kMaxBufferSize, which fits on an int.
     int bytes_to_read =
-        std::min<int64_t>(buffer.size(), bytes_so_far_ - current_position);
+        std::min<int64_t>(buffer.size(), offset_ - current_position);
     int length = file_.ReadAtCurrentPos(&buffer.front(), bytes_to_read);
     if (length == -1) {
       return LogInterruptReason("Reading partial file",
                                 logging::GetLastSystemErrorCode(),
                                 DOWNLOAD_INTERRUPT_REASON_FILE_TOO_SHORT);
     }
 
     if (length == 0)
       break;
 
     secure_hash_->Update(&buffer.front(), length);
     current_position += length;
   }
 
-  if (current_position != bytes_so_far_) {
+  if (current_position != offset_) {
     return LogInterruptReason(
         "Verifying prefix hash", 0, DOWNLOAD_INTERRUPT_REASON_FILE_TOO_SHORT);
   }
 
   if (!hash_to_expect.empty()) {
     DCHECK_EQ(secure_hash_->GetHashLength(), hash_to_expect.size());
     DCHECK(buffer.size() >= secure_hash_->GetHashLength());
     std::unique_ptr<crypto::SecureHash> partial_hash(secure_hash_->Clone());
     partial_hash->Finish(&buffer.front(), buffer.size());
 
@@ skipping 20 matching lines @@
                      base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_WRITE |
                          base::File::FLAG_READ);
     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_));
+      base::Bind(&FileOpenedNetLogCallback, &full_path_, offset_));
+
+  if (access_mode_ == SHARED) {
+    if (file_.Seek(base::File::FROM_BEGIN, offset_) < 0) {
+      logging::SystemErrorCode error = logging::GetLastSystemErrorCode();
+      ClearFile();
+      return LogSystemError("Seeking to end", error);
+    }
+    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) {
     logging::SystemErrorCode error = logging::GetLastSystemErrorCode();
     ClearFile();
     return LogSystemError("Seeking to end", error);
-  } else if (file_size > bytes_so_far_) {
+  } else if (file_size > offset_) {
     // The file is larger than we expected.
     // This is OK, as long as we don't use the extra.
     // Truncate the file.
-    if (!file_.SetLength(bytes_so_far_) ||
-        file_.Seek(base::File::FROM_BEGIN, bytes_so_far_) != bytes_so_far_) {
+    if (!file_.SetLength(offset_) ||
+        file_.Seek(base::File::FROM_BEGIN, offset_) != offset_) {
       logging::SystemErrorCode error = logging::GetLastSystemErrorCode();
       ClearFile();
       return LogSystemError("Truncating to last known offset", error);
     }
-  } else if (file_size < bytes_so_far_) {
+  } else if (file_size < offset_) {
     // The file is shorter than we expected.  Our hashes won't be valid.
     ClearFile();
     return LogInterruptReason("Unable to seek to last written point", 0,
                               DOWNLOAD_INTERRUPT_REASON_FILE_TOO_SHORT);
   }
 
   return DOWNLOAD_INTERRUPT_REASON_NONE;
 }
 
 void BaseFile::Close() {
@@ skipping 131 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