Refactor BaseFile class to support sparse files

content/browser/download/base_file_unittest.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 <stddef.h>
 #include <stdint.h>
 #include <utility>
 
@@ skipping 48 matching lines @@
 
   void SetUp() override {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     base_file_.reset(new BaseFile(net::NetLogWithSource()));
   }
 
   void TearDown() override {
     EXPECT_FALSE(base_file_->in_progress());
     if (!expected_error_) {
       EXPECT_EQ(static_cast<int64_t>(expected_data_.size()),
-                base_file_->bytes_so_far());
+                base_file_->offset());
     }
 
     base::FilePath full_path = base_file_->full_path();
 
     if (!expected_data_.empty() && !expected_error_) {
       // Make sure the data has been properly written to disk.
       std::string disk_data;
       EXPECT_TRUE(base::ReadFileToString(full_path, &disk_data));
       EXPECT_EQ(expected_data_, disk_data);
     }
 
     // Make sure the mock BrowserThread outlives the BaseFile to satisfy
     // thread checks inside it.
     base_file_.reset();
 
     EXPECT_EQ(expect_file_survives_, base::PathExists(full_path));
   }
 
   bool InitializeFile() {
     DownloadInterruptReason result = base_file_->Initialize(
         base::FilePath(), temp_dir_.GetPath(), base::File(), 0, std::string(),
-        std::unique_ptr<crypto::SecureHash>());
+        std::unique_ptr<crypto::SecureHash>(), BaseFile::EXCLUSIVE);
     EXPECT_EQ(expected_error_, result);
     return result == DOWNLOAD_INTERRUPT_REASON_NONE;
   }
 
-  bool AppendDataToFile(const std::string& data) {
+  bool WriteDataToFile(const std::string& data) {
     EXPECT_EQ(expect_in_progress_, base_file_->in_progress());
     DownloadInterruptReason result =
-        base_file_->AppendDataToFile(data.data(), data.size());
+        base_file_->WriteDataToFile(data.data(), data.size());
     if (result == DOWNLOAD_INTERRUPT_REASON_NONE)
       EXPECT_TRUE(expect_in_progress_) << " result = " << result;
 
     EXPECT_EQ(expected_error_, result);
     if (base_file_->in_progress()) {
       expected_data_ += data;
       if (expected_error_ == DOWNLOAD_INTERRUPT_REASON_NONE) {
         EXPECT_EQ(static_cast<int64_t>(expected_data_.size()),
-                  base_file_->bytes_so_far());
+                  base_file_->offset());
       }
     }
     return result == DOWNLOAD_INTERRUPT_REASON_NONE;
   }
 
   void set_expected_data(const std::string& data) { expected_data_ = data; }
 
   // Helper functions.
   // Create a file.  Returns the complete file path.
   base::FilePath CreateTestFile() {
     base::FilePath file_name;
     BaseFile file((net::NetLogWithSource()));
 
     EXPECT_EQ(
         DOWNLOAD_INTERRUPT_REASON_NONE,
         file.Initialize(base::FilePath(), temp_dir_.GetPath(), base::File(), 0,
-                        std::string(), std::unique_ptr<crypto::SecureHash>()));
+                        std::string(), std::unique_ptr<crypto::SecureHash>(),
+                        BaseFile::EXCLUSIVE));
     file_name = file.full_path();
     EXPECT_NE(base::FilePath::StringType(), file_name.value());
 
     EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NONE,
-              file.AppendDataToFile(kTestData4, kTestDataLength4));
+              file.WriteDataToFile(kTestData4, kTestDataLength4));
 
     // Keep the file from getting deleted when existing_file_name is deleted.
     file.Detach();
 
     return file_name;
   }
 
   // Create a file with the specified file name.
   void CreateFileWithName(const base::FilePath& file_name) {
     EXPECT_NE(base::FilePath::StringType(), file_name.value());
     BaseFile duplicate_file((net::NetLogWithSource()));
     EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NONE,
               duplicate_file.Initialize(file_name, temp_dir_.GetPath(),
                                         base::File(), 0, std::string(),
-                                        std::unique_ptr<crypto::SecureHash>()));
+                                        std::unique_ptr<crypto::SecureHash>(),
+                                        BaseFile::EXCLUSIVE));
     // Write something into it.
