Split DownloadFile::Rename into RenameAndUniquify and RenameAndAnnotate.

content/browser/download/download_browsertest.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.
 
 // This file contains download browser tests that are known to be runnable
 // in a pure content context.  Over time tests should be migrated here.
 
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/scoped_temp_dir.h"
@@ skipping 68 matching lines @@
       const GURL& referrer_url,
       bool calculate_hash,
       scoped_ptr<ByteStreamReader> stream,
       const net::BoundNetLog& bound_net_log,
       scoped_ptr<PowerSaveBlocker> power_save_blocker,
       base::WeakPtr<DownloadDestinationObserver> observer,
       base::WeakPtr<DownloadFileWithDelayFactory> owner);
 
   virtual ~DownloadFileWithDelay();
 
-  // Wraps DownloadFileImpl::Rename and intercepts the return callback,
+  // Wraps DownloadFileImpl::Rename* and intercepts the return callback,
   // storing it in the factory that produced this object for later
   // retrieval.
-  virtual void Rename(const FilePath& full_path,
-                      bool overwrite_existing_file,
-                      const RenameCompletionCallback& callback) OVERRIDE;
-
-  // Wraps DownloadFileImpl::Detach and intercepts the return callback,
-  // storing it in the factory that produced this object for later
-  // retrieval.
-  virtual void Detach(const DetachCompletionCallback& callback) OVERRIDE;
+  virtual void RenameAndUniquify(
+      const FilePath& full_path,
+      const RenameCompletionCallback& callback) OVERRIDE;
+  virtual void RenameAndAnnotate(
+      const FilePath& full_path,
+      const RenameCompletionCallback& callback) OVERRIDE;
 
  private:
   static void RenameCallbackWrapper(
       DownloadFileWithDelayFactory* factory,
       const RenameCompletionCallback& original_callback,
       DownloadInterruptReason reason,
       const FilePath& path);
 
-  static void DetachCallbackWrapper(
-      DownloadFileWithDelayFactory* factory,
-      const DetachCompletionCallback& original_callback,
-      DownloadInterruptReason interrupt_reason);
-
   // This variable may only be read on the FILE thread, and may only be
   // indirected through (e.g. methods on DownloadFileWithDelayFactory called)
   // on the UI thread.  This is because after construction,
   // DownloadFileWithDelay lives on the file thread, but
   // DownloadFileWithDelayFactory is purely a UI thread object.
   base::WeakPtr<DownloadFileWithDelayFactory> owner_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadFileWithDelay);
 };
 
 // All routines on this class must be called on the UI thread.
 class DownloadFileWithDelayFactory : public DownloadFileFactory {
  public:
   DownloadFileWithDelayFactory();
   virtual ~DownloadFileWithDelayFactory();
 
   // DownloadFileFactory interface.
   virtual DownloadFile* CreateFile(
       scoped_ptr<DownloadSaveInfo> save_info,
       const FilePath& default_download_directory,
       const GURL& url,
       const GURL& referrer_url,
       bool calculate_hash,
       scoped_ptr<ByteStreamReader> stream,
       const net::BoundNetLog& bound_net_log,
       base::WeakPtr<DownloadDestinationObserver> observer) OVERRIDE;
 
   void AddRenameCallback(base::Closure callback);
-  void AddDetachCallback(base::Closure callback);
   void GetAllRenameCallbacks(std::vector<base::Closure>* results);
-  void GetAllDetachCallbacks(std::vector<base::Closure>* results);
 
-  // Do not return until either GetAllRenameCallbacks() or
-  // GetAllDetachCallbacks() will return a non-empty list.
+  // Do not return until GetAllRenameCallbacks() will return a non-empty list.
   void WaitForSomeCallback();
 
  private:
   base::WeakPtrFactory<DownloadFileWithDelayFactory> weak_ptr_factory_;
   std::vector<base::Closure> rename_callbacks_;
-  std::vector<base::Closure> detach_callbacks_;
   bool waiting_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadFileWithDelayFactory);
 };
 
 DownloadFileWithDelay::DownloadFileWithDelay(
     scoped_ptr<DownloadSaveInfo> save_info,
     const FilePath& default_download_directory,
     const GURL& url,
     const GURL& referrer_url,
     bool calculate_hash,
     scoped_ptr<ByteStreamReader> stream,
     const net::BoundNetLog& bound_net_log,
     scoped_ptr<PowerSaveBlocker> power_save_blocker,
     base::WeakPtr<DownloadDestinationObserver> observer,
     base::WeakPtr<DownloadFileWithDelayFactory> owner)
     : DownloadFileImpl(
         save_info.Pass(), default_download_directory, url, referrer_url,
         calculate_hash, stream.Pass(), bound_net_log,
         power_save_blocker.Pass(), observer),
       owner_(owner) {}
 
 DownloadFileWithDelay::~DownloadFileWithDelay() {}
 
