Make DownloadHistory observe manager, items

content/browser/download/download_manager_impl_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 <string>
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 50 matching lines @@
 // has a |default_download_directory| that matches |download_directory|.
 MATCHER_P2(DownloadCreateInfoWithDefaultPath, info, download_directory, "") {
   return arg == info &&
       arg->default_download_directory == download_directory;
 }
 
 class MockDownloadItemImpl : public DownloadItemImpl {
  public:
   // Use history constructor for minimal base object.
   MockDownloadItemImpl(DownloadItemImplDelegate* delegate)
-      : DownloadItemImpl(delegate, content::DownloadId(),
-                         content::DownloadPersistentStoreInfo(),
-                         net::BoundNetLog()) {}
+      : DownloadItemImpl(
+          delegate,
+          content::DownloadId(),
+          FilePath(),
+          GURL(),
+          GURL(),
+          base::Time(),
+          base::Time(),
+          0,
+          0,
+          DownloadItem::IN_PROGRESS,
+          false,
+          net::BoundNetLog()) {}
   virtual ~MockDownloadItemImpl() {}
 
   MOCK_METHOD4(OnDownloadTargetDetermined,
                void(const FilePath&, TargetDisposition,
                     content::DownloadDangerType, const FilePath&));
   MOCK_METHOD1(AddObserver, void(content::DownloadItem::Observer*));
   MOCK_METHOD1(RemoveObserver, void(content::DownloadItem::Observer*));
   MOCK_METHOD0(UpdateObservers, void());
   MOCK_METHOD0(CanShowInFolder, bool());
   MOCK_METHOD0(CanOpenDownload, bool());
@@ skipping 40 matching lines @@
   MOCK_CONST_METHOD0(GetReferrerCharset, std::string());
   MOCK_CONST_METHOD0(GetRemoteAddress, std::string());
   MOCK_CONST_METHOD0(GetTotalBytes, int64());
   MOCK_CONST_METHOD0(GetReceivedBytes, int64());
   MOCK_CONST_METHOD0(GetHashState, const std::string&());
   MOCK_CONST_METHOD0(GetHash, const std::string&());
   MOCK_CONST_METHOD0(GetId, int32());
   MOCK_CONST_METHOD0(GetGlobalId, content::DownloadId());
   MOCK_CONST_METHOD0(GetStartTime, base::Time());
   MOCK_CONST_METHOD0(GetEndTime, base::Time());
-  MOCK_METHOD0(SetIsPersisted, void());
-  MOCK_CONST_METHOD0(IsPersisted, bool());
-  MOCK_METHOD1(SetDbHandle, void(int64));
-  MOCK_CONST_METHOD0(GetDbHandle, int64());
   MOCK_METHOD0(GetDownloadManager, content::DownloadManager*());
   MOCK_CONST_METHOD0(IsPaused, bool());
   MOCK_CONST_METHOD0(GetOpenWhenComplete, bool());
   MOCK_METHOD1(SetOpenWhenComplete, void(bool));
   MOCK_CONST_METHOD0(GetFileExternallyRemoved, bool());
   MOCK_CONST_METHOD0(GetSafetyState, SafetyState());
   MOCK_CONST_METHOD0(GetDangerType, content::DownloadDangerType());
   MOCK_CONST_METHOD0(IsDangerous, bool());
   MOCK_METHOD0(GetAutoOpened, bool());
   MOCK_CONST_METHOD0(GetForcedFilePath, const FilePath&());
   MOCK_CONST_METHOD0(HasUserGesture, bool());
   MOCK_CONST_METHOD0(GetTransitionType, content::PageTransition());
   MOCK_CONST_METHOD0(IsTemporary, bool());
   MOCK_METHOD1(SetIsTemporary, void(bool));
   MOCK_METHOD1(SetOpened, void(bool));
   MOCK_CONST_METHOD0(GetOpened, bool());
   MOCK_CONST_METHOD0(GetLastModifiedTime, const std::string&());
   MOCK_CONST_METHOD0(GetETag, const std::string&());
   MOCK_CONST_METHOD0(GetLastReason, DownloadInterruptReason());
-  MOCK_CONST_METHOD0(GetPersistentStoreInfo,
-                     content::DownloadPersistentStoreInfo());
   MOCK_CONST_METHOD0(GetBrowserContext, content::BrowserContext*());
   MOCK_CONST_METHOD0(GetWebContents, content::WebContents*());
   MOCK_CONST_METHOD0(GetFileNameToReportUser, FilePath());
   MOCK_METHOD1(SetDisplayName, void(const FilePath&));
   MOCK_CONST_METHOD0(GetUserVerifiedFilePath, FilePath());
   MOCK_METHOD0(OffThreadCancel, void());
   MOCK_CONST_METHOD1(DebugString, std::string(bool));
   MOCK_METHOD0(MockDownloadOpenForTesting, void());
 };
 
 class MockDownloadManagerDelegate : public content::DownloadManagerDelegate {
  public:
   MockDownloadManagerDelegate();
   virtual ~MockDownloadManagerDelegate();
 
   MOCK_METHOD0(Shutdown, void());
   MOCK_METHOD0(GetNextId, content::DownloadId());
   MOCK_METHOD2(DetermineDownloadTarget,
                bool(DownloadItem* item,
                     const content::DownloadTargetCallback&));
   MOCK_METHOD0(GetAlternativeWebContentsToNotifyForDownload, WebContents*());
   MOCK_METHOD1(ShouldOpenFileBasedOnExtension, bool(const FilePath&));
   MOCK_METHOD2(ShouldCompleteDownload, bool(
       DownloadItem*, const base::Closure&));
   MOCK_METHOD1(ShouldOpenDownload, bool(DownloadItem*));
   MOCK_METHOD0(GenerateFileHash, bool());
-  MOCK_METHOD1(AddItemToPersistentStore, void(DownloadItem*));
-  MOCK_METHOD1(UpdateItemInPersistentStore, void(DownloadItem*));
-  MOCK_METHOD2(UpdatePathForItemInPersistentStore,
-               void(DownloadItem*, const FilePath&));
-  MOCK_METHOD1(RemoveItemFromPersistentStore, void(DownloadItem*));
-  MOCK_METHOD2(RemoveItemsFromPersistentStoreBetween, void(
-      base::Time remove_begin, base::Time remove_end));
   MOCK_METHOD4(GetSaveDir, void(content::BrowserContext*,
                                 FilePath*, FilePath*, bool*));
   MOCK_METHOD5(ChooseSavePath, void(
       WebContents*, const FilePath&, const FilePath::StringType&,
       bool, const content::SavePackagePathPickedCallback&));
 };
 
 MockDownloadManagerDelegate::MockDownloadManagerDelegate() {}
 
 MockDownloadManagerDelegate::~MockDownloadManagerDelegate() {}