-    duplicate_file.AppendDataToFile(kTestData4, kTestDataLength4);
+    duplicate_file.WriteDataToFile(kTestData4, kTestDataLength4);
     // Detach the file so it isn't deleted on destruction of |duplicate_file|.
     duplicate_file.Detach();
   }
 
   int64_t CurrentSpeedAtTime(base::TimeTicks current_time) {
     EXPECT_TRUE(base_file_.get());
     return base_file_->CurrentSpeedAtTime(current_time);
   }
 
   base::TimeTicks StartTick() {
@@ skipping 57 matching lines @@
   EXPECT_TRUE(base::PathExists(base_file_->full_path()));
   base_file_->Cancel();
   EXPECT_FALSE(base::PathExists(base_file_->full_path()));
   EXPECT_NE(base::FilePath().value(), base_file_->full_path().value());
 }
 
 // Write data to the file and detach it, so it doesn't get deleted
 // automatically when base_file_ is destructed.
 TEST_F(BaseFileTest, WriteAndDetach) {
   ASSERT_TRUE(InitializeFile());
-  ASSERT_TRUE(AppendDataToFile(kTestData1));
+  ASSERT_TRUE(WriteDataToFile(kTestData1));
   base_file_->Finish();
   base_file_->Detach();
   expect_file_survives_ = true;
 }
 
 // Write data to the file and detach it, and calculate its sha256 hash.
 TEST_F(BaseFileTest, WriteWithHashAndDetach) {
   ASSERT_TRUE(InitializeFile());
-  ASSERT_TRUE(AppendDataToFile(kTestData1));
+  ASSERT_TRUE(WriteDataToFile(kTestData1));
   ExpectHashValue(kHashOfTestData1, base_file_->Finish());
   base_file_->Detach();
   expect_file_survives_ = true;
 }
 
 // Rename the file after writing to it, then detach.
 TEST_F(BaseFileTest, WriteThenRenameAndDetach) {
   ASSERT_TRUE(InitializeFile());
 
   base::FilePath initial_path(base_file_->full_path());
   EXPECT_TRUE(base::PathExists(initial_path));
   base::FilePath new_path(temp_dir_.GetPath().AppendASCII("NewFile"));
   EXPECT_FALSE(base::PathExists(new_path));
 
-  ASSERT_TRUE(AppendDataToFile(kTestData1));
+  ASSERT_TRUE(WriteDataToFile(kTestData1));
 
   EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NONE, base_file_->Rename(new_path));
   EXPECT_FALSE(base::PathExists(initial_path));
   EXPECT_TRUE(base::PathExists(new_path));
 
   ExpectHashValue(kHashOfTestData1, base_file_->Finish());
   base_file_->Detach();
   expect_file_survives_ = true;
 }
 
 // Write data to the file once.
 TEST_F(BaseFileTest, SingleWrite) {
   ASSERT_TRUE(InitializeFile());
-  ASSERT_TRUE(AppendDataToFile(kTestData1));
+  ASSERT_TRUE(WriteDataToFile(kTestData1));
   ExpectHashValue(kHashOfTestData1, base_file_->Finish());
 }
 
 // Write data to the file multiple times.
 TEST_F(BaseFileTest, MultipleWrites) {
   ASSERT_TRUE(InitializeFile());
-  ASSERT_TRUE(AppendDataToFile(kTestData1));
-  ASSERT_TRUE(AppendDataToFile(kTestData2));
-  ASSERT_TRUE(AppendDataToFile(kTestData3));
+  ASSERT_TRUE(WriteDataToFile(kTestData1));
+  ASSERT_TRUE(WriteDataToFile(kTestData2));
+  ASSERT_TRUE(WriteDataToFile(kTestData3));
   ExpectHashValue(kHashOfTestData1To3, base_file_->Finish());
 }
 
 // Write data to the file multiple times, interrupt it, and continue using
 // another file.  Calculate the resulting combined sha256 hash.
 TEST_F(BaseFileTest, MultipleWritesInterruptedWithHash) {
   ASSERT_TRUE(InitializeFile());
   // Write some data
-  ASSERT_TRUE(AppendDataToFile(kTestData1));
-  ASSERT_TRUE(AppendDataToFile(kTestData2));
+  ASSERT_TRUE(WriteDataToFile(kTestData1));
+  ASSERT_TRUE(WriteDataToFile(kTestData2));
   // Get the hash state and file name.
   std::unique_ptr<crypto::SecureHash> hash_state = base_file_->Finish();
 
   base::FilePath new_file_path(temp_dir_.GetPath().Append(
       base::FilePath(FILE_PATH_LITERAL("second_file"))));
 
   ASSERT_TRUE(base::CopyFile(base_file_->full_path(), new_file_path));
 
   // Create another file
   BaseFile second_file((net::NetLogWithSource()));
   ASSERT_EQ(DOWNLOAD_INTERRUPT_REASON_NONE,
             second_file.Initialize(new_file_path,
                                    base::FilePath(),
                                    base::File(),
                                    base_file_->bytes_so_far(),
                                    std::string(),
-                                   std::move(hash_state)));
+                                   std::move(hash_state),
+                                   BaseFile::EXCLUSIVE));
   std::string data(kTestData3);
   EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NONE,