-void DownloadFileWithDelay::Rename(const FilePath& full_path,
-                      bool overwrite_existing_file,
-                      const RenameCompletionCallback& callback) {
+void DownloadFileWithDelay::RenameAndUniquify(
+    const FilePath& full_path, const RenameCompletionCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-  DownloadFileImpl::Rename(
-      full_path, overwrite_existing_file,
-      base::Bind(DownloadFileWithDelay::RenameCallbackWrapper,
-                 owner_, callback));
+  DownloadFileImpl::RenameAndUniquify(
+      full_path, base::Bind(DownloadFileWithDelay::RenameCallbackWrapper,
+                            owner_, callback));
 }
 
-void DownloadFileWithDelay::Detach(const DetachCompletionCallback& callback) {
+void DownloadFileWithDelay::RenameAndAnnotate(
+    const FilePath& full_path, const RenameCompletionCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-  DownloadFileImpl::Detach(
-      base::Bind(DownloadFileWithDelay::DetachCallbackWrapper,
-                 owner_, callback));
+  DownloadFileImpl::RenameAndAnnotate(
+      full_path, base::Bind(DownloadFileWithDelay::RenameCallbackWrapper,
+                            owner_, callback));
 }
 
 // static
 void DownloadFileWithDelay::RenameCallbackWrapper(
     DownloadFileWithDelayFactory* factory,
     const RenameCompletionCallback& original_callback,
     DownloadInterruptReason reason,
     const FilePath& path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   factory->AddRenameCallback(base::Bind(original_callback, reason, path));
 }
 
-// static
-void DownloadFileWithDelay::DetachCallbackWrapper(
-    DownloadFileWithDelayFactory* factory,
-    const DetachCompletionCallback& original_callback,
-    DownloadInterruptReason interrupt_reason) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  factory->AddDetachCallback(base::Bind(original_callback, interrupt_reason));
-}
-
 DownloadFileWithDelayFactory::DownloadFileWithDelayFactory()
     : weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       waiting_(false) {}
 DownloadFileWithDelayFactory::~DownloadFileWithDelayFactory() {}
 
 DownloadFile* DownloadFileWithDelayFactory::CreateFile(
     scoped_ptr<DownloadSaveInfo> save_info,
     const FilePath& default_download_directory,
     const GURL& url,
     const GURL& referrer_url,
@@ skipping 11 matching lines @@
       psb.Pass(), observer, weak_ptr_factory_.GetWeakPtr());
 }
 
 void DownloadFileWithDelayFactory::AddRenameCallback(base::Closure callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   rename_callbacks_.push_back(callback);
   if (waiting_)
     MessageLoopForUI::current()->Quit();
 }
 
-void DownloadFileWithDelayFactory::AddDetachCallback(base::Closure callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  detach_callbacks_.push_back(callback);
-  if (waiting_)
-    MessageLoopForUI::current()->Quit();
-}
-
 void DownloadFileWithDelayFactory::GetAllRenameCallbacks(
     std::vector<base::Closure>* results) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   results->swap(rename_callbacks_);
 }
 
