[Downloads] Ask DownloadHistory if a download was from history.

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/memory/weak_ptr.h"
 #include "base/rand_util.h"
 #include "base/stl_util.h"
 #include "chrome/browser/download/download_history.h"
 #include "chrome/browser/history/download_database.h"
 #include "chrome/browser/history/download_row.h"
 #include "chrome/browser/history/history_service.h"
 #include "content/public/test/mock_download_item.h"
 #include "content/public/test/mock_download_manager.h"
 #include "content/public/test/test_browser_thread.h"
 #include "content/public/test/test_utils.h"
@@ skipping 168 matching lines @@
   history::DownloadRow update_download_;
   scoped_ptr<InfoVector> expect_query_downloads_;
   IdSet remove_downloads_;
   history::DownloadRow create_download_info_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeHistoryAdapter);
 };
 
 class DownloadHistoryTest : public testing::Test {
  public:
+  // Generic callback that receives a pointer to a StrictMockDownloadItem.
+  typedef base::Callback<void(content::MockDownloadItem*)> DownloadItemCallback;
+
   DownloadHistoryTest()
       : ui_thread_(content::BrowserThread::UI, &loop_),
         manager_(new content::MockDownloadManager()),
         history_(NULL),
         manager_observer_(NULL),
         download_created_index_(0) {}
   virtual ~DownloadHistoryTest() {
     STLDeleteElements(&items_);
   }
 
  protected:
   virtual void TearDown() OVERRIDE {
     download_history_.reset();
   }
 
   content::MockDownloadManager& manager() { return *manager_.get(); }
   content::MockDownloadItem& item(size_t index) { return *items_[index]; }
+  DownloadHistory* download_history() { return download_history_.get(); }
 
   void SetManagerObserver(
       content::DownloadManager::Observer* manager_observer) {
     manager_observer_ = manager_observer;
   }
   content::DownloadManager::Observer* manager_observer() {
     return manager_observer_;
   }
 
-  void ExpectWillQueryDownloads(scoped_ptr<InfoVector> infos) {
+  void CreateDownloadHistory(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) {
       content::MockDownloadManager::CreateDownloadItemAdapter adapter(
           infos->at(index).id,
           infos->at(index).current_path,
@@ skipping 21 matching lines @@
     history_->ExpectWillQueryDownloads(infos.Pass());
     EXPECT_CALL(*manager_.get(), GetAllDownloads(_)).WillRepeatedly(Return());
     download_history_.reset(new DownloadHistory(
         &manager(), scoped_ptr<DownloadHistory::HistoryAdapter>(history_)));
     content::RunAllPendingInMessageLoop(content::BrowserThread::UI);
     history_->ExpectQueryDownloadsDone();
   }
 
   void CallOnDownloadCreated(size_t index) {
     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+    if (!pre_on_create_handler_.is_null())
+      pre_on_create_handler_.Run(&item(index));
     manager_observer()->OnDownloadCreated(&manager(), &item(index));
+    if (!post_on_create_handler_.is_null())
+      post_on_create_handler_.Run(&item(index));
   }
 
   void CallOnDownloadCreatedInOrder() {
     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
     // Gmock doesn't appear to support something like InvokeWithTheseArgs. Maybe
     // gmock needs to learn about base::Callback.
     CallOnDownloadCreated(download_created_index_++);
   }
 
   void set_slow_create_download(bool slow) {
@@ skipping 35 matching lines @@
   void ExpectNoDownloadsRemoved() {
     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
     history_->ExpectNoDownloadsRemoved();
   }
 
   void ExpectDownloadsRemoved(const IdSet& ids) {
     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
     history_->ExpectDownloadsRemoved(ids);
   }
 
+  void ExpectDownloadsRestoredFromHistory(bool expected_value) {
+    DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+    pre_on_create_handler_ =
+        base::Bind(&DownloadHistoryTest::CheckDownloadWasRestoredFromHistory,
+                   base::Unretained(this),
+                   expected_value);
+    post_on_create_handler_ =
+        base::Bind(&DownloadHistoryTest::CheckDownloadWasRestoredFromHistory,
+                   base::Unretained(this),
+                   expected_value);
+  }
+
   void InitBasicItem(const base::FilePath::CharType* path,
                      const char* url_string,
                      const char* referrer_string,
                      history::DownloadRow* info) {
     GURL url(url_string);
     GURL referrer(referrer_string);
     std::vector<GURL> url_chain;
     url_chain.push_back(url);
     InitItem(static_cast<uint32>(items_.size() + 1),
              base::FilePath(path),
@@ skipping 100 matching lines @@
 
     std::vector<content::DownloadItem*> items;
     for (size_t i = 0; i < items_.size(); ++i) {
       items.push_back(&item(i));
     }
     EXPECT_CALL(*manager_.get(), GetAllDownloads(_))
         .WillRepeatedly(SetArgPointee<0>(items));
   }
 
  private:
+  void CheckDownloadWasRestoredFromHistory(bool expected_value,
+                                           content::MockDownloadItem* item) {
+    ASSERT_TRUE(download_history_.get());
+    EXPECT_EQ(expected_value, download_history_->WasRestoredFromHistory(item));
+  }
+
   base::MessageLoopForUI loop_;
   content::TestBrowserThread ui_thread_;
   std::vector<StrictMockDownloadItem*> items_;
   scoped_ptr<content::MockDownloadManager> manager_;
   FakeHistoryAdapter* history_;
   scoped_ptr<DownloadHistory> download_history_;
   content::DownloadManager::Observer* manager_observer_;
   size_t download_created_index_;
+  DownloadItemCallback pre_on_create_handler_;
+  DownloadItemCallback post_on_create_handler_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadHistoryTest);
 };
 
-}  // namespace
-
 // 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;
   InitBasicItem(FILE_PATH_LITERAL("/foo/bar.pdf"),
                 "http://example.com/bar.pdf",
                 "http://example.com/referrer.html",
                 &info);
   {
     scoped_ptr<InfoVector> infos(new InfoVector());
     infos->push_back(info);
-    ExpectWillQueryDownloads(infos.Pass());
+    CreateDownloadHistory(infos.Pass());
     ExpectNoDownloadCreated();
   }
   EXPECT_TRUE(DownloadHistory::IsPersisted(&item(0)));
 
   // Pretend that something changed on the item.
   EXPECT_CALL(item(0), GetOpened()).WillRepeatedly(Return(true));
   item(0).NotifyObserversDownloadUpdated();
   info.opened = true;
   ExpectDownloadUpdated(info);
 
   // Pretend that the user removed the item.
   IdSet ids;
   ids.insert(info.id);
   item(0).NotifyObserversDownloadRemoved();
   ExpectDownloadsRemoved(ids);
 }
 
+// Test that WasRestoredFromHistory accurately identifies downloads that were
+// created from history, even during an OnDownloadCreated() handler.
+TEST_F(DownloadHistoryTest, DownloadHistoryTest_WasRestoredFromHistory_True) {
+  // This sets DownloadHistoryTest to call DH::WasRestoredFromHistory() both
+  // before and after DH::OnDownloadCreated() is called. At each call, the
+  // expected return value is |true| since the download was restored from
+  // history.
+  ExpectDownloadsRestoredFromHistory(true);
+
+  // Construct a DownloadHistory with a single history download. This results in
+  // DownloadManager::CreateDownload() being called for the restored download.
+  // The above test expectation should verify that the value of
+  // WasRestoredFromHistory is correct for this download.
+  history::DownloadRow info;
+  InitBasicItem(FILE_PATH_LITERAL("/foo/bar.pdf"),
+                "http://example.com/bar.pdf",
+                "http://example.com/referrer.html",
+                &info);
+  scoped_ptr<InfoVector> infos(new InfoVector());
+  infos->push_back(info);
+  CreateDownloadHistory(infos.Pass());
+
+  EXPECT_TRUE(DownloadHistory::IsPersisted(&item(0)));
+}
+
+// Test that WasRestoredFromHistory accurately identifies downloads that were
+// not created from history.
+TEST_F(DownloadHistoryTest, DownloadHistoryTest_WasRestoredFromHistory_False) {
+  // This sets DownloadHistoryTest to call DH::WasRestoredFromHistory() both
+  // before and after DH::OnDownloadCreated() is called. At each call, the
+  // expected return value is |true| since the download was restored from
+  // history.
+  ExpectDownloadsRestoredFromHistory(false);
+
+  // Create a DownloadHistory with no history downloads. No
+  // DownloadManager::CreateDownload() calls are expected.
+  CreateDownloadHistory(scoped_ptr<InfoVector>(new InfoVector()));
+
+  // Notify DownloadHistory that a new download was created. The above test
+  // expecation should verify that WasRestoredFromHistory is correct for this
+  // download.
+  history::DownloadRow info;
+  InitBasicItem(FILE_PATH_LITERAL("/foo/bar.pdf"),
+                "http://example.com/bar.pdf",
+                "http://example.com/referrer.html",
+                &info);
+  CallOnDownloadCreated(0);
+  ExpectDownloadCreated(info);
+}
+
 // Test creating an item, saving it to the database, changing it, saving it
 // back, removing it.
 TEST_F(DownloadHistoryTest, DownloadHistoryTest_Create) {
   // Create a fresh item not from history, OnDownloadCreated, OnDownloadUpdated,
   // OnDownloadRemoved.
-  ExpectWillQueryDownloads(scoped_ptr<InfoVector>(new InfoVector()));
+  CreateDownloadHistory(scoped_ptr<InfoVector>(new InfoVector()));
 
   history::DownloadRow info;
   InitBasicItem(FILE_PATH_LITERAL("/foo/bar.pdf"),
                 "http://example.com/bar.pdf",
                 "http://example.com/referrer.html",
                 &info);
 
   // Pretend the manager just created |item|.
   CallOnDownloadCreated(0);
   ExpectDownloadCreated(info);
   EXPECT_TRUE(DownloadHistory::IsPersisted(&item(0)));
 
   // Pretend that something changed on the item.
   EXPECT_CALL(item(0), GetOpened()).WillRepeatedly(Return(true));
   item(0).NotifyObserversDownloadUpdated();
   info.opened = true;
   ExpectDownloadUpdated(info);
 
   // Pretend that the user removed the item.
   IdSet ids;
   ids.insert(info.id);
   item(0).NotifyObserversDownloadRemoved();
   ExpectDownloadsRemoved(ids);
 }
 
 // Test that changes to persisted fields in a DownloadItem triggers database
 // updates.
 TEST_F(DownloadHistoryTest, DownloadHistoryTest_Update) {
-  ExpectWillQueryDownloads(scoped_ptr<InfoVector>(new InfoVector()));
+  CreateDownloadHistory(scoped_ptr<InfoVector>(new InfoVector()));
 
   history::DownloadRow info;
   InitBasicItem(FILE_PATH_LITERAL("/foo/bar.pdf"),
                 "http://example.com/bar.pdf",
                 "http://example.com/referrer.html",
                 &info);
   CallOnDownloadCreated(0);
   ExpectDownloadCreated(info);
   EXPECT_TRUE(DownloadHistory::IsPersisted(&item(0)));
 
@@ skipping 74 matching lines @@
   ExpectDownloadUpdated(info);
 }
 
 // Test creating a new item, saving it, removing it by setting it Temporary,
 // changing it without saving it back because it's Temporary, clearing
 // IsTemporary, saving it back, changing it, saving it back because it isn't
 // Temporary anymore.
 TEST_F(DownloadHistoryTest, DownloadHistoryTest_Temporary) {
   // Create a fresh item not from history, OnDownloadCreated, OnDownloadUpdated,
   // OnDownloadRemoved.
-  ExpectWillQueryDownloads(scoped_ptr<InfoVector>(new InfoVector()));
+  CreateDownloadHistory(scoped_ptr<InfoVector>(new InfoVector()));
 
   history::DownloadRow info;
   InitBasicItem(FILE_PATH_LITERAL("/foo/bar.pdf"),
                 "http://example.com/bar.pdf",
                 "http://example.com/referrer.html",
                 &info);
 
   // Pretend the manager just created |item|.
   CallOnDownloadCreated(0);
   ExpectDownloadCreated(info);
@@ skipping 22 matching lines @@
   EXPECT_TRUE(DownloadHistory::IsPersisted(&item(0)));
 
   EXPECT_CALL(item(0), GetReceivedBytes()).WillRepeatedly(Return(100));
   item(0).NotifyObserversDownloadUpdated();
   info.received_bytes = 100;
   ExpectDownloadUpdated(info);
 }
 
 // Test removing downloads while they're still being added.
 TEST_F(DownloadHistoryTest, DownloadHistoryTest_RemoveWhileAdding) {
-  ExpectWillQueryDownloads(scoped_ptr<InfoVector>(new InfoVector()));
+  CreateDownloadHistory(scoped_ptr<InfoVector>(new InfoVector()));
 
   history::DownloadRow info;
   InitBasicItem(FILE_PATH_LITERAL("/foo/bar.pdf"),
                 "http://example.com/bar.pdf",
                 "http://example.com/referrer.html",
                 &info);
 
   // Instruct CreateDownload() to not callback to DownloadHistory immediately,
   // but to wait for FinishCreateDownload().
   set_slow_create_download(true);
@@ skipping 32 matching lines @@
                 "http://example.com/referrer.html",
                 &info0);
   InitBasicItem(FILE_PATH_LITERAL("/foo/qux.pdf"),
                 "http://example.com/qux.pdf",
                 "http://example.com/referrer1.html",
                 &info1);
   {
     scoped_ptr<InfoVector> infos(new InfoVector());
     infos->push_back(info0);
     infos->push_back(info1);
-    ExpectWillQueryDownloads(infos.Pass());
+    CreateDownloadHistory(infos.Pass());
     ExpectNoDownloadCreated();
   }
 
   EXPECT_TRUE(DownloadHistory::IsPersisted(&item(0)));
   EXPECT_TRUE(DownloadHistory::IsPersisted(&item(1)));
 
   // Pretend that the user removed both items.
   IdSet ids;
   ids.insert(info0.id);
   ids.insert(info1.id);
   item(0).NotifyObserversDownloadRemoved();
   item(1).NotifyObserversDownloadRemoved();
   ExpectDownloadsRemoved(ids);
 }
 
 // Test what happens when HistoryService/CreateDownload::CreateDownload() fails.
 TEST_F(DownloadHistoryTest, DownloadHistoryTest_CreateFailed) {
   // Create a fresh item not from history, OnDownloadCreated, OnDownloadUpdated,
   // OnDownloadRemoved.
-  ExpectWillQueryDownloads(scoped_ptr<InfoVector>(new InfoVector()));
+  CreateDownloadHistory(scoped_ptr<InfoVector>(new InfoVector()));
 
   history::DownloadRow info;
   InitBasicItem(FILE_PATH_LITERAL("/foo/bar.pdf"),
                 "http://example.com/bar.pdf",
                 "http://example.com/referrer.html",
                 &info);
 
   FailCreateDownload();
   // Pretend the manager just created |item|.
   CallOnDownloadCreated(0);
   ExpectDownloadCreated(info);
   EXPECT_FALSE(DownloadHistory::IsPersisted(&item(0)));
 
   EXPECT_CALL(item(0), GetReceivedBytes()).WillRepeatedly(Return(100));
   item(0).NotifyObserversDownloadUpdated();
   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()));
+  CreateDownloadHistory(scoped_ptr<InfoVector>(new InfoVector()));
 
   history::DownloadRow info;
   InitBasicItem(FILE_PATH_LITERAL("/foo/bar.pdf"),
                 "http://example.com/bar.pdf",
                 "http://example.com/referrer.html",
                 &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);
   ExpectDownloadCreated(info);
   EXPECT_FALSE(DownloadHistory::IsPersisted(&item(0)));
 
   // Pretend that something changed on the item.
   EXPECT_CALL(item(0), GetOpened()).WillRepeatedly(Return(true));
   item(0).NotifyObserversDownloadUpdated();
 
   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);
 }
+
+}  // anonymous namespace