Added member data to classes to support download resumption.

chrome/browser/download/download_manager_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 <set>
 #include <string>
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/i18n/number_formatting.h"
@@ skipping 52 matching lines @@
 
 namespace {
 
 class MockDownloadFileFactory
     : public DownloadFileManager::DownloadFileFactory {
  public:
   MockDownloadFileFactory() {}
 
   virtual DownloadFile* CreateFile(DownloadCreateInfo* info,
                                    const DownloadRequestHandle& request_handle,
-                                   DownloadManager* download_manager) OVERRIDE;
+                                   DownloadManager* download_manager,
+                                   bool calculate_hash) OVERRIDE;
 };
 
 DownloadFile* MockDownloadFileFactory::CreateFile(
     DownloadCreateInfo* info,
     const DownloadRequestHandle& request_handle,
-    DownloadManager* download_manager) {
+    DownloadManager* download_manager,
+    bool calculate_hash) {
   NOTREACHED();
   return NULL;
 }
 
 DownloadId::Domain kValidIdDomain = "valid DownloadId::Domain";
 
 class TestDownloadManagerDelegate : public ChromeDownloadManagerDelegate {
  public:
   explicit TestDownloadManagerDelegate(Profile* profile)
       : ChromeDownloadManagerDelegate(profile),
@@ skipping 124 matching lines @@
 
     BrowserThread::PostTask(
         BrowserThread::FILE, FROM_HERE,
         base::Bind(&DownloadFileManager::UpdateDownload, file_manager_.get(),
                    DownloadId(kValidIdDomain, id), download_buffer_));
 
     message_loop_.RunAllPending();
   }
 
   void OnDownloadInterrupted(int32 download_id, int64 size,
+                             const std::string& hash_state,
                              InterruptReason reason) {
-    download_manager_->OnDownloadInterrupted(download_id, size, reason);
+    download_manager_->OnDownloadInterrupted(download_id, size,
+                                             hash_state, reason);
   }
 
   // Get the download item with ID |id|.
   DownloadItem* GetActiveDownloadItem(int32 id) {
     return download_manager_->GetActiveDownload(id);
   }
 
  protected:
   DownloadStatusUpdater download_status_updater_;
   scoped_ptr<TestingProfile> profile_;
@@ skipping 18 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(DownloadManagerTest);
 };
 
 const char* DownloadManagerTest::kTestData = "a;sdlfalsdfjalsdkfjad";
 const size_t DownloadManagerTest::kTestDataLen =
     strlen(DownloadManagerTest::kTestData);
 
 // A DownloadFile that we can inject errors into.
 class DownloadFileWithErrors : public DownloadFileImpl {
  public:
-  DownloadFileWithErrors(DownloadCreateInfo* info, DownloadManager* manager);
+  DownloadFileWithErrors(DownloadCreateInfo* info,
+                         DownloadManager* manager,
+                         bool calculate_hash);
   virtual ~DownloadFileWithErrors() {}
 
   // BaseFile delegated functions.
-  virtual net::Error Initialize(bool calculate_hash);
+  virtual net::Error Initialize();
   virtual net::Error AppendDataToFile(const char* data, size_t data_len);
   virtual net::Error Rename(const FilePath& full_path);
 
   void set_forced_error(net::Error error) { forced_error_ = error; }
   void clear_forced_error() { forced_error_ = net::OK; }
   net::Error forced_error() const { return forced_error_; }
 
  private:
   net::Error ReturnError(net::Error function_error) {
     if (forced_error_ != net::OK) {
       net::Error ret = forced_error_;
       clear_forced_error();
       return ret;
     }
 
     return function_error;
   }
 
   net::Error forced_error_;
 };
 
 DownloadFileWithErrors::DownloadFileWithErrors(DownloadCreateInfo* info,
-                                               DownloadManager* manager)
-    : DownloadFileImpl(info, new DownloadRequestHandle(), manager),
+                                               DownloadManager* manager,
+                                               bool calculate_hash)
+    : DownloadFileImpl(info,
+                       new DownloadRequestHandle(),
+                       manager,
+                       calculate_hash),
       forced_error_(net::OK) {
 }
 
-net::Error DownloadFileWithErrors::Initialize(bool calculate_hash) {
-  return ReturnError(DownloadFileImpl::Initialize(calculate_hash));
+net::Error DownloadFileWithErrors::Initialize() {
+  return ReturnError(DownloadFileImpl::Initialize());
 }
 
 net::Error DownloadFileWithErrors::AppendDataToFile(const char* data,
                                                     size_t data_len) {
   return ReturnError(DownloadFileImpl::AppendDataToFile(data, data_len));
 }
 
 net::Error DownloadFileWithErrors::Rename(const FilePath& full_path) {
   return ReturnError(DownloadFileImpl::Rename(full_path));
 }
@@ skipping 167 matching lines @@
     // don't call the function that deletes it, so we do so ourselves.
     scoped_ptr<DownloadCreateInfo> info(new DownloadCreateInfo);
     info->download_id = DownloadId(kValidIdDomain, static_cast<int>(i));
     info->prompt_user_for_save_location = kStartDownloadCases[i].save_as;
     info->url_chain.push_back(GURL(kStartDownloadCases[i].url));
     info->mime_type = kStartDownloadCases[i].mime_type;
     download_manager_->CreateDownloadItem(info.get(), DownloadRequestHandle());
 
     DownloadFile* download_file(
         new DownloadFileImpl(info.get(), new DownloadRequestHandle(),
-                             download_manager_));
+                             download_manager_, false));
     AddDownloadToFileManager(info->download_id.local(), download_file);