-            second_file.AppendDataToFile(data.data(), data.size()));
+            second_file.WriteDataToFile(data.data(), data.size()));
   ExpectHashValue(kHashOfTestData1To3, second_file.Finish());
 }
 
 // Rename the file after all writes to it.
 TEST_F(BaseFileTest, WriteThenRename) {
   ASSERT_TRUE(InitializeFile());
 
   base::FilePath initial_path(base_file_->full_path());
   EXPECT_TRUE(base::PathExists(initial_path));
   base::FilePath new_path(temp_dir_.GetPath().AppendASCII("NewFile"));
   EXPECT_FALSE(base::PathExists(new_path));
 
-  ASSERT_TRUE(AppendDataToFile(kTestData1));
+  ASSERT_TRUE(WriteDataToFile(kTestData1));
 
   EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NONE,
             base_file_->Rename(new_path));
   EXPECT_FALSE(base::PathExists(initial_path));
   EXPECT_TRUE(base::PathExists(new_path));
 
   ExpectHashValue(kHashOfTestData1, base_file_->Finish());
 }
 
 // Rename the file while the download is still in progress.
 TEST_F(BaseFileTest, RenameWhileInProgress) {
   ASSERT_TRUE(InitializeFile());
 
   base::FilePath initial_path(base_file_->full_path());
   EXPECT_TRUE(base::PathExists(initial_path));
   base::FilePath new_path(temp_dir_.GetPath().AppendASCII("NewFile"));
   EXPECT_FALSE(base::PathExists(new_path));
 
-  ASSERT_TRUE(AppendDataToFile(kTestData1));
+  ASSERT_TRUE(WriteDataToFile(kTestData1));
 
   EXPECT_TRUE(base_file_->in_progress());
   EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NONE, base_file_->Rename(new_path));
   EXPECT_FALSE(base::PathExists(initial_path));
   EXPECT_TRUE(base::PathExists(new_path));
 
