Refactor downloads into a ProfileKeyedService.

chrome/browser/download/download_browsertest.cc

 // Copyright (c) 2011 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 "base/bind.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/path_service.h"
 #include "base/scoped_temp_dir.h"
 #include "base/stl_util.h"
 #include "base/test/test_file_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/download/chrome_download_manager_delegate.h"
 #include "chrome/browser/download/download_crx_util.h"
 #include "chrome/browser/download/download_history.h"
 #include "chrome/browser/download/download_prefs.h"
+#include "chrome/browser/download/download_service.h"
+#include "chrome/browser/download/download_service_factory.h"
 #include "chrome/browser/download/download_shelf.h"
 #include "chrome/browser/download/download_util.h"
 #include "chrome/browser/extensions/extension_install_ui.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/history/history.h"
 #include "chrome/browser/net/url_request_mock_util.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
@@ skipping 461 matching lines @@
   int rdh_pending_requests_;
   int dfm_pending_downloads_;
 
   DISALLOW_COPY_AND_ASSIGN(CancelTestDataCollector);
 };
 
 class PickSuggestedFileDelegate : public ChromeDownloadManagerDelegate {
  public:
   explicit PickSuggestedFileDelegate(Profile* profile)
       : ChromeDownloadManagerDelegate(profile) {
-    SetDownloadManager(profile->GetDownloadManager());
+    SetDownloadManager(
+        DownloadServiceFactory::GetForProfile(profile)->GetDownloadManager());
   }
 
   virtual void ChooseDownloadPath(TabContents* tab_contents,
                                   const FilePath& suggested_path,
                                   void* data) OVERRIDE {
     if (download_manager_)
       download_manager_->FileSelected(suggested_path, data);
   }
 };
 
@@ skipping 75 matching lines @@
 
   // Proceed without confirmation prompt.
   virtual void ConfirmInstall(Delegate* delegate, const Extension* extension) {
     delegate->InstallUIProceed();
   }
 
   virtual void OnInstallSuccess(const Extension* extension, SkBitmap* icon) {}
   virtual void OnInstallFailure(const std::string& error) {}
 };
 
+static DownloadManager* DownloadManagerForBrowser(Browser* browser) {
+  return DownloadServiceFactory::GetForProfile(browser->profile())
+      ->GetDownloadManager();

[Miranda Callahan, 2011/10/06 20:07:32]

nit: I think this is nonstandard wrapping (at least in chrome code); perhaps put
the whole argument on the next line?

return DownloadServiceFactory::GetForProfile(
    browser->profile()->GetDownloadManager());

[Randy Smith (Not in Mondays), 2011/10/08 23:46:54]

The problem is that that's not the right parenthesis nesting, and it looked as
wrong to me with the correct parenthesis nesting as what I actually wrote. 
Here's the alternative:

  return DownloadServiceFactory::GetForProfile(
      browser->profile())->GetDownloadManager();

If you think that's better, I'm happy to go with it--just let me know.

+}
+
 }  // namespace
 
 // While an object of this class exists, it will mock out download
 // opening for all downloads created on the specified download manager.
 class MockDownloadOpeningObserver : public DownloadManager::Observer {
  public:
   explicit MockDownloadOpeningObserver(DownloadManager* manager)
       : download_manager_(manager) {
     download_manager_->AddObserver(this);
   }
@@ skipping 52 matching lines @@
     EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
 
     // Set up the temporary download folder.
     bool created_downloads_dir = CreateAndSetDownloadsDirectory(browser());
     EXPECT_TRUE(created_downloads_dir);
     if (!created_downloads_dir)
       return false;
     browser()->profile()->GetPrefs()->SetBoolean(prefs::kPromptForDownload,
                                                  prompt_for_download);
 
-    DownloadManager* manager = browser()->profile()->GetDownloadManager();
+    DownloadManager* manager = DownloadManagerForBrowser(browser());
     DownloadPrefs::FromDownloadManager(manager)->ResetAutoOpen();
     manager->RemoveAllDownloads();
 
     return true;
   }
 
  protected:
 
   enum SizeTestType {
     SIZE_TEST_TYPE_KNOWN,
@@ skipping 23 matching lines @@
 
     browser->profile()->GetPrefs()->SetFilePath(
         prefs::kDownloadDefaultDirectory,
         downloads_directory_.path());
 
     return true;
   }
 
   DownloadPrefs* GetDownloadPrefs(Browser* browser) {
     return DownloadPrefs::FromDownloadManager(
-        browser->profile()->GetDownloadManager());
+        DownloadManagerForBrowser(browser));
   }
 
   FilePath GetDownloadDirectory(Browser* browser) {
     return GetDownloadPrefs(browser)->download_path();
   }
 
   // Create a DownloadsObserver that will wait for the
   // specified number of downloads to finish.
   DownloadsObserver* CreateWaiter(Browser* browser, int num_downloads) {
-    DownloadManager* download_manager =
-        browser->profile()->GetDownloadManager();
+    DownloadManager* download_manager = DownloadManagerForBrowser(browser);
     return new DownloadsObserver(
         download_manager, num_downloads,
         DownloadItem::COMPLETE,  // Really done
         true,                    // Bail on select file
         ON_DANGEROUS_DOWNLOAD_FAIL);
   }
 
   // Create a DownloadsObserver that will wait for the
   // specified number of downloads to start.
   DownloadsObserver* CreateInProgressWaiter(Browser* browser,
                                             int num_downloads) {
-    DownloadManager* download_manager =
-        browser->profile()->GetDownloadManager();
+    DownloadManager* download_manager = DownloadManagerForBrowser(browser);
     return new DownloadsObserver(
         download_manager, num_downloads,
         DownloadItem::IN_PROGRESS,      // Has started
         true,                           // Bail on select file
         ON_DANGEROUS_DOWNLOAD_FAIL);
   }
 
   // Create a DownloadsObserver that will wait for the
   // specified number of downloads to finish, or for
   // a dangerous download warning to be shown.
   DownloadsObserver* DangerousInstallWaiter(
       Browser* browser,
       int num_downloads,
       DownloadItem::DownloadState final_state,
       DangerousDownloadAction dangerous_download_action) {
-    DownloadManager* download_manager =
-        browser->profile()->GetDownloadManager();
+    DownloadManager* download_manager = DownloadManagerForBrowser(browser);
     return new DownloadsObserver(
         download_manager, num_downloads,
         final_state,
         true,                         // Bail on select file
         dangerous_download_action);
   }
 
   // Download |url|, then wait for the download to finish.
   // |disposition| indicates where the navigation occurs (current tab, new
   // foreground tab, etc).
