[Downloads] Add real observers to MockDownloadItem.

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 180 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(FakeHistoryAdapter);
 };
 
 class DownloadHistoryTest : public testing::Test {
  public:
   DownloadHistoryTest()
       : ui_thread_(content::BrowserThread::UI, &loop_),
         manager_(new content::MockDownloadManager()),
         history_(NULL),
         manager_observer_(NULL),
-        item_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]; }
 
   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) {
       content::MockDownloadManager::CreateDownloadItemAdapter adapter(
           infos->at(index).id,
@@ skipping 183 matching lines @@
     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(_));
     EXPECT_CALL(item(index), IsTemporary()).WillRepeatedly(Return(false));
 #if !defined(OS_ANDROID)
     new extensions::DownloadedByExtension(
         &item(index), by_extension_id, by_extension_name);
 #endif
 
     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:
   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_;
-  content::DownloadItem::Observer* item_observer_;
   size_t download_created_index_;
 
   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());
     ExpectNoDownloadCreated();
   }
   EXPECT_TRUE(DownloadHistory::IsPersisted(&item(0)));
 
   // Pretend that something changed on the item.
   EXPECT_CALL(item(0), GetOpened()).WillRepeatedly(Return(true));
-  item_observer()->OnDownloadUpdated(&item(0));
+  item(0).NotifyObserversDownloadUpdated();
   info.opened = true;
   ExpectDownloadUpdated(info);
 
   // Pretend that the user removed the item.
   IdSet ids;
   ids.insert(info.id);
-  item_observer()->OnDownloadRemoved(&item(0));
+  item(0).NotifyObserversDownloadRemoved();
   ExpectDownloadsRemoved(ids);
 }
 
 // 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()));
 
   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_observer()->OnDownloadUpdated(&item(0));
+  item(0).NotifyObserversDownloadUpdated();
   info.opened = true;
   ExpectDownloadUpdated(info);
 
   // Pretend that the user removed the item.
   IdSet ids;
   ids.insert(info.id);
-  item_observer()->OnDownloadRemoved(&item(0));
+  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()));
 
   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)));
 
   base::FilePath new_path(FILE_PATH_LITERAL("/foo/baz.txt"));
   base::Time new_time(base::Time::Now());
   std::string new_etag("new etag");
   std::string new_last_modifed("new last modified");
 
   // current_path
   EXPECT_CALL(item(0), GetFullPath()).WillRepeatedly(ReturnRefOfCopy(new_path));
   info.current_path = new_path;
-  item_observer()->OnDownloadUpdated(&item(0));
+  item(0).NotifyObserversDownloadUpdated();
   ExpectDownloadUpdated(info);
 
   // target_path
   EXPECT_CALL(item(0), GetTargetFilePath())
       .WillRepeatedly(ReturnRefOfCopy(new_path));
   info.target_path = new_path;
-  item_observer()->OnDownloadUpdated(&item(0));
+  item(0).NotifyObserversDownloadUpdated();
   ExpectDownloadUpdated(info);
 
   // end_time
   EXPECT_CALL(item(0), GetEndTime()).WillRepeatedly(Return(new_time));
   info.end_time = new_time;
-  item_observer()->OnDownloadUpdated(&item(0));
+  item(0).NotifyObserversDownloadUpdated();
   ExpectDownloadUpdated(info);
 
   // received_bytes
   EXPECT_CALL(item(0), GetReceivedBytes()).WillRepeatedly(Return(101));
   info.received_bytes = 101;
-  item_observer()->OnDownloadUpdated(&item(0));
+  item(0).NotifyObserversDownloadUpdated();
   ExpectDownloadUpdated(info);
 
   // total_bytes
   EXPECT_CALL(item(0), GetTotalBytes()).WillRepeatedly(Return(102));
   info.total_bytes = 102;
-  item_observer()->OnDownloadUpdated(&item(0));
+  item(0).NotifyObserversDownloadUpdated();
   ExpectDownloadUpdated(info);
 
   // etag
   EXPECT_CALL(item(0), GetETag()).WillRepeatedly(ReturnRefOfCopy(new_etag));
   info.etag = new_etag;
-  item_observer()->OnDownloadUpdated(&item(0));
+  item(0).NotifyObserversDownloadUpdated();
   ExpectDownloadUpdated(info);
 
   // last_modified
   EXPECT_CALL(item(0), GetLastModifiedTime())
       .WillRepeatedly(ReturnRefOfCopy(new_last_modifed));
   info.last_modified = new_last_modifed;