-  ASSERT_TRUE(AppendDataToFile(kTestData2));
-  ASSERT_TRUE(AppendDataToFile(kTestData3));
+  ASSERT_TRUE(WriteDataToFile(kTestData2));
+  ASSERT_TRUE(WriteDataToFile(kTestData3));
 
   ExpectHashValue(kHashOfTestData1To3, base_file_->Finish());
 }
 
 // Test that a failed rename reports the correct error.
 TEST_F(BaseFileTest, RenameWithError) {
   ASSERT_TRUE(InitializeFile());
 
   // TestDir is a subdirectory in |temp_dir_| that we will make read-only so
   // that the rename will fail.
@@ skipping 17 matching lines @@
 TEST_F(BaseFileTest, RenameWithErrorInProgress) {
   ASSERT_TRUE(InitializeFile());
 
   base::FilePath test_dir(temp_dir_.GetPath().AppendASCII("TestDir"));
   ASSERT_TRUE(base::CreateDirectory(test_dir));
 
   base::FilePath new_path(test_dir.AppendASCII("TestFile"));
   EXPECT_FALSE(base::PathExists(new_path));
 
   // Write some data to start with.
-  ASSERT_TRUE(AppendDataToFile(kTestData1));
+  ASSERT_TRUE(WriteDataToFile(kTestData1));
   ASSERT_TRUE(base_file_->in_progress());
 
   base::FilePath old_path = base_file_->full_path();
 
   {
     base::FilePermissionRestorer restore_permissions_for(test_dir);
     ASSERT_TRUE(base::MakeFileUnwritable(test_dir));
     ExpectPermissionError(base_file_->Rename(new_path));
 
     // The file should still be open and we should be able to continue writing
     // to it.
     ASSERT_TRUE(base_file_->in_progress());
-    ASSERT_TRUE(AppendDataToFile(kTestData2));
+    ASSERT_TRUE(WriteDataToFile(kTestData2));
     ASSERT_EQ(old_path.value(), base_file_->full_path().value());
 
     // Try to rename again, just for kicks. It should still fail.
     ExpectPermissionError(base_file_->Rename(new_path));
   }
 
   // Now that TestDir is writeable again, we should be able to successfully
   // rename the file.
   EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NONE, base_file_->Rename(new_path));
   ASSERT_EQ(new_path.value(), base_file_->full_path().value());
-  ASSERT_TRUE(AppendDataToFile(kTestData3));
+  ASSERT_TRUE(WriteDataToFile(kTestData3));
 
   ExpectHashValue(kHashOfTestData1To3, base_file_->Finish());
 }
 
 // Test that a failed write reports an error.
 TEST_F(BaseFileTest, WriteWithError) {
   base::FilePath path;
   ASSERT_TRUE(base::CreateTemporaryFile(&path));
 
   // Pass a file handle which was opened without the WRITE flag.
   // This should result in an error when writing.
   base::File file(path, base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_READ);
   base_file_.reset(new BaseFile(net::NetLogWithSource()));
   EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NONE,
             base_file_->Initialize(path, base::FilePath(), std::move(file), 0,
                                    std::string(),
-                                   std::unique_ptr<crypto::SecureHash>()));
+                                   std::unique_ptr<crypto::SecureHash>(),
+                                   BaseFile::EXCLUSIVE));
 #if defined(OS_WIN)
   set_expected_error(DOWNLOAD_INTERRUPT_REASON_FILE_ACCESS_DENIED);
 #elif defined (OS_POSIX)
   set_expected_error(DOWNLOAD_INTERRUPT_REASON_FILE_FAILED);
 #endif
-  ASSERT_FALSE(AppendDataToFile(kTestData1));
+  ASSERT_FALSE(WriteDataToFile(kTestData1));
   base_file_->Finish();
 }
 
 // Try to write to uninitialized file.
 TEST_F(BaseFileTest, UninitializedFile) {
   expect_in_progress_ = false;
   set_expected_error(DOWNLOAD_INTERRUPT_REASON_FILE_FAILED);
-  EXPECT_FALSE(AppendDataToFile(kTestData1));
+  EXPECT_FALSE(WriteDataToFile(kTestData1));
 }
 
 // Create two |BaseFile|s with the same file, and attempt to write to both.
 // Overwrite base_file_ with another file with the same name and
 // non-zero contents, and make sure the last file to close 'wins'.
 TEST_F(BaseFileTest, DuplicateBaseFile) {
   ASSERT_TRUE(InitializeFile());
 
   // Create another |BaseFile| referring to the file that |base_file_| owns.
   CreateFileWithName(base_file_->full_path());
 
-  ASSERT_TRUE(AppendDataToFile(kTestData1));
+  ASSERT_TRUE(WriteDataToFile(kTestData1));
   base_file_->Finish();
 }
 
 // Create a file and append to it.
 TEST_F(BaseFileTest, AppendToBaseFile) {
   // Create a new file.
   base::FilePath existing_file_name = CreateTestFile();
   set_expected_data(kTestData4);
 
   // Use the file we've just created.
   base_file_.reset(new BaseFile(net::NetLogWithSource()));
   ASSERT_EQ(
       DOWNLOAD_INTERRUPT_REASON_NONE,
       base_file_->Initialize(existing_file_name, base::FilePath(), base::File(),
                              kTestDataLength4, std::string(),
-                             std::unique_ptr<crypto::SecureHash>()));
+                             std::unique_ptr<crypto::SecureHash>(),
+                             BaseFile::EXCLUSIVE));
 
   const base::FilePath file_name = base_file_->full_path();
   EXPECT_NE(base::FilePath::StringType(), file_name.value());
 
   // Write into the file.
