DownloadManager::Observer::OnDownloadCreated

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 176 matching lines @@
                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(WebContents*, FilePath*, FilePath*, bool*));
   MOCK_METHOD5(ChooseSavePath, void(
       WebContents*, const FilePath&, const FilePath::StringType&,
       bool, const content::SavePackagePathPickedCallback&));
 };
 
-MockDownloadManagerDelegate::MockDownloadManagerDelegate() { }
+MockDownloadManagerDelegate::MockDownloadManagerDelegate() {}
 
-MockDownloadManagerDelegate::~MockDownloadManagerDelegate() { }
+MockDownloadManagerDelegate::~MockDownloadManagerDelegate() {}
 
 class MockDownloadFileManager : public DownloadFileManager {
  public:
   MockDownloadFileManager();
 
   void CreateDownloadFile(
       scoped_ptr<DownloadCreateInfo> info,
       scoped_ptr<content::ByteStreamReader> stream,
       scoped_refptr<content::DownloadManager> download_manager,
       bool hash_needed,
@@ skipping 23 matching lines @@
   MOCK_METHOD4(RenameDownloadFile, void(content::DownloadId,
                                         const FilePath&,
                                         bool,
                                         const RenameCompletionCallback&));
   MOCK_CONST_METHOD0(NumberOfActiveDownloads, int());
  protected:
   virtual ~MockDownloadFileManager();
 };
 
 MockDownloadFileManager::MockDownloadFileManager()
-    : DownloadFileManager(NULL) { }
+    : DownloadFileManager(NULL) {}
 
-MockDownloadFileManager::~MockDownloadFileManager() { }
+MockDownloadFileManager::~MockDownloadFileManager() {}
 
 class MockDownloadItemFactory
     : public content::DownloadItemFactory,
       public base::SupportsWeakPtr<MockDownloadItemFactory> {
  public:
   MockDownloadItemFactory();
   virtual ~MockDownloadItemFactory();
 
   // Access to map of created items.
   // TODO(rdsmith): Could add type (save page, persisted, etc.)
@@ skipping 114 matching lines @@
       new StrictMock<MockDownloadItemImpl>(&item_delegate_);
   EXPECT_CALL(*result, GetId())
       .WillRepeatedly(Return(local_id));
   items_[local_id] = result;
 
   return result;
 }
 
 class MockBrowserContext : public content::BrowserContext {
  public:
-  MockBrowserContext() { }
-  ~MockBrowserContext() { }
+  MockBrowserContext() {}
+  ~MockBrowserContext() {}
 
   MOCK_METHOD0(GetPath, FilePath());
   MOCK_CONST_METHOD0(IsOffTheRecord, bool());
   MOCK_METHOD0(GetRequestContext, net::URLRequestContextGetter*());
   MOCK_METHOD1(GetRequestContextForRenderProcess,
                net::URLRequestContextGetter*(int renderer_child_id));
   MOCK_METHOD0(GetRequestContextForMedia, net::URLRequestContextGetter*());
   MOCK_METHOD0(GetResourceContext, content::ResourceContext*());
   MOCK_METHOD0(GetDownloadManagerDelegate, content::DownloadManagerDelegate*());
   MOCK_METHOD0(GetGeolocationPermissionContext,
                content::GeolocationPermissionContext* ());
   MOCK_METHOD0(GetSpeechRecognitionPreferences,
                content::SpeechRecognitionPreferences* ());
   MOCK_METHOD0(DidLastSessionExitCleanly, bool());
   MOCK_METHOD0(GetSpecialStoragePolicy, quota::SpecialStoragePolicy*());
 };
 
+class MockDownloadManagerObserver : public content::DownloadManager::Observer {
+ public:
+  MockDownloadManagerObserver() {}
+  ~MockDownloadManagerObserver() {}
+  MOCK_METHOD2(OnDownloadCreated, void(
+        content::DownloadManager*, content::DownloadItem*));
+  MOCK_METHOD1(ModelChanged, void(content::DownloadManager*));
+  MOCK_METHOD1(ManagerGoingDown, void(content::DownloadManager*));
+  MOCK_METHOD2(SelectFileDialogDisplayed, void(
+        content::DownloadManager*, int32));
+};
+
 } // namespace
 
 class DownloadManagerTest : public testing::Test {
  public:
   static const char* kTestData;
   static const size_t kTestDataLen;
 
   DownloadManagerTest()
       : ui_thread_(content::BrowserThread::UI, &message_loop_),
         file_thread_(content::BrowserThread::FILE, &message_loop_),
@@ skipping 18 matching lines @@
     EXPECT_CALL(*mock_download_file_manager_.get(),
                 OnDownloadManagerShutdown(_));
     mock_browser_context_.reset(new StrictMock<MockBrowserContext>);
     EXPECT_CALL(*mock_browser_context_.get(), IsOffTheRecord())
         .WillRepeatedly(Return(false));
 
     download_manager_ = new DownloadManagerImpl(
         mock_download_file_manager_.get(),
         scoped_ptr<content::DownloadItemFactory>(
             mock_download_item_factory_.get()).Pass(), NULL);
+    observer_.reset(new MockDownloadManagerObserver());
+    EXPECT_CALL(GetMockObserver(), ModelChanged(download_manager_.get()))
+        .WillOnce(Return());
+    download_manager_->AddObserver(observer_.get());
     download_manager_->SetDelegate(mock_download_manager_delegate_.get());
     download_manager_->Init(mock_browser_context_.get());
   }
 
   virtual void TearDown() {
     while (MockDownloadItemImpl*
            item = mock_download_item_factory_->PopItem()) {
       EXPECT_CALL(*item, GetSafetyState())
           .WillOnce(Return(content::DownloadItem::SAFE));
       EXPECT_CALL(*item, IsPartialDownload())
           .WillOnce(Return(false));
     }
+    EXPECT_CALL(GetMockObserver(), ManagerGoingDown(download_manager_.get()))
+        .WillOnce(Return());
 
     download_manager_->Shutdown();
     download_manager_ = NULL;
     message_loop_.RunAllPending();
     ASSERT_EQ(NULL, mock_download_item_factory_.get());
     message_loop_.RunAllPending();
     mock_download_manager_delegate_.reset();
     mock_download_file_manager_ = NULL;
     mock_browser_context_.reset();
   }