-void DownloadFileWithDelayFactory::GetAllDetachCallbacks(
-    std::vector<base::Closure>* results) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  results->swap(detach_callbacks_);
-}
-
 void DownloadFileWithDelayFactory::WaitForSomeCallback() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  if (rename_callbacks_.empty() && detach_callbacks_.empty()) {
+  if (rename_callbacks_.empty()) {
     waiting_ = true;
     RunMessageLoop();
     waiting_ = false;
   }
 }
 
 bool WasPersisted(DownloadItem* item) {
   return item->IsPersisted();
 }
 
@@ skipping 67 matching lines @@
         new PowerSaveBlocker(
             PowerSaveBlocker::kPowerSaveBlockPreventAppSuspension,
             "Download in progress"));
     return new CountingDownloadFile(
         save_info.Pass(), default_downloads_directory, url, referrer_url,
         calculate_hash, stream.Pass(), bound_net_log,
         psb.Pass(), observer);
   }
 };
 
+class TestShellDownloadManagerDelegate : public ShellDownloadManagerDelegate {
+ public:
+  TestShellDownloadManagerDelegate()
+      : delay_download_open_(false) {}
+
+  virtual bool ShouldOpenDownload(DownloadItem* item) OVERRIDE {
+    if (delay_download_open_) {
+      delayed_ids_.push_back(item->GetId());
+      return false;
+    }
+    return true;
+  }
+
+  void SetDelayedOpen(bool delay) {
+    delay_download_open_ = delay;
+  }
+
+  void GetDelayedIds(std::vector<int32>* ids) {
+    ids->swap(delayed_ids_);
+  }
+ private:
+  virtual ~TestShellDownloadManagerDelegate() {}
+
+  bool delay_download_open_;
+  std::vector<int32> delayed_ids_;
+};
+
 }  // namespace
 
 class DownloadContentTest : public ContentBrowserTest {
  protected:
   virtual void SetUpOnMainThread() OVERRIDE {
     ASSERT_TRUE(downloads_directory_.CreateUniqueTempDir());
 
-    ShellDownloadManagerDelegate* delegate =
-        static_cast<ShellDownloadManagerDelegate*>(
-            shell()->web_contents()->GetBrowserContext()
-            ->GetDownloadManagerDelegate());
+    TestShellDownloadManagerDelegate* delegate =
+        new TestShellDownloadManagerDelegate();
     delegate->SetDownloadBehaviorForTesting(downloads_directory_.path());
+    DownloadManager* manager = DownloadManagerForShell(shell());
+    manager->SetDelegate(delegate);
+    delegate->SetDownloadManager(manager);
 
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&URLRequestSlowDownloadJob::AddUrlHandler));
     FilePath mock_base(GetTestFilePath("download", ""));
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&URLRequestMockHTTPJob::AddUrlHandler, mock_base));
   }
 
+  TestShellDownloadManagerDelegate* GetDownloadManagerDelegate(
+      DownloadManager* manager) {
+    return static_cast<TestShellDownloadManagerDelegate*>(
+        manager->GetDelegate());
+  }
+
   // Create a DownloadTestObserverTerminal that will wait for the
   // specified number of downloads to finish.
   DownloadTestObserver* CreateWaiter(
       Shell* shell, int num_downloads) {
     DownloadManager* download_manager = DownloadManagerForShell(shell);
     return new DownloadTestObserverTerminal(download_manager, num_downloads,
         DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_FAIL);
   }
 
   // Create a DownloadTestObserverInProgress that will wait for the
@@ skipping 177 matching lines @@
   download_manager->SetDownloadFileFactoryForTesting(
       scoped_ptr<DownloadFileFactory>(file_factory).Pass());
 
   // Create a download
   FilePath file(FILE_PATH_LITERAL("download-test.lib"));
   NavigateToURL(shell(), URLRequestMockHTTPJob::GetMockUrl(file));
 
   // Wait until the first (intermediate file) rename and execute the callback.
   file_factory->WaitForSomeCallback();
   std::vector<base::Closure> callbacks;
-  file_factory->GetAllDetachCallbacks(&callbacks);
-  ASSERT_TRUE(callbacks.empty());
   file_factory->GetAllRenameCallbacks(&callbacks);
   ASSERT_EQ(1u, callbacks.size());
   callbacks[0].Run();
   callbacks.clear();
 
   // Wait until the second (final) rename callback is posted.
   file_factory->WaitForSomeCallback();