-  EXPECT_TRUE(AppendDataToFile(kTestData1));
+  EXPECT_TRUE(WriteDataToFile(kTestData1));
 
   base_file_->Finish();
   base_file_->Detach();
   expect_file_survives_ = true;
 }
 
 // Create a read-only file and attempt to write to it.
 TEST_F(BaseFileTest, ReadonlyBaseFile) {
   // Create a new file.
   base::FilePath readonly_file_name = CreateTestFile();
 
   // Restore permissions to the file when we are done with this test.
   base::FilePermissionRestorer restore_permissions(readonly_file_name);
 
   // Make it read-only.
   EXPECT_TRUE(base::MakeFileUnwritable(readonly_file_name));
 
   // Try to overwrite it.
   base_file_.reset(new BaseFile(net::NetLogWithSource()));
   EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_FILE_ACCESS_DENIED,
             base_file_->Initialize(readonly_file_name, base::FilePath(),
                                    base::File(), 0, std::string(),
-                                   std::unique_ptr<crypto::SecureHash>()));
+                                   std::unique_ptr<crypto::SecureHash>(),
+                                   BaseFile::EXCLUSIVE));
 
   expect_in_progress_ = false;
 
   const base::FilePath file_name = base_file_->full_path();
   EXPECT_NE(base::FilePath::StringType(), file_name.value());
 
   // Write into the file.
   set_expected_error(DOWNLOAD_INTERRUPT_REASON_FILE_FAILED);
-  EXPECT_FALSE(AppendDataToFile(kTestData1));
+  EXPECT_FALSE(WriteDataToFile(kTestData1));
 
   base_file_->Finish();
   base_file_->Detach();
   expect_file_survives_ = true;
 }
 
 // Open an existing file and continue writing to it. The hash of the partial
 // file is known and matches the existing contents.
 TEST_F(BaseFileTest, ExistingBaseFileKnownHash) {
   base::FilePath file_path = temp_dir_.GetPath().AppendASCII("existing");
   ASSERT_EQ(kTestDataLength1,
             base::WriteFile(file_path, kTestData1, kTestDataLength1));
 
   std::string hash_so_far(std::begin(kHashOfTestData1),
                           std::end(kHashOfTestData1));
   EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NONE,
             base_file_->Initialize(file_path, base::FilePath(), base::File(),
                                    kTestDataLength1, hash_so_far,
-                                   std::unique_ptr<crypto::SecureHash>()));
+                                   std::unique_ptr<crypto::SecureHash>(),
+                                   BaseFile::EXCLUSIVE));
   set_expected_data(kTestData1);
-  ASSERT_TRUE(AppendDataToFile(kTestData2));
-  ASSERT_TRUE(AppendDataToFile(kTestData3));
+  ASSERT_TRUE(WriteDataToFile(kTestData2));
+  ASSERT_TRUE(WriteDataToFile(kTestData3));
   ExpectHashValue(kHashOfTestData1To3, base_file_->Finish());
 }
 
 // Open an existing file and continue writing to it. The hash of the partial
 // file is unknown.
 TEST_F(BaseFileTest, ExistingBaseFileUnknownHash) {
   base::FilePath file_path = temp_dir_.GetPath().AppendASCII("existing");
   ASSERT_EQ(kTestDataLength1,
             base::WriteFile(file_path, kTestData1, kTestDataLength1));
 
   EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NONE,
             base_file_->Initialize(file_path, base::FilePath(), base::File(),
                                    kTestDataLength1, std::string(),
-                                   std::unique_ptr<crypto::SecureHash>()));
+                                   std::unique_ptr<crypto::SecureHash>(),
+                                   BaseFile::EXCLUSIVE));
   set_expected_data(kTestData1);