@@ skipping 33 matching lines @@
   }
 
   MockDownloadManagerDelegate& GetMockDownloadManagerDelegate() {
     return *mock_download_manager_delegate_;
   }
 
   MockDownloadFileManager& GetMockDownloadFileManager() {
     return *mock_download_file_manager_;
   }
 
+  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())
@@ skipping 26 matching lines @@
   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_;
   scoped_refptr<MockDownloadFileManager> mock_download_file_manager_;
   scoped_ptr<MockBrowserContext> mock_browser_context_;
+  scoped_ptr<MockDownloadManagerObserver> observer_;
   int next_download_id_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadManagerTest);
 };
 
 // Confirm the appropriate invocations occur when you start a download.
 TEST_F(DownloadManagerTest, StartDownload) {
   scoped_ptr<DownloadCreateInfo> info(new DownloadCreateInfo);
   scoped_ptr<content::ByteStreamReader> stream;
   int32 local_id(5);                    // Random value
 
   EXPECT_FALSE(download_manager_->GetActiveDownloadItem(local_id));
 
+  EXPECT_CALL(GetMockObserver(), OnDownloadCreated(download_manager_.get(), _))
+      .WillOnce(Return());
   EXPECT_CALL(GetMockDownloadManagerDelegate(), GetNextId())
       .WillOnce(Return(content::DownloadId(this, local_id)));
   EXPECT_CALL(GetMockDownloadManagerDelegate(), GenerateFileHash())
       .WillOnce(Return(true));
   EXPECT_CALL(GetMockDownloadFileManager(), MockCreateDownloadFile(
       info.get(), static_cast<content::ByteStreamReader*>(NULL),
       download_manager_.get(), true, _, _));
 
   download_manager_->StartDownload(info.Pass(), stream.Pass());
   EXPECT_TRUE(download_manager_->GetActiveDownloadItem(local_id));
 }
 
 // Does the DownloadManager prompt when requested?
 TEST_F(DownloadManagerTest, RestartDownload) {
+  EXPECT_CALL(GetMockObserver(), OnDownloadCreated(download_manager_.get(), _))
+      .WillOnce(Return());
+  EXPECT_CALL(GetMockObserver(), SelectFileDialogDisplayed(
+        download_manager_.get(), 0)).WillOnce(Return());
   // Put a mock we have a handle to on the download manager.
   MockDownloadItemImpl& item(AddItemToManager());
   int download_id = item.GetId();
 
   // Confirm we're internally consistent.
   EXPECT_EQ(&item, download_manager_->GetActiveDownloadItem(download_id));
 
   ScopedTempDir download_dir;
   ASSERT_TRUE(download_dir.CreateUniqueTempDir());
   FilePath expected_path(download_dir.path().Append(
       FILE_PATH_LITERAL("location")));
 
   EXPECT_CALL(item, GetTargetDisposition())
       .WillOnce(Return(DownloadItem::TARGET_DISPOSITION_PROMPT));
   EXPECT_CALL(GetMockDownloadManagerDelegate(), ChooseDownloadPath(&item));
   download_manager_->RestartDownload(download_id);
 
   // The alternative pathway goes straight to OnTargetPathAvailable,
   // so it more naturally belongs below.
 }
 
 // Do the results of GetIntermediatePath get passed through to the
 // download?  Note that this path is tested from RestartDownload
 // to test the non-prompting path in RestartDownload as well.
 TEST_F(DownloadManagerTest, OnTargetPathAvailable) {
+  EXPECT_CALL(GetMockObserver(), OnDownloadCreated(download_manager_.get(), _))
+      .WillOnce(Return());
   // Put a mock we have a handle to on the download manager.
   MockDownloadItemImpl& item(AddItemToManager());
 
   ScopedTempDir download_dir;
   ASSERT_TRUE(download_dir.CreateUniqueTempDir());
   FilePath target_path(download_dir.path().Append(
       FILE_PATH_LITERAL("location")));
   FilePath intermediate_path(download_dir.path().Append(
       FILE_PATH_LITERAL("location.crdownload")));
 
   EXPECT_CALL(item, GetTargetDisposition())
       .WillOnce(Return(DownloadItem::TARGET_DISPOSITION_OVERWRITE));
   EXPECT_CALL(GetMockDownloadManagerDelegate(),
               GetIntermediatePath(Ref(item)))
       .WillOnce(Return(intermediate_path));
   // Finesse DCHECK with WillRepeatedly.
   EXPECT_CALL(item, GetTargetFilePath())
       .WillRepeatedly(ReturnRef(target_path));
   EXPECT_CALL(item, OnIntermediatePathDetermined(
       &GetMockDownloadFileManager(), intermediate_path));
   download_manager_->RestartDownload(item.GetId());
 }
 
 // Do the results of an OnDownloadInterrupted get passed through properly
 // to the DownloadItem?
 TEST_F(DownloadManagerTest, OnDownloadInterrupted) {
+  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();
 
   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) {
+  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(&GetMockDownloadFileManager()));
   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(item, GetExternalData(_))
       .WillOnce(Return(static_cast<DownloadItem::ExternalData*>(NULL)));
+  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(&GetMockDownloadFileManager()));
   DownloadStopped(&item);
   EXPECT_EQ(NULL, download_manager_->GetActiveDownloadItem(download_id));
 }