@@ skipping 63 matching lines @@
   MockDownloadItemImpl* PopItem();
 
   // Should be called when the item of this id is removed so that
   // we don't keep dangling pointers.
   void RemoveItem(int id);
 
   // Overridden methods from DownloadItemFactory.
   virtual DownloadItemImpl* CreatePersistedItem(
       DownloadItemImplDelegate* delegate,
       content::DownloadId download_id,
-      const content::DownloadPersistentStoreInfo& info,
+      const FilePath& path,
+      const GURL& url,
+      const GURL& referrer_url,
+      const base::Time& start_time,
+      const base::Time& end_time,
+      int64 received_bytes,
+      int64 total_bytes,
+      DownloadItem::DownloadState state,
+      bool opened,
       const net::BoundNetLog& bound_net_log) OVERRIDE;
   virtual DownloadItemImpl* CreateActiveItem(
       DownloadItemImplDelegate* delegate,
       const DownloadCreateInfo& info,
       scoped_ptr<DownloadRequestHandleInterface> request_handle,
       const net::BoundNetLog& bound_net_log) OVERRIDE;
   virtual DownloadItemImpl* CreateSavePageItem(
       DownloadItemImplDelegate* delegate,
       const FilePath& path,
       const GURL& url,
@@ skipping 30 matching lines @@
 }
 
 void MockDownloadItemFactory::RemoveItem(int id) {
   DCHECK(items_.find(id) != items_.end());
   items_.erase(id);
 }
 
 DownloadItemImpl* MockDownloadItemFactory::CreatePersistedItem(
     DownloadItemImplDelegate* delegate,
     content::DownloadId download_id,
-    const content::DownloadPersistentStoreInfo& info,
+    const FilePath& path,
+    const GURL& url,
+    const GURL& referrer_url,
+    const base::Time& start_time,
+    const base::Time& end_time,
+    int64 received_bytes,
+    int64 total_bytes,
+    DownloadItem::DownloadState state,
+    bool opened,
     const net::BoundNetLog& bound_net_log) {
   int local_id = download_id.local();
   DCHECK(items_.find(local_id) == items_.end());
 
   MockDownloadItemImpl* result =
       new StrictMock<MockDownloadItemImpl>(&item_delegate_);
   EXPECT_CALL(*result, GetId())
       .WillRepeatedly(Return(local_id));
   items_[local_id] = result;
 
@@ skipping 187 matching lines @@
 
   MockDownloadManagerObserver& GetMockObserver() {
     return *observer_;
   }
 
   // Probe at private internals.
   void DownloadStopped(DownloadItemImpl* item) {
     download_manager_->DownloadStopped(item);
   }
 
-  void AddItemToHistory(MockDownloadItemImpl& item, int64 db_handle) {
-    // For DCHECK in AddDownloadItemToHistory.  Don't want to use
-    // WillRepeatedly as it may have to return true after this.
-    if (DCHECK_IS_ON())
-      EXPECT_CALL(item, IsPersisted())
-          .WillRepeatedly(Return(false));
-
-    EXPECT_CALL(item, SetDbHandle(db_handle));
-    EXPECT_CALL(item, SetIsPersisted());
-    EXPECT_CALL(item, GetDbHandle())
-        .WillRepeatedly(Return(db_handle));
-
-    // Null out ShowDownloadInBrowser
-    EXPECT_CALL(item, GetWebContents())
-        .WillOnce(Return(static_cast<WebContents*>(NULL)));
-    EXPECT_CALL(GetMockDownloadManagerDelegate(),
-                GetAlternativeWebContentsToNotifyForDownload())
-        .WillOnce(Return(static_cast<WebContents*>(NULL)));
-
-    EXPECT_CALL(item, IsInProgress())
-        .WillOnce(Return(true));
-
-    // Null out MaybeCompleteDownload
-    EXPECT_CALL(item, AllDataSaved())
-        .WillOnce(Return(false));
-
-    download_manager_->OnItemAddedToPersistentStore(item.GetId(), db_handle);
-  }
-
  protected:
   // Key test variable; we'll keep it available to sub-classes.
   scoped_refptr<DownloadManagerImpl> download_manager_;
 
  private:
   MessageLoopForUI message_loop_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread file_thread_;
   base::WeakPtr<MockDownloadItemFactory> mock_download_item_factory_;
   scoped_ptr<MockDownloadManagerDelegate> mock_download_manager_delegate_;
@@ skipping 45 matching lines @@
 
   content::DownloadInterruptReason reason(
       content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED);
 
   EXPECT_CALL(item, Interrupt(reason));
   download_manager_->OnDownloadInterrupted(download_id, reason);
   EXPECT_EQ(&item, download_manager_->GetActiveDownloadItem(download_id));
 }
 
 // Does DownloadStopped remove Download from appropriate queues?