-  ASSERT_TRUE(AppendDataToFile(kTestData2));
-  ASSERT_TRUE(AppendDataToFile(kTestData3));
+  ASSERT_TRUE(WriteDataToFile(kTestData2));
+  ASSERT_TRUE(WriteDataToFile(kTestData3));
   ExpectHashValue(kHashOfTestData1To3, base_file_->Finish());
 }
 
 // Open an existing file. The contentsof the file doesn't match the known hash.
 TEST_F(BaseFileTest, ExistingBaseFileIncorrectHash) {
   base::FilePath file_path = temp_dir_.GetPath().AppendASCII("existing");
   ASSERT_EQ(kTestDataLength2,
             base::WriteFile(file_path, kTestData2, kTestDataLength2));
 
   std::string hash_so_far(std::begin(kHashOfTestData1),
                           std::end(kHashOfTestData1));
   EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_FILE_HASH_MISMATCH,
             base_file_->Initialize(file_path, base::FilePath(), base::File(),
                                    kTestDataLength2, hash_so_far,
-                                   std::unique_ptr<crypto::SecureHash>()));
+                                   std::unique_ptr<crypto::SecureHash>(),
+                                   BaseFile::EXCLUSIVE));
   set_expected_error(DOWNLOAD_INTERRUPT_REASON_FILE_HASH_MISMATCH);
 }
 
 // Open a large existing file with a known hash and continue writing to it.
 TEST_F(BaseFileTest, ExistingBaseFileLargeSizeKnownHash) {
   base::FilePath file_path = temp_dir_.GetPath().AppendASCII("existing");
   std::string big_buffer(1024 * 200, 'a');
   ASSERT_EQ(static_cast<int>(big_buffer.size()),
             base::WriteFile(file_path, big_buffer.data(), big_buffer.size()));
 
   // Hash of partial file (1024*200 * 'a')
   const uint8_t kExpectedPartialHash[] = {
       0x4b, 0x4f, 0x0f, 0x46, 0xac, 0x02, 0xd1, 0x77, 0xde, 0xa0, 0xab,
       0x36, 0xa6, 0x6a, 0x65, 0x78, 0x40, 0xe2, 0xfb, 0x98, 0xb2, 0x0b,
       0xb2, 0x7a, 0x68, 0x8d, 0xb4, 0xd8, 0xea, 0x9c, 0xd2, 0x2c};
 
   // Hash of entire file (1024*400 * 'a')
   const uint8_t kExpectedFullHash[] = {
       0x0c, 0xe9, 0xf6, 0x78, 0x6b, 0x0f, 0x58, 0x49, 0x36, 0xe8, 0x83,
       0xc5, 0x09, 0x16, 0xbc, 0x5e, 0x2d, 0x07, 0x95, 0xb9, 0x42, 0x20,
       0x41, 0x7c, 0xb3, 0x38, 0xd3, 0xf4, 0xe0, 0x78, 0x89, 0x46};
 
   ASSERT_EQ(DOWNLOAD_INTERRUPT_REASON_NONE,
             base_file_->Initialize(file_path, base::FilePath(), base::File(),
                                    big_buffer.size(),
                                    std::string(std::begin(kExpectedPartialHash),
                                                std::end(kExpectedPartialHash)),
-                                   std::unique_ptr<crypto::SecureHash>()));
+                                   std::unique_ptr<crypto::SecureHash>(),
+                                   BaseFile::EXCLUSIVE));
   set_expected_data(big_buffer);  // Contents of the file on Open.
-  ASSERT_TRUE(AppendDataToFile(big_buffer));
+  ASSERT_TRUE(WriteDataToFile(big_buffer));
   ExpectHashValue(kExpectedFullHash, base_file_->Finish());
 }
 
 // Open a large existing file. The contents doesn't match the known hash.
 TEST_F(BaseFileTest, ExistingBaseFileLargeSizeIncorrectHash) {
   base::FilePath file_path = temp_dir_.GetPath().AppendASCII("existing");
   std::string big_buffer(1024 * 200, 'a');
   ASSERT_EQ(static_cast<int>(big_buffer.size()),
             base::WriteFile(file_path, big_buffer.data(), big_buffer.size()));
 
   // Incorrect hash of partial file (1024*200 * 'a')
   const uint8_t kExpectedPartialHash[] = {
       0xc2, 0xa9, 0x08, 0xd9, 0x8f, 0x5d, 0xf9, 0x87, 0xad, 0xe4, 0x1b,
       0x5f, 0xce, 0x21, 0x30, 0x67, 0xef, 0x6c, 0xc2, 0x1e, 0xf2, 0x24,
       0x02, 0x12, 0xa4, 0x1e, 0x54, 0xb5, 0xe7, 0xc2, 0x8a, 0xe5};
 
   EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_FILE_HASH_MISMATCH,
             base_file_->Initialize(file_path, base::FilePath(), base::File(),
                                    big_buffer.size(),
                                    std::string(std::begin(kExpectedPartialHash),
                                                std::end(kExpectedPartialHash)),
-                                   std::unique_ptr<crypto::SecureHash>()));
+                                   std::unique_ptr<crypto::SecureHash>(),
+                                   BaseFile::EXCLUSIVE));
   set_expected_error(DOWNLOAD_INTERRUPT_REASON_FILE_HASH_MISMATCH);
 }
 
 // Open an existing file. The size of the file is too short.
 TEST_F(BaseFileTest, ExistingBaseFileTooShort) {
   base::FilePath file_path = temp_dir_.GetPath().AppendASCII("existing");
   ASSERT_EQ(kTestDataLength1,
             base::WriteFile(file_path, kTestData1, kTestDataLength1));
 
   EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_FILE_TOO_SHORT,
             base_file_->Initialize(file_path, base::FilePath(), base::File(),
                                    kTestDataLength1 + 1, std::string(),
-                                   std::unique_ptr<crypto::SecureHash>()));
+                                   std::unique_ptr<crypto::SecureHash>(),
+                                   BaseFile::EXCLUSIVE));
   set_expected_error(DOWNLOAD_INTERRUPT_REASON_FILE_TOO_SHORT);
 }
 
 // Open an existing file. The size is larger than expected.
 TEST_F(BaseFileTest, ExistingBaseFileKnownHashTooLong) {
   base::FilePath file_path = temp_dir_.GetPath().AppendASCII("existing");
   std::string contents;
   contents.append(kTestData1);
   contents.append("Something extra");
   ASSERT_EQ(static_cast<int>(contents.size()),
             base::WriteFile(file_path, contents.data(), contents.size()));
 
   std::string hash_so_far(std::begin(kHashOfTestData1),
                           std::end(kHashOfTestData1));
   EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NONE,
             base_file_->Initialize(file_path, base::FilePath(), base::File(),
                                    kTestDataLength1, hash_so_far,
-                                   std::unique_ptr<crypto::SecureHash>()));
+                                   std::unique_ptr<crypto::SecureHash>(),
+                                   BaseFile::EXCLUSIVE));
   set_expected_data(kTestData1);  // Our starting position.