@@ skipping 139 matching lines @@
 
     // Delete the file we just downloaded.
     EXPECT_TRUE(file_util::DieFileDie(download_path, true));
     EXPECT_FALSE(file_util::PathExists(download_path));
 
     return true;
   }
 
   void GetDownloads(Browser* browser, std::vector<DownloadItem*>* downloads) {
     DCHECK(downloads);
-    DownloadManager* manager = browser->profile()->GetDownloadManager();
+    DownloadManager* manager = DownloadManagerForBrowser(browser);
     manager->SearchDownloads(string16(), downloads);
   }
 
   // Check that the download UI (shelf on non-chromeos or panel on chromeos)
   // is visible or not as expected. Additionally, check that the filename
   // is present in the UI (currently only on chromeos).
   void CheckDownloadUI(Browser* browser, bool expected_non_cros,
       bool expected_cros, const FilePath& filename) {
 #if defined(OS_CHROMEOS)
 #if defined(TOUCH_UI)
@@ skipping 41 matching lines @@
 #endif
     EXPECT_EQ(expected, BrowserList::size());
   }
 
   // Arrange for select file calls on the given browser from the
   // download manager to always choose the suggested file.
   void NullSelectFile(Browser* browser) {
     PickSuggestedFileDelegate* new_delegate =
         new PickSuggestedFileDelegate(browser->profile());
 
-    DownloadManager* manager = browser->profile()->GetDownloadManager();
-
-    new_delegate->SetDownloadManager(manager);
-    manager->set_delegate(new_delegate);
-
-    // Gives ownership to Profile.
-    browser->profile()->SetDownloadManagerDelegate(new_delegate);
+    // Gives ownership to DownloadService.
+    DownloadServiceFactory::GetForProfile(
+        browser->profile())->SetDownloadManagerDelegate(new_delegate);
   }
 
  private:
   // Location of the test data.
   FilePath test_dir_;
 
   // Location of the downloads directory for these tests
   ScopedTempDir downloads_directory_;
 };
 