-  file_factory->GetAllDetachCallbacks(&callbacks);
-  ASSERT_TRUE(callbacks.empty());
   file_factory->GetAllRenameCallbacks(&callbacks);
   ASSERT_EQ(1u, callbacks.size());
 
   // Cancel it.
   std::vector<DownloadItem*> items;
   download_manager->GetAllDownloads(&items);
   ASSERT_EQ(1u, items.size());
   items[0]->Cancel(true);
   RunAllPendingInMessageLoop();
 
   // Check state.
   EXPECT_EQ(DownloadItem::CANCELLED, items[0]->GetState());
 
   // Run final rename callback.
   callbacks[0].Run();
   callbacks.clear();
 
   // Check state.
   EXPECT_EQ(DownloadItem::CANCELLED, items[0]->GetState());
 }
 
 // Try to cancel just after we release the download file, by delaying
-// release.
+// in ShouldOpenDownload.
 IN_PROC_BROWSER_TEST_F(DownloadContentTest, CancelAtRelease) {
+  DownloadManagerImpl* download_manager(DownloadManagerForShell(shell()));
+
+  // Mark delegate for delayed open.
+  GetDownloadManagerDelegate(download_manager)->SetDelayedOpen(true);
+
   // Setup new factory.
   DownloadFileWithDelayFactory* file_factory =
       new DownloadFileWithDelayFactory();
-  DownloadManagerImpl* download_manager(DownloadManagerForShell(shell()));
   download_manager->SetDownloadFileFactoryForTesting(
       scoped_ptr<DownloadFileFactory>(file_factory).Pass());
 
   // Create a download
   FilePath file(FILE_PATH_LITERAL("download-test.lib"));
   NavigateToURL(shell(), URLRequestMockHTTPJob::GetMockUrl(file));
 
   // Wait until the first (intermediate file) rename and execute the callback.
   file_factory->WaitForSomeCallback();
   std::vector<base::Closure> callbacks;
-  file_factory->GetAllDetachCallbacks(&callbacks);
-  ASSERT_TRUE(callbacks.empty());
   file_factory->GetAllRenameCallbacks(&callbacks);
   ASSERT_EQ(1u, callbacks.size());
   callbacks[0].Run();
   callbacks.clear();
 
   // Wait until the second (final) rename callback is posted.
   file_factory->WaitForSomeCallback();
-  file_factory->GetAllDetachCallbacks(&callbacks);
-  ASSERT_TRUE(callbacks.empty());
   file_factory->GetAllRenameCallbacks(&callbacks);
   ASSERT_EQ(1u, callbacks.size());
 
   // Call it.
   callbacks[0].Run();
   callbacks.clear();
 
-  // Confirm download still IN_PROGRESS.
+  // Confirm download still IN_PROGRESS (internal state COMPLETING).
   std::vector<DownloadItem*> items;
   download_manager->GetAllDownloads(&items);
   EXPECT_EQ(DownloadItem::IN_PROGRESS, items[0]->GetState());
 
   // Cancel the download; confirm cancel fails.
   ASSERT_EQ(1u, items.size());
   items[0]->Cancel(true);
   EXPECT_EQ(DownloadItem::IN_PROGRESS, items[0]->GetState());
 
-  // Confirm detach callback and run it.
-  file_factory->WaitForSomeCallback();
-  file_factory->GetAllRenameCallbacks(&callbacks);
-  ASSERT_TRUE(callbacks.empty());
-  file_factory->GetAllDetachCallbacks(&callbacks);
-  ASSERT_EQ(1u, callbacks.size());
-  callbacks[0].Run();
-  callbacks.clear();
+  // Need to complete open test.
+  std::vector<int32> delayed_ids;
+  GetDownloadManagerDelegate(download_manager)->GetDelayedIds(&delayed_ids);
+  ASSERT_EQ(1u, delayed_ids.size());
+  ASSERT_EQ(items[0]->GetId(), delayed_ids[0]);
+  items[0]->DelayedDownloadOpened(false);
 
   // *Now* the download should be complete.
   EXPECT_EQ(DownloadItem::COMPLETE, items[0]->GetState());
 }
 
 // Try to shutdown with a download in progress to make sure shutdown path
 // works properly.
 IN_PROC_BROWSER_TEST_F(DownloadContentTest, ShutdownInProgress) {
   // Create a download that won't complete.
   scoped_ptr<DownloadTestObserver> observer(CreateInProgressWaiter(shell(), 1));
@@ skipping 31 matching lines @@
     EXPECT_CALL(item_observer, OnDownloadDestroyed(items[0]))
         .WillOnce(Return());
   }
   DownloadManagerForShell(shell())->Shutdown();
   items.clear();
 }
 
 // Try to shutdown just after we release the download file, by delaying
 // release.
 IN_PROC_BROWSER_TEST_F(DownloadContentTest, ShutdownAtRelease) {
+  DownloadManagerImpl* download_manager(DownloadManagerForShell(shell()));
+
+  // Mark delegate for delayed open.
+  GetDownloadManagerDelegate(download_manager)->SetDelayedOpen(true);
+
   // Setup new factory.
   DownloadFileWithDelayFactory* file_factory =
       new DownloadFileWithDelayFactory();
-  DownloadManagerForShell(shell())->SetDownloadFileFactoryForTesting(
+  download_manager->SetDownloadFileFactoryForTesting(
       scoped_ptr<DownloadFileFactory>(file_factory).Pass());
 
   // Create a download
   FilePath file(FILE_PATH_LITERAL("download-test.lib"));
   NavigateToURL(shell(), URLRequestMockHTTPJob::GetMockUrl(file));
 
   // Wait until the first (intermediate file) rename and execute the callback.
   file_factory->WaitForSomeCallback();
   std::vector<base::Closure> callbacks;
-  file_factory->GetAllDetachCallbacks(&callbacks);
-  ASSERT_TRUE(callbacks.empty());
   file_factory->GetAllRenameCallbacks(&callbacks);
   ASSERT_EQ(1u, callbacks.size());
   callbacks[0].Run();
   callbacks.clear();
 
   // Wait until the second (final) rename callback is posted.
   file_factory->WaitForSomeCallback();
-  file_factory->GetAllDetachCallbacks(&callbacks);
-  ASSERT_TRUE(callbacks.empty());
   file_factory->GetAllRenameCallbacks(&callbacks);
   ASSERT_EQ(1u, callbacks.size());
 
   // Call it.
   callbacks[0].Run();
   callbacks.clear();
 
   // Confirm download isn't complete yet.
   std::vector<DownloadItem*> items;
   DownloadManagerForShell(shell())->GetAllDownloads(&items);
   EXPECT_EQ(DownloadItem::IN_PROGRESS, items[0]->GetState());
 
   // Cancel the download; confirm cancel fails anyway.
   ASSERT_EQ(1u, items.size());
   items[0]->Cancel(true);
   EXPECT_EQ(DownloadItem::IN_PROGRESS, items[0]->GetState());
   RunAllPendingInMessageLoop();
   EXPECT_EQ(DownloadItem::IN_PROGRESS, items[0]->GetState());
 
-  // Get the detach callback that should have been produced by the above.
-  file_factory->WaitForSomeCallback();
-  file_factory->GetAllRenameCallbacks(&callbacks);
-  ASSERT_TRUE(callbacks.empty());
-  file_factory->GetAllDetachCallbacks(&callbacks);
-  ASSERT_EQ(1u, callbacks.size());
+  MockDownloadItemObserver observer;
+  items[0]->AddObserver(&observer);
+  EXPECT_CALL(observer, OnDownloadDestroyed(items[0]));
 
   // Shutdown the download manager.  Mostly this is confirming a lack of
   // crashes.
   DownloadManagerForShell(shell())->Shutdown();
-
-  // Run the detach callback; shouldn't cause any problems.
-  callbacks[0].Run();
-  callbacks.clear();
 }
 
 }  // namespace content