-  ASSERT_TRUE(AppendDataToFile(kTestData2));
-  ASSERT_TRUE(AppendDataToFile(kTestData3));
+  ASSERT_TRUE(WriteDataToFile(kTestData2));
+  ASSERT_TRUE(WriteDataToFile(kTestData3));
   ExpectHashValue(kHashOfTestData1To3, base_file_->Finish());
 }
 
 // Open an existing file. The size is large than expected and the hash is
 // unknown.
 TEST_F(BaseFileTest, ExistingBaseFileUnknownHashTooLong) {
   base::FilePath file_path = temp_dir_.GetPath().AppendASCII("existing");
   std::string contents;
   contents.append(kTestData1);
   contents.append("Something extra");
   ASSERT_EQ(static_cast<int>(contents.size()),
             base::WriteFile(file_path, contents.data(), contents.size()));
 
   EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NONE,
             base_file_->Initialize(file_path, base::FilePath(), base::File(),
                                    kTestDataLength1, std::string(),
-                                   std::unique_ptr<crypto::SecureHash>()));
+                                   std::unique_ptr<crypto::SecureHash>(),
+                                   BaseFile::EXCLUSIVE));
   set_expected_data(kTestData1);
-  ASSERT_TRUE(AppendDataToFile(kTestData2));
-  ASSERT_TRUE(AppendDataToFile(kTestData3));
+  ASSERT_TRUE(WriteDataToFile(kTestData2));
+  ASSERT_TRUE(WriteDataToFile(kTestData3));
   ExpectHashValue(kHashOfTestData1To3, base_file_->Finish());
 }
 
 // Similar to ExistingBaseFileKnownHashTooLong test, but with a file large
 // enough to requre multiple Read()s to complete. This provides additional code
 // coverage for the CalculatePartialHash() logic.
 TEST_F(BaseFileTest, ExistingBaseFileUnknownHashTooLongForLargeFile) {
   base::FilePath file_path = temp_dir_.GetPath().AppendASCII("existing");
   const size_t kFileSize = 1024 * 1024;
   const size_t kIntermediateSize = kFileSize / 2 + 111;
   // |contents| is 100 bytes longer than kIntermediateSize. The latter is the
   // expected size.
   std::string contents(kIntermediateSize + 100, 'a');
   ASSERT_EQ(static_cast<int>(contents.size()),
             base::WriteFile(file_path, contents.data(), contents.size()));
 
   EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NONE,
             base_file_->Initialize(file_path, base::FilePath(), base::File(),
                                    kIntermediateSize, std::string(),
-                                   std::unique_ptr<crypto::SecureHash>()));
+                                   std::unique_ptr<crypto::SecureHash>(),
+                                   BaseFile::EXCLUSIVE));
   // The extra bytes should be stripped during Initialize().
   contents.resize(kIntermediateSize, 'a');
   set_expected_data(contents);
   std::string new_data(kFileSize - kIntermediateSize, 'a');