-  item_observer()->OnDownloadUpdated(&item(0));
+  item(0).NotifyObserversDownloadUpdated();
   ExpectDownloadUpdated(info);
 
   // state
   EXPECT_CALL(item(0), GetState())
       .WillRepeatedly(Return(content::DownloadItem::INTERRUPTED));
   info.state = content::DownloadItem::INTERRUPTED;
-  item_observer()->OnDownloadUpdated(&item(0));
+  item(0).NotifyObserversDownloadUpdated();
   ExpectDownloadUpdated(info);
 
   // danger_type
   EXPECT_CALL(item(0), GetDangerType())
       .WillRepeatedly(Return(content::DOWNLOAD_DANGER_TYPE_DANGEROUS_CONTENT));
   info.danger_type = content::DOWNLOAD_DANGER_TYPE_DANGEROUS_CONTENT;
-  item_observer()->OnDownloadUpdated(&item(0));
+  item(0).NotifyObserversDownloadUpdated();
   ExpectDownloadUpdated(info);
 
   // interrupt_reason
   EXPECT_CALL(item(0), GetLastReason())
       .WillRepeatedly(Return(content::DOWNLOAD_INTERRUPT_REASON_SERVER_FAILED));
   info.interrupt_reason = content::DOWNLOAD_INTERRUPT_REASON_SERVER_FAILED;
-  item_observer()->OnDownloadUpdated(&item(0));
+  item(0).NotifyObserversDownloadUpdated();
   ExpectDownloadUpdated(info);
 
   // opened
   EXPECT_CALL(item(0), GetOpened()).WillRepeatedly(Return(true));
   info.opened = true;
-  item_observer()->OnDownloadUpdated(&item(0));
+  item(0).NotifyObserversDownloadUpdated();
   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()));
 
   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 the item was marked temporary. DownloadHistory should remove it
   // from history and start ignoring it.
   EXPECT_CALL(item(0), IsTemporary()).WillRepeatedly(Return(true));
-  item_observer()->OnDownloadUpdated(&item(0));
+  item(0).NotifyObserversDownloadUpdated();
   IdSet ids;
   ids.insert(info.id);
   ExpectDownloadsRemoved(ids);
 
   // Change something that would make DownloadHistory call UpdateDownload if the
   // item weren't temporary.
   EXPECT_CALL(item(0), GetReceivedBytes()).WillRepeatedly(Return(4200));
-  item_observer()->OnDownloadUpdated(&item(0));
+  item(0).NotifyObserversDownloadUpdated();
   ExpectNoDownloadUpdated();
 
   // Changing a temporary item back to a non-temporary item should make
   // DownloadHistory call CreateDownload.
   EXPECT_CALL(item(0), IsTemporary()).WillRepeatedly(Return(false));
-  item_observer()->OnDownloadUpdated(&item(0));
+  item(0).NotifyObserversDownloadUpdated();
   info.received_bytes = 4200;
   ExpectDownloadCreated(info);
   EXPECT_TRUE(DownloadHistory::IsPersisted(&item(0)));
 
   EXPECT_CALL(item(0), GetReceivedBytes()).WillRepeatedly(Return(100));
-  item_observer()->OnDownloadUpdated(&item(0));
+  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()));
 
   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)));
 
   // Call OnDownloadRemoved before calling back to DownloadHistory::ItemAdded().
   // Instead of calling RemoveDownloads() immediately, DownloadHistory should
   // add the item's id to removed_while_adding_. Then, ItemAdded should
   // immediately remove the item's record from history.
-  item_observer()->OnDownloadRemoved(&item(0));
+  item(0).NotifyObserversDownloadRemoved();
   EXPECT_CALL(manager(), GetDownload(item(0).GetId()))
     .WillRepeatedly(Return(static_cast<content::DownloadItem*>(NULL)));
   ExpectNoDownloadsRemoved();
   EXPECT_FALSE(DownloadHistory::IsPersisted(&item(0)));
 
   // Now callback to DownloadHistory::ItemAdded(), and expect a call to
   // RemoveDownloads() for the item that was removed while it was being added.
   FinishCreateDownload();
   IdSet ids;
   ids.insert(info.id);
@@ skipping 22 matching lines @@
     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_observer()->OnDownloadRemoved(&item(0));
-  item_observer()->OnDownloadRemoved(&item(1));
+  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()));
 
   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_observer()->OnDownloadUpdated(&item(0));
+  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()));
 
   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_observer()->OnDownloadUpdated(&item(0));
+  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);
 }