-// This test tests non-persisted downloads.
-TEST_F(DownloadManagerTest, OnDownloadStopped_NonPersisted) {
+TEST_F(DownloadManagerTest, OnDownloadStopped) {
   EXPECT_CALL(GetMockObserver(), OnDownloadCreated(download_manager_.get(), _))
       .WillOnce(Return());
   // Put a mock we have a handle to on the download manager.
   MockDownloadItemImpl& item(AddItemToManager());
 
-  EXPECT_CALL(item, IsPersisted())
-      .WillRepeatedly(Return(false));
   EXPECT_CALL(item, GetState())
       .WillRepeatedly(Return(DownloadItem::CANCELLED));
-  EXPECT_CALL(item, GetDbHandle())
-      .WillRepeatedly(Return(DownloadItem::kUninitializedHandle));
 
   EXPECT_CALL(item, OffThreadCancel());
   DownloadStopped(&item);
   // TODO(rdsmith): Confirm that the download item is no longer on the
   // active list by calling download_manager_->GetActiveDownloadItem(id).
   // Currently, the item is left on the active list for rendez-vous with
   // the history system :-{.
 }
-
-// Does DownloadStopped remove Download from appropriate queues?
-// This test tests persisted downloads.
-TEST_F(DownloadManagerTest, OnDownloadStopped_Persisted) {
-  EXPECT_CALL(GetMockObserver(), OnDownloadCreated(download_manager_.get(), _))
-      .WillOnce(Return());
-  // Put a mock we have a handle to on the download manager.
-  MockDownloadItemImpl& item(AddItemToManager());
-  int download_id = item.GetId();
-  int64 db_handle = 0x7;
-  EXPECT_CALL(GetMockObserver(), ModelChanged(download_manager_.get()))
-      .WillOnce(Return());
-  AddItemToHistory(item, db_handle);
-
-  EXPECT_CALL(item, IsPersisted())
-      .WillRepeatedly(Return(true));
-  EXPECT_CALL(GetMockDownloadManagerDelegate(),
-              UpdateItemInPersistentStore(&item));
-  EXPECT_CALL(item, GetState())
-      .WillRepeatedly(Return(DownloadItem::CANCELLED));
-  EXPECT_CALL(item, GetDbHandle())
-      .WillRepeatedly(Return(db_handle));
-
-  EXPECT_CALL(item, OffThreadCancel());
-  DownloadStopped(&item);
-  EXPECT_EQ(NULL, download_manager_->GetActiveDownloadItem(download_id));
-}