Added member data to classes to support download resumption.

content/browser/download/base_file_unittest.cc

 // Copyright (c) 2011 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 "base/file_util.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/scoped_temp_dir.h"
@@ skipping 26 matching lines @@
   BaseFileTest()
       : expect_file_survives_(false),
         expect_in_progress_(true),
         expected_error_(false),
         file_thread_(BrowserThread::FILE, &message_loop_) {
   }
 
   virtual void SetUp() {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     base_file_.reset(
-        new BaseFile(FilePath(), GURL(), GURL(), 0, file_stream_));
+        new BaseFile(FilePath(), GURL(), GURL(), 0, "", file_stream_));
   }
 
   virtual void TearDown() {
     EXPECT_FALSE(base_file_->in_progress());
     if (!expected_error_) {
       EXPECT_EQ(static_cast<int64>(expected_data_.size()),
                 base_file_->bytes_so_far());
     }
 
     FilePath full_path = base_file_->full_path();
@@ skipping 53 matching lines @@
     return appended;
   }
 
   void set_expected_data(const std::string& data) { expected_data_ = data; }
 
   // Helper functions.
   // Create a file.  Returns the complete file path.
   static FilePath CreateTestFile() {
     FilePath file_name;
     linked_ptr<net::FileStream> dummy_file_stream;
-    BaseFile file(FilePath(), GURL(), GURL(), 0, dummy_file_stream);
+    BaseFile file(FilePath(), GURL(), GURL(), 0, "", dummy_file_stream);
 
     EXPECT_EQ(net::OK, file.Initialize(false));
     file_name = file.full_path();
     EXPECT_NE(FilePath::StringType(), file_name.value());
 
     EXPECT_EQ(net::OK, file.AppendDataToFile(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.
   static void CreateFileWithName(const FilePath& file_name) {
     EXPECT_NE(FilePath::StringType(), file_name.value());
     linked_ptr<net::FileStream> dummy_file_stream;
-    BaseFile duplicate_file(file_name, GURL(), GURL(), 0, dummy_file_stream);
+    BaseFile duplicate_file(
+        file_name, GURL(), GURL(), 0, "", dummy_file_stream);
     EXPECT_EQ(net::OK, duplicate_file.Initialize(false));
     // Write something into it.
     duplicate_file.AppendDataToFile(kTestData4, kTestDataLength4);
     // Detach the file so it isn't deleted on destruction of |duplicate_file|.
     duplicate_file.Detach();
   }
 
  protected:
   linked_ptr<net::FileStream> file_stream_;
   linked_ptr<net::testing::MockFileStream> mock_file_stream_;
@@ skipping 93 matching lines @@
   ASSERT_EQ(net::OK, base_file_->Initialize(false));
   ASSERT_EQ(net::OK, AppendDataToFile(kTestData1));
   ASSERT_EQ(net::OK, AppendDataToFile(kTestData2));
   ASSERT_EQ(net::OK, AppendDataToFile(kTestData3));
   std::string hash;
   EXPECT_FALSE(base_file_->GetSha256Hash(&hash));
   base_file_->Finish();
 }
 
 // Write data to the file once and calculate its sha256 hash.
 TEST_F(BaseFileTest, SingleWriteWithHash) {

[Randy Smith (Not in Mondays), 2011/11/16 21:40:25]

I'd think that we'd also want to confirm that if we have a data chunk X, and we
write it to a file and get a hash, that hash is the same as if we wrote X/2,
closed the file, opened a new one with the partial hash, and did the second
half.

[ahendrickson, 2011/11/19 20:18:04]

That sounds like a good idea.

Done.

+  std::string partial_hash;
   ASSERT_EQ(net::OK, base_file_->Initialize(true));
+  // Can get partial hashes before Finish() is called.
+  EXPECT_TRUE(base_file_->GetSha256Hash(&partial_hash));
   ASSERT_EQ(net::OK, AppendDataToFile(kTestData1));
+  EXPECT_TRUE(base_file_->GetSha256Hash(&partial_hash));
   base_file_->Finish();
 
   std::string hash;
   base_file_->GetSha256Hash(&hash);
   EXPECT_EQ("0B2D3F3F7943AD64B860DF94D05CB56A8A97C6EC5768B5B70B930C5AA7FA9ADE",
             base::HexEncode(hash.data(), hash.size()));
 }
 
 // Write data to the file multiple times and calculate its sha256 hash.
 TEST_F(BaseFileTest, MultipleWritesWithHash) {
   std::string hash;
 
   ASSERT_EQ(net::OK, base_file_->Initialize(true));
   ASSERT_EQ(net::OK, AppendDataToFile(kTestData1));
   ASSERT_EQ(net::OK, AppendDataToFile(kTestData2));
   ASSERT_EQ(net::OK, AppendDataToFile(kTestData3));
-  // no hash before Finish() is called either.
-  EXPECT_FALSE(base_file_->GetSha256Hash(&hash));
   base_file_->Finish();
 
   EXPECT_TRUE(base_file_->GetSha256Hash(&hash));
   EXPECT_EQ("CBF68BF10F8003DB86B31343AFAC8C7175BD03FB5FC905650F8C80AF087443A8",
             base::HexEncode(hash.data(), hash.size()));
 }
 
 // Rename the file after all writes to it.
 TEST_F(BaseFileTest, WriteThenRename) {
   ASSERT_EQ(net::OK, base_file_->Initialize(false));
@@ skipping 30 matching lines @@
 
   ASSERT_EQ(net::OK, AppendDataToFile(kTestData2));
 
   base_file_->Finish();
 }
 
 // Write data to the file multiple times.
 TEST_F(BaseFileTest, MultipleWritesWithError) {
   ASSERT_TRUE(OpenMockFileStream());
   base_file_.reset(new BaseFile(mock_file_stream_->get_path(),
-                                GURL(), GURL(), 0, mock_file_stream_));
+                                GURL(), GURL(), 0, "", mock_file_stream_));
   EXPECT_EQ(net::OK, base_file_->Initialize(false));
   ASSERT_EQ(net::OK, AppendDataToFile(kTestData1));
   ASSERT_EQ(net::OK, AppendDataToFile(kTestData2));
   ForceError(net::ERR_ACCESS_DENIED);
   ASSERT_NE(net::OK, AppendDataToFile(kTestData3));
   std::string hash;
   EXPECT_FALSE(base_file_->GetSha256Hash(&hash));
   base_file_->Finish();
 }
 