@@ skipping 46 matching lines @@
   ASSERT_TRUE(InitialSetup(true));
   FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
 
   NullSelectFile(browser());
 
   // Download the file and wait.  We expect the Select File dialog to appear
   // due to the MIME type, but we still wait until the download completes.
   scoped_ptr<DownloadsObserver> observer(
       new DownloadsObserver(
-          browser()->profile()->GetDownloadManager(),
+          DownloadManagerForBrowser(browser()),
           1,
           DownloadItem::COMPLETE,  // Really done
           false,                   // Continue on select file.
           ON_DANGEROUS_DOWNLOAD_FAIL));
   ui_test_utils::NavigateToURLWithDisposition(
       browser(), url, CURRENT_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
   observer->WaitForFinished();
   EXPECT_TRUE(observer->select_file_dialog_seen());
 
@@ skipping 424 matching lines @@
 
   // Create a download, wait until it's started, and confirm
   // we're in the expected state.
   scoped_ptr<DownloadsObserver> observer(
       CreateInProgressWaiter(browser(), 1));
   ui_test_utils::NavigateToURL(
       browser(), GURL(URLRequestSlowDownloadJob::kUnknownSizeUrl));
   observer->WaitForFinished();
 
   std::vector<DownloadItem*> downloads;
-  browser()->profile()->GetDownloadManager()->SearchDownloads(
+  DownloadManagerForBrowser(browser())->SearchDownloads(
       string16(), &downloads);
   ASSERT_EQ(1u, downloads.size());
   ASSERT_EQ(DownloadItem::IN_PROGRESS, downloads[0]->state());
   CheckDownloadUI(browser(), true, true, FilePath());
 
   // Cancel the download and wait for download system quiesce.
   downloads[0]->Delete(DownloadItem::DELETE_DUE_TO_USER_DISCARD);
   scoped_refptr<DownloadsFlushObserver> flush_observer(
-      new DownloadsFlushObserver(browser()->profile()->GetDownloadManager()));
+      new DownloadsFlushObserver(DownloadManagerForBrowser(browser())));
   flush_observer->WaitForFlush();
 
   // Get the important info from other threads and check it.
   scoped_refptr<CancelTestDataCollector> info(new CancelTestDataCollector());
   info->WaitForDataCollected();
   EXPECT_EQ(0, info->rdh_pending_requests());
   EXPECT_EQ(0, info->dfm_pending_downloads());
 
   // Using "DownloadItem::Remove" follows the discard dangerous download path,
   // which completely removes the browser from the shelf and closes the shelf
@@ skipping 20 matching lines @@
   int64 db_handle = downloads[0]->db_handle();
 
   // Check state.
   EXPECT_EQ(1, browser()->tab_count());
   CheckDownload(browser(), file, file);
   CheckDownloadUI(browser(), true, true, file);
 
   // Check history results.
   DownloadsHistoryDataCollector history_collector(
       db_handle,
-      browser()->profile()->GetDownloadManager());
+      DownloadManagerForBrowser(browser()));
   DownloadPersistentStoreInfo info;
   EXPECT_TRUE(history_collector.GetDownloadsHistoryEntry(&info)) << db_handle;
   EXPECT_EQ(file, info.path.BaseName());
   EXPECT_EQ(url, info.url);
   // Ignore start_time.
   EXPECT_EQ(origin_size, info.received_bytes);
   EXPECT_EQ(origin_size, info.total_bytes);
   EXPECT_EQ(DownloadItem::COMPLETE, info.state);
 }
 
@@ skipping 73 matching lines @@
 IN_PROC_BROWSER_TEST_F(DownloadTest, AutoOpen) {
   ASSERT_TRUE(InitialSetup(false));
   FilePath file(FILE_PATH_LITERAL("download-autoopen.txt"));
   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
 
   ASSERT_TRUE(
       GetDownloadPrefs(browser())->EnableAutoOpenBasedOnExtension(file));
 
   // Mock out external opening on all downloads until end of test.
   MockDownloadOpeningObserver observer(
-      browser()->profile()->GetDownloadManager());
+      DownloadManagerForBrowser(browser()));
 
   DownloadAndWait(browser(), url, EXPECT_NO_SELECT_DIALOG);
 
   // Find the download and confirm it was opened.
   std::vector<DownloadItem*> downloads;
-  browser()->profile()->GetDownloadManager()->SearchDownloads(
+  DownloadManagerForBrowser(browser())->SearchDownloads(
       string16(), &downloads);
   ASSERT_EQ(1u, downloads.size());
   EXPECT_EQ(DownloadItem::COMPLETE, downloads[0]->state());
   EXPECT_TRUE(downloads[0]->opened());
 
   // As long as we're here, confirmed everything else is good.
   EXPECT_EQ(1, browser()->tab_count());
   CheckDownload(browser(), file, file);
   // Download shelf should close. Download panel stays open on ChromeOS.
   CheckDownloadUI(browser(), false, true, FilePath());
@@ skipping 132 matching lines @@
   EXPECT_EQ(1u, observer->NumDangerousDownloadsSeen());
 
   // Download shelf should close. Download panel stays open on ChromeOS.
   CheckDownloadUI(browser(), false, true, FilePath());
 
   // Check that the extension was installed.
   ExtensionService* extension_service =
       browser()->profile()->GetExtensionService();
   ASSERT_TRUE(extension_service->GetExtensionById(kLargeThemeCrxId, false));
 }