Persist download interrupt reason, both target and current paths, and url_chain.

chrome/browser/download/download_history_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 <set>
 #include <vector>
 
 #include "base/rand_util.h"
 #include "base/stl_util.h"
 #include "chrome/browser/download/download_history.h"
@@ skipping 11 matching lines @@
 using testing::Return;
 using testing::ReturnRef;
 using testing::SetArgPointee;
 using testing::WithArg;
 using testing::_;
 
 namespace {
 
 void CheckInfoEqual(const history::DownloadRow& left,
                     const history::DownloadRow& right) {
-  EXPECT_EQ(left.path.value(), right.path.value());
-  EXPECT_EQ(left.url.spec(), right.url.spec());
+  EXPECT_EQ(left.current_path.value(), right.current_path.value());
+  EXPECT_EQ(left.target_path.value(), right.target_path.value());
+  EXPECT_EQ(left.url_chain.size(), right.url_chain.size());
+  for (unsigned int i = 0;
+       i < left.url_chain.size() && i < right.url_chain.size();
+       ++i) {
+    EXPECT_EQ(left.url_chain[i].spec(), right.url_chain[i].spec());
+  }
   EXPECT_EQ(left.referrer_url.spec(), right.referrer_url.spec());
   EXPECT_EQ(left.start_time.ToTimeT(), right.start_time.ToTimeT());
   EXPECT_EQ(left.end_time.ToTimeT(), right.end_time.ToTimeT());
   EXPECT_EQ(left.received_bytes, right.received_bytes);
   EXPECT_EQ(left.total_bytes, right.total_bytes);
   EXPECT_EQ(left.state, right.state);
+  EXPECT_EQ(left.danger_type, right.danger_type);
   EXPECT_EQ(left.db_handle, right.db_handle);
   EXPECT_EQ(left.opened, right.opened);
 }
 
 typedef std::set<int64> HandleSet;
 typedef std::vector<history::DownloadRow> InfoVector;
 typedef testing::NiceMock<content::MockDownloadItem> NiceMockDownloadItem;
 
 class FakeHistoryAdapter : public DownloadHistory::HistoryAdapter {
  public:
@@ skipping 161 matching lines @@
   content::MockDownloadManager& manager() { return *manager_.get(); }
   content::MockDownloadItem& item(size_t index) { return *items_[index]; }
 
   void SetManagerObserver(
       content::DownloadManager::Observer* manager_observer) {
     manager_observer_ = manager_observer;
   }
   content::DownloadManager::Observer* manager_observer() {
     return manager_observer_;
   }
+
+  // Relies on the same object observing all download items.
   void SetItemObserver(
       content::DownloadItem::Observer* item_observer) {
     item_observer_ = item_observer;
   }
   content::DownloadItem::Observer* item_observer() {
     return item_observer_;
   }
 
   void ExpectWillQueryDownloads(scoped_ptr<InfoVector> infos) {
     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
     CHECK(infos.get());
     EXPECT_CALL(manager(), AddObserver(_)).WillOnce(WithArg<0>(Invoke(
         this, &DownloadHistoryTest::SetManagerObserver)));
     EXPECT_CALL(manager(), RemoveObserver(_));
     download_created_index_ = 0;
     for (size_t index = 0; index < infos->size(); ++index) {
-      EXPECT_CALL(manager(), CreateDownloadItem(
-          infos->at(index).path,
-          infos->at(index).url,
+      EXPECT_CALL(manager(), MockCreateDownloadItem1(

[benjhayden, 2013/01/23 21:02:06]

Did you consider my idea of passing a single struct to MockCreateDownloadItem
and overloading its operator==? I think it might actually be less confusing and
error-prone than splitting it into two.

[Randy Smith (Not in Mondays), 2013/01/23 23:20:39]

I hadn't because its seemed more complex than I wanted, but your comment here
made me decide to throw it together and see how it looked, and you're quite
right; that's better.  Done.

+          infos->at(index).current_path,
+          infos->at(index).target_path,
+          infos->at(index).url_chain,
           infos->at(index).referrer_url,
           infos->at(index).start_time,
           infos->at(index).end_time,
           infos->at(index).received_bytes,
           infos->at(index).total_bytes,
           infos->at(index).state,
+          infos->at(index).danger_type));
+      EXPECT_CALL(manager(), MockCreateDownloadItem2(
+          infos->at(index).target_path,
+          infos->at(index).url_chain,
+          infos->at(index).interrupt_reason,
           infos->at(index).opened))
         .WillOnce(DoAll(
             InvokeWithoutArgs(
                 this, &DownloadHistoryTest::CallOnDownloadCreatedInOrder),
             Return(&item(index))));
     }
     EXPECT_CALL(manager(), CheckForHistoryFilesRemoval());
     history_ = new FakeHistoryAdapter();
     history_->ExpectWillQueryDownloads(infos.Pass());
     EXPECT_CALL(*manager_.get(), GetAllDownloads(_)).WillRepeatedly(Return());
@@ skipping 54 matching lines @@
   void ExpectNoDownloadsRemoved() {
     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
     history_->ExpectNoDownloadsRemoved();
   }
 
   void ExpectDownloadsRemoved(const HandleSet& handles) {
     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
     history_->ExpectDownloadsRemoved(handles);
   }
 
+  // Caller is responsibile for making sure reference arguments lifetime is
+  // greater than the lifetime of the NiceMockDownloadItem() created by this
+  // routine.
   void InitItem(
       int32 id,
-      const FilePath& path,
-      const GURL& url,
+      const FilePath& current_path,
+      const FilePath& target_path,
+      const std::vector<GURL>& url_chain,
       const GURL& referrer,
       const base::Time& start_time,
       const base::Time& end_time,
       int64 received_bytes,
       int64 total_bytes,
       content::DownloadItem::DownloadState state,
+      content::DownloadDangerType danger_type,
+      content::DownloadInterruptReason interrupt_reason,
       int64 db_handle,
       bool opened,
       history::DownloadRow* info) {
     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
     int32 index = items_.size();
     NiceMockDownloadItem* mock_item = new NiceMockDownloadItem();
     items_.push_back(mock_item);
 
-    info->path = path;
-    info->url = url;
+    info->current_path = current_path;
+    info->target_path = target_path;
+    info->url_chain = url_chain;
     info->referrer_url = referrer;
     info->start_time = start_time;
     info->end_time = end_time;
     info->received_bytes = received_bytes;
     info->total_bytes = total_bytes;
     info->state = state;
+    info->danger_type = danger_type;
+    info->interrupt_reason = interrupt_reason;
     info->db_handle = db_handle;
     info->opened = opened;
 
     EXPECT_CALL(item(index), GetId()).WillRepeatedly(Return(id));
-    EXPECT_CALL(item(index), GetFullPath()).WillRepeatedly(ReturnRef(path));
-    EXPECT_CALL(item(index), GetURL()).WillRepeatedly(ReturnRef(url));
+    EXPECT_CALL(item(index),
+                GetFullPath()).WillRepeatedly(ReturnRef(current_path));
+    EXPECT_CALL(item(index),
+                GetTargetFilePath()).WillRepeatedly(ReturnRef(target_path));
+    DCHECK_LE(1u, url_chain.size());
+    EXPECT_CALL(item(index), GetURL()).WillRepeatedly(ReturnRef(url_chain[0]));
+    EXPECT_CALL(item(index),
+                GetUrlChain()).WillRepeatedly(ReturnRef(url_chain));
     EXPECT_CALL(item(index), GetMimeType()).WillRepeatedly(Return(
         "application/octet-stream"));
     EXPECT_CALL(item(index), GetReferrerUrl()).WillRepeatedly(ReturnRef(
         referrer));
     EXPECT_CALL(item(index), GetStartTime()).WillRepeatedly(Return(start_time));
     EXPECT_CALL(item(index), GetEndTime()).WillRepeatedly(Return(end_time));
     EXPECT_CALL(item(index), GetReceivedBytes())
         .WillRepeatedly(Return(received_bytes));
     EXPECT_CALL(item(index), GetTotalBytes()).WillRepeatedly(Return(
         total_bytes));
     EXPECT_CALL(item(index), GetState()).WillRepeatedly(Return(state));
+    EXPECT_CALL(item(index), GetDangerType())
+        .WillRepeatedly(Return(danger_type));
+    EXPECT_CALL(item(index), GetLastReason()).WillRepeatedly(
+        Return(interrupt_reason));
     EXPECT_CALL(item(index), GetOpened()).WillRepeatedly(Return(opened));
     EXPECT_CALL(item(index), GetTargetDisposition()).WillRepeatedly(Return(
           content::DownloadItem::TARGET_DISPOSITION_OVERWRITE));
     EXPECT_CALL(manager(), GetDownload(id))
         .WillRepeatedly(Return(&item(index)));
     EXPECT_CALL(item(index), AddObserver(_)).WillOnce(WithArg<0>(Invoke(
         this, &DownloadHistoryTest::SetItemObserver)));
     EXPECT_CALL(item(index), RemoveObserver(_));
 
     std::vector<content::DownloadItem*> items;
@@ skipping 22 matching lines @@
 
 // Test loading an item from the database, changing it, saving it back, removing
 // it.
 TEST_F(DownloadHistoryTest, DownloadHistoryTest_Load) {
   // Load a download from history, create the item, OnDownloadCreated,
   // OnDownloadUpdated, OnDownloadRemoved.
   history::DownloadRow info;
   FilePath path(FILE_PATH_LITERAL("/foo/bar.pdf"));
   GURL url("http://example.com/bar.pdf");
   GURL referrer("http://example.com/referrer.html");
+  std::vector<GURL> url_chain;
+  url_chain.push_back(url);
   InitItem(base::RandInt(0, 1 << 20),
            path,
-           url,
+           path,
+           url_chain,
            referrer,
            (base::Time::Now() - base::TimeDelta::FromMinutes(10)),
            (base::Time::Now() - base::TimeDelta::FromMinutes(1)),
            100,
            100,
            content::DownloadItem::COMPLETE,
+           content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+           content::DOWNLOAD_INTERRUPT_REASON_NONE,
            base::RandInt(0, 1 << 20),
            false,
            &info);
   {
     scoped_ptr<InfoVector> infos(new InfoVector());
     infos->push_back(info);
     ExpectWillQueryDownloads(infos.Pass());
     ExpectNoDownloadCreated();
   }
   EXPECT_TRUE(DownloadHistory::IsPersisted(&item(0)));
@@ skipping 16 matching lines @@
 TEST_F(DownloadHistoryTest, DownloadHistoryTest_Create) {
   // Create a fresh item not from history, OnDownloadCreated, OnDownloadUpdated,
   // OnDownloadRemoved.
   ExpectWillQueryDownloads(scoped_ptr<InfoVector>(new InfoVector()));
 
   // Note that db_handle must be -1 at first because it isn't in the db yet.
   history::DownloadRow info;
   FilePath path(FILE_PATH_LITERAL("/foo/bar.pdf"));
   GURL url("http://example.com/bar.pdf");
   GURL referrer("http://example.com/referrer.html");
+  std::vector<GURL> url_chain;
+  url_chain.push_back(url);
   InitItem(base::RandInt(0, 1 << 20),
            path,
-           url,
+           path,
+           url_chain,
            referrer,
            (base::Time::Now() - base::TimeDelta::FromMinutes(10)),
            (base::Time::Now() - base::TimeDelta::FromMinutes(1)),
            100,
            100,
            content::DownloadItem::COMPLETE,
+           content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+           content::DOWNLOAD_INTERRUPT_REASON_NONE,
            -1,
            false,
            &info);
 
   // Pretend the manager just created |item|.
   CallOnDownloadCreated(0);
   // CreateDownload() always gets db_handle=-1.
   ExpectDownloadCreated(info);
   info.db_handle = 0;
   EXPECT_TRUE(DownloadHistory::IsPersisted(&item(0)));
@@ skipping 18 matching lines @@
 TEST_F(DownloadHistoryTest, DownloadHistoryTest_Temporary) {
   // Create a fresh item not from history, OnDownloadCreated, OnDownloadUpdated,
   // OnDownloadRemoved.
   ExpectWillQueryDownloads(scoped_ptr<InfoVector>(new InfoVector()));
 
   // Note that db_handle must be -1 at first because it isn't in the db yet.
   history::DownloadRow info;
   FilePath path(FILE_PATH_LITERAL("/foo/bar.pdf"));
   GURL url("http://example.com/bar.pdf");
   GURL referrer("http://example.com/referrer.html");
+  std::vector<GURL> url_chain;
+  url_chain.push_back(url);
   InitItem(base::RandInt(0, 1 << 20),
            path,
-           url,
+           path,
+           url_chain,
            referrer,
            (base::Time::Now() - base::TimeDelta::FromMinutes(10)),
            (base::Time::Now() - base::TimeDelta::FromMinutes(1)),
            100,
            100,
            content::DownloadItem::COMPLETE,
+           content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+           content::DOWNLOAD_INTERRUPT_REASON_NONE,
            -1,
            false,
            &info);
 
   // Pretend the manager just created |item|.
   CallOnDownloadCreated(0);
   // CreateDownload() always gets db_handle=-1.
   ExpectDownloadCreated(info);
   info.db_handle = 0;
   EXPECT_TRUE(DownloadHistory::IsPersisted(&item(0)));
@@ skipping 32 matching lines @@
 // Test removing downloads while they're still being added.
 TEST_F(DownloadHistoryTest,
     DownloadHistoryTest_RemoveWhileAdding) {
   ExpectWillQueryDownloads(scoped_ptr<InfoVector>(new InfoVector()));
 
   // Note that db_handle must be -1 at first because it isn't in the db yet.
   history::DownloadRow info;
   FilePath path(FILE_PATH_LITERAL("/foo/bar.pdf"));
   GURL url("http://example.com/bar.pdf");
   GURL referrer("http://example.com/referrer.html");
+  std::vector<GURL> url_chain;
+  url_chain.push_back(url);
   InitItem(base::RandInt(0, 1 << 20),
            path,
-           url,
+           path,
+           url_chain,
            referrer,
            (base::Time::Now() - base::TimeDelta::FromMinutes(10)),
            (base::Time::Now() - base::TimeDelta::FromMinutes(1)),
            100,
            100,
            content::DownloadItem::COMPLETE,
+           content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+           content::DOWNLOAD_INTERRUPT_REASON_NONE,
            -1,
            false,
            &info);
 
   // Instruct CreateDownload() to not callback to DownloadHistory immediately,
   // but to wait for FinishCreateDownload().
   set_slow_create_download(true);
 
   // Pretend the manager just created |item|.
   CallOnDownloadCreated(0);
@@ skipping 22 matching lines @@
 }
 
 // Test loading multiple items from the database and removing them all.
 TEST_F(DownloadHistoryTest, DownloadHistoryTest_Multiple) {
   // Load a download from history, create the item, OnDownloadCreated,
   // OnDownloadUpdated, OnDownloadRemoved.
   history::DownloadRow info0, info1;
   FilePath path0(FILE_PATH_LITERAL("/foo/bar.pdf"));
   GURL url0("http://example.com/bar.pdf");
   GURL referrer0("http://example.com/referrer.html");
+  std::vector<GURL> url0_chain;
+  url0_chain.push_back(url0);
   InitItem(base::RandInt(0, 1 << 10),
            path0,
-           url0,
+           path0,
+           url0_chain,
            referrer0,
            (base::Time::Now() - base::TimeDelta::FromMinutes(11)),
            (base::Time::Now() - base::TimeDelta::FromMinutes(2)),
            100,
            100,
            content::DownloadItem::COMPLETE,
+           content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+           content::DOWNLOAD_INTERRUPT_REASON_NONE,
            base::RandInt(0, 1 << 10),
            false,
            &info0);
   FilePath path1(FILE_PATH_LITERAL("/foo/qux.pdf"));
   GURL url1("http://example.com/qux.pdf");
   GURL referrer1("http://example.com/referrer.html");
+  std::vector<GURL> url1_chain;
+  url1_chain.push_back(url0);
   InitItem(item(0).GetId() + base::RandInt(1, 1 << 10),
            path1,
-           url1,
+           path1,
+           url1_chain,
            referrer1,
            (base::Time::Now() - base::TimeDelta::FromMinutes(10)),
            (base::Time::Now() - base::TimeDelta::FromMinutes(1)),
            200,
            200,
            content::DownloadItem::COMPLETE,
+           content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+           content::DOWNLOAD_INTERRUPT_REASON_NONE,
            info0.db_handle + base::RandInt(1, 1 << 10),
            false,
            &info1);
   {
     scoped_ptr<InfoVector> infos(new InfoVector());
     infos->push_back(info0);
     infos->push_back(info1);
     ExpectWillQueryDownloads(infos.Pass());
     ExpectNoDownloadCreated();
   }
@@ skipping 14 matching lines @@
 TEST_F(DownloadHistoryTest, DownloadHistoryTest_CreateFailed) {
   // Create a fresh item not from history, OnDownloadCreated, OnDownloadUpdated,
   // OnDownloadRemoved.
   ExpectWillQueryDownloads(scoped_ptr<InfoVector>(new InfoVector()));
 
   // Note that db_handle must be -1 at first because it isn't in the db yet.
   history::DownloadRow info;
   FilePath path(FILE_PATH_LITERAL("/foo/bar.pdf"));
   GURL url("http://example.com/bar.pdf");
   GURL referrer("http://example.com/referrer.html");
+  std::vector<GURL> url_chain;
+  url_chain.push_back(url);
   InitItem(base::RandInt(0, 1 << 20),
            path,
-           url,
+           path,
+           url_chain,
            referrer,
            (base::Time::Now() - base::TimeDelta::FromMinutes(10)),
            (base::Time::Now() - base::TimeDelta::FromMinutes(1)),
            100,
            100,
            content::DownloadItem::COMPLETE,
+           content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+           content::DOWNLOAD_INTERRUPT_REASON_NONE,
            -1,
            false,
            &info);
 
   FailCreateDownload();
   // Pretend the manager just created |item|.
   CallOnDownloadCreated(0);
   // CreateDownload() always gets db_handle=-1.
   ExpectDownloadCreated(info);
   EXPECT_FALSE(DownloadHistory::IsPersisted(&item(0)));
 
   EXPECT_CALL(item(0), GetReceivedBytes()).WillRepeatedly(Return(100));
   item_observer()->OnDownloadUpdated(&item(0));
   info.received_bytes = 100;
   ExpectDownloadCreated(info);
   EXPECT_TRUE(DownloadHistory::IsPersisted(&item(0)));
 }
 
 TEST_F(DownloadHistoryTest,
     DownloadHistoryTest_UpdateWhileAdding) {
   // Create a fresh item not from history, OnDownloadCreated, OnDownloadUpdated,
   // OnDownloadRemoved.
   ExpectWillQueryDownloads(scoped_ptr<InfoVector>(new InfoVector()));
 
   // Note that db_handle must be -1 at first because it isn't in the db yet.
   history::DownloadRow info;
   FilePath path(FILE_PATH_LITERAL("/foo/bar.pdf"));
   GURL url("http://example.com/bar.pdf");
   GURL referrer("http://example.com/referrer.html");
+  std::vector<GURL> url_chain;
+  url_chain.push_back(url);
   InitItem(base::RandInt(0, 1 << 20),
            path,
-           url,
+           path,
+           url_chain,
            referrer,
            (base::Time::Now() - base::TimeDelta::FromMinutes(10)),
            (base::Time::Now() - base::TimeDelta::FromMinutes(1)),
            100,
            100,
            content::DownloadItem::COMPLETE,
+           content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+           content::DOWNLOAD_INTERRUPT_REASON_NONE,
            -1,
            false,
            &info);
 
   // Instruct CreateDownload() to not callback to DownloadHistory immediately,
   // but to wait for FinishCreateDownload().
   set_slow_create_download(true);
 
   // Pretend the manager just created |item|.
   CallOnDownloadCreated(0);
   // CreateDownload() always gets db_handle=-1.
   ExpectDownloadCreated(info);
   info.db_handle = 0;
   EXPECT_FALSE(DownloadHistory::IsPersisted(&item(0)));
 
   // Pretend that something changed on the item.
   EXPECT_CALL(item(0), GetOpened()).WillRepeatedly(Return(true));
   item_observer()->OnDownloadUpdated(&item(0));
 
   FinishCreateDownload();
   EXPECT_TRUE(DownloadHistory::IsPersisted(&item(0)));
 
   // ItemAdded should call OnDownloadUpdated, which should detect that the item
   // changed while it was being added and call UpdateDownload immediately.
   info.opened = true;
   ExpectDownloadUpdated(info);
 }