-  ASSERT_TRUE(AppendDataToFile(new_data));
+  ASSERT_TRUE(WriteDataToFile(new_data));
   const uint8_t kExpectedHash[] = {
       0x9b, 0xc1, 0xb2, 0xa2, 0x88, 0xb2, 0x6a, 0xf7, 0x25, 0x7a, 0x36,
       0x27, 0x7a, 0xe3, 0x81, 0x6a, 0x7d, 0x4f, 0x16, 0xe8, 0x9c, 0x1e,
       0x7e, 0x77, 0xd0, 0xa5, 0xc4, 0x8b, 0xad, 0x62, 0xb3, 0x60,
   };
   ExpectHashValue(kExpectedHash, base_file_->Finish());
 }
 
 // Test that a temporary file is created in the default download directory.
 TEST_F(BaseFileTest, CreatedInDefaultDirectory) {
@@ skipping 24 matching lines @@
   ASSERT_FALSE(base::PathExists(full_path));
 
   const char kData[] = "hello";
   const int kDataLength = static_cast<int>(arraysize(kData) - 1);
   ASSERT_EQ(kDataLength, base::WriteFile(full_path, kData, kDataLength));
   // The file that we created here should stick around when the BaseFile is
   // destroyed during TearDown.
   expect_file_survives_ = true;
 }
 
+// Test that a it is ok to initialize a shared file with offset larger than the
+// file size.
+TEST_F(BaseFileTest, InitializeSharedFileWithOffsetLargerThanFileSize) {
+  base::FilePath file_path = temp_dir_.GetPath().AppendASCII("existing");
+  std::string contents = kTestData1;
+  ASSERT_EQ(static_cast<int>(contents.size()),
+            base::WriteFile(file_path, contents.data(), contents.size()));
+
+  std::string empty_data = "\0\0\0\0\0";
+  EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NONE,
+            base_file_->Initialize(file_path, base::FilePath(), base::File(),
+                                   contents.size() + empty_data.size(),
+                                   std::string(),
+                                   std::unique_ptr<crypto::SecureHash>(),
+                                   BaseFile::SHARED));
+  set_expected_data(kTestData1 + empty_data);
+  ASSERT_TRUE(WriteDataToFile(kTestData2));
+  EXPECT_EQ(kTestDataLength2, base_file_->bytes_so_far());
+  base_file_->Finish();
+}
+
+// Test that multiple writers can share the same file and write data to it.
+TEST_F(BaseFileTest, MultipleWriters) {
+  base::FilePath file_path = temp_dir_.GetPath().AppendASCII("existing");
+  std::string contents = kTestData1;
+  ASSERT_EQ(static_cast<int>(contents.size()),
+            base::WriteFile(file_path, contents.data(), contents.size()));
+
+  // Create another file.
+  BaseFile second_file((net::NetLogWithSource()));
+  EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NONE,
+            second_file.Initialize(file_path, base::FilePath(), base::File(),
+                                   contents.size(), std::string(),
+                                   std::unique_ptr<crypto::SecureHash>(),
+                                   BaseFile::SHARED));
+
+  EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NONE,

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

In this way, each parallel download worker class will hold a  DownloadFile
objects, each DownloadFile holds a content::BaseFile. I'll create a branch try
to glue network IO with disk IO in this way.

It will create multiple file descriptors on low level disk IO api. I think
currently base::File supports that in linux and windows.

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

An  alternative is to provide a write(int64_t offset, const char* data, size_t
data_len) function so that we can write to arbitrary location. Probably that is
better, but then each job needs to figure out how much data they have written by
themselves, rather than using the bytes_so_far() function. 

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

Yeah, make sense, we can reuse the meta data with the first approach. It might
be easier to implement compared to the alternative approach.

+            base_file_->Initialize(file_path, base::FilePath(), base::File(),
+                                   contents.size() + kTestDataLength2,
+                                   std::string(),
+                                   std::unique_ptr<crypto::SecureHash>(),
+                                   BaseFile::SHARED));
+
+  EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NONE,
+            second_file.WriteDataToFile(kTestData2, kTestDataLength2));
+  EXPECT_EQ(kTestDataLength2, second_file.bytes_so_far());
+
+  set_expected_data(contents + kTestData2);
+  ASSERT_TRUE(WriteDataToFile(kTestData4));
+  base_file_->Finish();
+  second_file.Detach();
+}
+
 }  // namespace content