-    download_file->Initialize(false);
+    download_file->Initialize();
     download_manager_->StartDownload(info->download_id.local());
     message_loop_.RunAllPending();
 
     // SelectFileObserver will have recorded any attempt to open the
     // select file dialog.
     // Note that DownloadManager::FileSelectionCanceled() is never called.
     EXPECT_EQ(kStartDownloadCases[i].expected_save_as,
               observer.ShowedFileDialogForId(i));
   }
 }
@@ skipping 415 matching lines @@
 
   download_file->AppendDataToFile(kTestData, kTestDataLen);
 
   ContinueDownloadWithPath(download, new_path);
   message_loop_.RunAllPending();
   EXPECT_EQ(1,
             recorder.Count(MockDownloadFile::StatisticsRecorder::STAT_RENAME));
   EXPECT_TRUE(GetActiveDownloadItem(0) != NULL);
 
   int64 error_size = 3;
-  OnDownloadInterrupted(0, error_size,
+  OnDownloadInterrupted(0, error_size, "",
                         DOWNLOAD_INTERRUPT_REASON_FILE_ACCESS_DENIED);
   message_loop_.RunAllPending();
 
   EXPECT_TRUE(GetActiveDownloadItem(0) == NULL);
   EXPECT_TRUE(observer->hit_state(DownloadItem::IN_PROGRESS));
   EXPECT_TRUE(observer->hit_state(DownloadItem::INTERRUPTED));
   EXPECT_FALSE(observer->hit_state(DownloadItem::COMPLETE));
   EXPECT_FALSE(observer->hit_state(DownloadItem::CANCELLED));
   EXPECT_FALSE(observer->hit_state(DownloadItem::REMOVING));
   EXPECT_TRUE(observer->was_updated());
@@ skipping 45 matching lines @@
   static const int32 local_id = 0;
   info->download_id = DownloadId(kValidIdDomain, local_id);
   info->prompt_user_for_save_location = false;
   info->url_chain.push_back(GURL());
   info->total_bytes = static_cast<int64>(kTestDataLen * 3);
   info->save_info.file_path = path;
   info->save_info.file_stream.reset(stream);
 
   // Create a download file that we can insert errors into.
   DownloadFileWithErrors* download_file(new DownloadFileWithErrors(
-      info.get(), download_manager_));
+      info.get(), download_manager_, false));
+  download_file->Initialize();
   AddDownloadToFileManager(local_id, download_file);
 
   // |download_file| is owned by DownloadFileManager.
   download_manager_->CreateDownloadItem(info.get(), DownloadRequestHandle());
 
   DownloadItem* download = GetActiveDownloadItem(0);
   ASSERT_TRUE(download != NULL);
   // This will keep track of what should be displayed on the shelf.
   scoped_ptr<DownloadItemModel> download_item_model(
       new DownloadItemModel(download));
@@ skipping 153 matching lines @@
 
   EXPECT_EQ(DownloadItem::IN_PROGRESS, download->GetState());
   scoped_ptr<ItemObserver> observer(new ItemObserver(download));
 
   // Create and initialize the download file.  We're bypassing the first part
   // of the download process and skipping to the part after the final file
   // name has been chosen, so we need to initialize the download file
   // properly.
   DownloadFile* download_file(
       new DownloadFileImpl(info.get(), new DownloadRequestHandle(),
-                           download_manager_));
+                           download_manager_, false));
   download_file->Rename(cr_path);
   // This creates the .crdownload version of the file.
-  download_file->Initialize(false);
+  download_file->Initialize();
   // |download_file| is owned by DownloadFileManager.
   AddDownloadToFileManager(info->download_id.local(), download_file);
 
   ContinueDownloadWithPath(download, new_path);
   message_loop_.RunAllPending();
   EXPECT_TRUE(GetActiveDownloadItem(0) != NULL);
 
   download_file->AppendDataToFile(kTestData, kTestDataLen);
 
   // Finish the download.
@@ skipping 53 matching lines @@
 
   EXPECT_EQ(DownloadItem::IN_PROGRESS, download->GetState());
   scoped_ptr<ItemObserver> observer(new ItemObserver(download));
 
   // Create and initialize the download file.  We're bypassing the first part
   // of the download process and skipping to the part after the final file
   // name has been chosen, so we need to initialize the download file
   // properly.
   DownloadFile* download_file(
       new DownloadFileImpl(info.get(), new DownloadRequestHandle(),
-                           download_manager_));
+                           download_manager_, false));
   download_file->Rename(cr_path);
   // This creates the .crdownload version of the file.
-  download_file->Initialize(false);
+  download_file->Initialize();
   // |download_file| is owned by DownloadFileManager.
   AddDownloadToFileManager(info->download_id.local(), download_file);
 
   ContinueDownloadWithPath(download, new_path);
   message_loop_.RunAllPending();
   EXPECT_TRUE(GetActiveDownloadItem(0) != NULL);
 
   download_file->AppendDataToFile(kTestData, kTestDataLen);
 
   // Finish the download.
@@ skipping 29 matching lines @@
   EXPECT_FALSE(observer->hit_state(DownloadItem::REMOVING));
   EXPECT_TRUE(observer->was_updated());
   EXPECT_FALSE(observer->was_opened());
   EXPECT_TRUE(download->GetFileExternallyRemoved());
   EXPECT_EQ(DownloadItem::COMPLETE, download->GetState());
   EXPECT_EQ(download_item_model->GetStatusText(),
             l10n_util::GetStringUTF16(IDS_DOWNLOAD_STATUS_REMOVED));
 
   EXPECT_FALSE(file_util::PathExists(new_path));
 }