@@ skipping 19 matching lines @@
 // Create a file and append to it.
 TEST_F(BaseFileTest, AppendToBaseFile) {
   // Create a new file.
   FilePath existing_file_name = CreateTestFile();
 
   set_expected_data(kTestData4);
 
   // Use the file we've just created.
   base_file_.reset(
       new BaseFile(existing_file_name, GURL(), GURL(), kTestDataLength4,
-                   file_stream_));
+                   "", file_stream_));
 
   EXPECT_EQ(net::OK, base_file_->Initialize(false));
 
   const FilePath file_name = base_file_->full_path();
   EXPECT_NE(FilePath::StringType(), file_name.value());
 
   // Write into the file.
   EXPECT_EQ(net::OK, AppendDataToFile(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.
   FilePath readonly_file_name = CreateTestFile();
 
   // Make it read-only.
   EXPECT_TRUE(file_util::MakeFileUnwritable(readonly_file_name));
 
   // Try to overwrite it.
   base_file_.reset(
-      new BaseFile(readonly_file_name, GURL(), GURL(), 0, file_stream_));
+      new BaseFile(readonly_file_name, GURL(), GURL(), 0, "", file_stream_));
 
   expect_in_progress_ = false;
 
   int init_error = base_file_->Initialize(false);
   DVLOG(1) << " init_error = " << init_error;
   EXPECT_NE(net::OK, init_error);
 
   const FilePath file_name = base_file_->full_path();
   EXPECT_NE(FilePath::StringType(), file_name.value());
 
   // Write into the file.
   EXPECT_NE(net::OK, AppendDataToFile(kTestData1));
 
   base_file_->Finish();
   base_file_->Detach();
   expect_file_survives_ = true;
 }
 
 TEST_F(BaseFileTest, IsEmptySha256Hash) {
   std::string empty(BaseFile::kSha256HashLen, '\x00');
   EXPECT_TRUE(BaseFile::IsEmptySha256Hash(empty));
   std::string not_empty(BaseFile::kSha256HashLen, '\x01');
   EXPECT_FALSE(BaseFile::IsEmptySha256Hash(not_empty));
   EXPECT_FALSE(BaseFile::IsEmptySha256Hash(""));
 }