Download filename determination refactor (3/3)

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 46 matching lines @@
 
 class MockDownloadItemImpl : public DownloadItemImpl {
  public:
   // Use history constructor for minimal base object.
   MockDownloadItemImpl(DownloadItemImplDelegate* delegate)
       : DownloadItemImpl(delegate, content::DownloadId(),
                          content::DownloadPersistentStoreInfo(),
                          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());
   MOCK_METHOD0(ShouldOpenFileBasedOnExtension, bool());
   MOCK_METHOD0(OpenDownload, void());
   MOCK_METHOD0(ShowDownloadInShell, void());
   MOCK_METHOD0(DangerousDownloadValidated, void());
   MOCK_METHOD3(UpdateProgress, void(int64, int64, const std::string&));
   MOCK_METHOD1(Cancel, void(bool));
   MOCK_METHOD0(MarkAsComplete, void());
   MOCK_METHOD1(DelayedDownloadOpened, void(bool));
   MOCK_METHOD2(OnAllDataSaved, void(int64, const std::string&));
   MOCK_METHOD0(OnDownloadedFileRemoved, void());
   MOCK_METHOD0(MaybeCompleteDownload, void());
   MOCK_METHOD1(Interrupt, void(DownloadInterruptReason));
   MOCK_METHOD1(Delete, void(DeleteReason));
   MOCK_METHOD0(Remove, void());
   MOCK_CONST_METHOD1(TimeRemaining, bool(base::TimeDelta*));
   MOCK_CONST_METHOD0(CurrentSpeed, int64());
   MOCK_CONST_METHOD0(PercentComplete, int());
   MOCK_CONST_METHOD0(AllDataSaved, bool());
   MOCK_METHOD0(TogglePause, void());
-  MOCK_METHOD1(OnDownloadCompleting, void(DownloadFileManager*));
+  MOCK_METHOD0(OnDownloadCompleting, void());
   MOCK_CONST_METHOD1(MatchesQuery, bool(const string16& query));
   MOCK_CONST_METHOD0(IsPartialDownload, bool());
   MOCK_CONST_METHOD0(IsInProgress, bool());
   MOCK_CONST_METHOD0(IsCancelled, bool());
   MOCK_CONST_METHOD0(IsInterrupted, bool());
   MOCK_CONST_METHOD0(IsComplete, bool());
   MOCK_CONST_METHOD0(GetFullPath, const FilePath&());
   MOCK_CONST_METHOD0(GetTargetFilePath, const FilePath&());
   MOCK_CONST_METHOD0(GetTargetDisposition, TargetDisposition());
-  MOCK_METHOD3(OnTargetPathDetermined, void(const FilePath&,
-                                            TargetDisposition,
-                                            content::DownloadDangerType));
-  MOCK_METHOD1(OnTargetPathSelected, void(const FilePath&));
   MOCK_METHOD1(OnContentCheckCompleted, void(content::DownloadDangerType));
-  MOCK_METHOD2(OnIntermediatePathDetermined, void(DownloadFileManager*,
-                                                  const FilePath&));
   MOCK_CONST_METHOD0(GetState, DownloadState());
   MOCK_CONST_METHOD0(GetUrlChain, const std::vector<GURL>&());
   MOCK_METHOD1(SetTotalBytes, void(int64));
   MOCK_CONST_METHOD0(GetURL, const GURL&());
   MOCK_CONST_METHOD0(GetOriginalUrl, const GURL&());
   MOCK_CONST_METHOD0(GetReferrerUrl, const GURL&());
   MOCK_CONST_METHOD0(GetSuggestedFilename, std::string());
   MOCK_CONST_METHOD0(GetContentDisposition, std::string());
   MOCK_CONST_METHOD0(GetMimeType, std::string());
   MOCK_CONST_METHOD0(GetOriginalMimeType, std::string());
@@ skipping 32 matching lines @@
   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_METHOD1(OffThreadCancel, void(DownloadFileManager* file_manager));
+  MOCK_METHOD0(OffThreadCancel, void());
   MOCK_CONST_METHOD1(DebugString, std::string(bool));
   MOCK_METHOD0(MockDownloadOpenForTesting, void());
   MOCK_METHOD1(GetExternalData, ExternalData*(const void*));
   MOCK_CONST_METHOD1(GetExternalData, const ExternalData*(const void*));
   MOCK_METHOD2(SetExternalData, void(const void*, ExternalData*));
 };
 
 class MockDownloadManagerDelegate : public content::DownloadManagerDelegate {
  public:
   MockDownloadManagerDelegate();
   virtual ~MockDownloadManagerDelegate();
 
   MOCK_METHOD0(Shutdown, void());
   MOCK_METHOD0(GetNextId, content::DownloadId());
-  MOCK_METHOD1(ShouldStartDownload, bool(int32));
-  MOCK_METHOD1(ChooseDownloadPath, void(DownloadItem*));
-  MOCK_METHOD1(GetIntermediatePath, FilePath(const DownloadItem&));
+  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&));
@@ skipping 375 matching lines @@
   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) {
-  // 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) {
-  // 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) {
   // 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) {
   // 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()));
+  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) {
   // 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)));
   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()));
+  EXPECT_CALL(item, OffThreadCancel());
   DownloadStopped(&item);
   EXPECT_EQ(NULL, download_manager_->GetActiveDownloadItem(download_id));
 }