Fix warning prompting on closing a window that will cancel downloads.

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/bind_helpers.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_test_observer.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"
 #include "chrome/browser/ui/browser_window.h"
@@ skipping 677 matching lines @@
 
   DownloadPrefs* GetDownloadPrefs(Browser* browser) {
     return DownloadPrefs::FromDownloadManager(
         DownloadManagerForBrowser(browser));
   }
 
   FilePath GetDownloadDirectory(Browser* browser) {
     return GetDownloadPrefs(browser)->download_path();
   }
 
-  // Create a DownloadsObserver that will wait for the
+  // Create a DownloadTestObserver that will wait for the
   // specified number of downloads to finish.
-  DownloadsObserver* CreateWaiter(Browser* browser, int num_downloads) {
+  DownloadTestObserver* CreateWaiter(Browser* browser, int num_downloads) {
     DownloadManager* download_manager = DownloadManagerForBrowser(browser);
-    return new DownloadsObserver(
+    return new DownloadTestObserver(
         download_manager, num_downloads,
         DownloadItem::COMPLETE,  // Really done
-        true,                    // Bail on select file
-        ON_DANGEROUS_DOWNLOAD_FAIL);
+        true,                   // Bail on select file
+        DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_FAIL);
   }
 
-  // Create a DownloadsObserver that will wait for the
+  // Create a DownloadTestObserver that will wait for the
   // specified number of downloads to start.
-  DownloadsObserver* CreateInProgressWaiter(Browser* browser,
+  DownloadTestObserver* CreateInProgressWaiter(Browser* browser,
                                             int num_downloads) {
     DownloadManager* download_manager = DownloadManagerForBrowser(browser);
-    return new DownloadsObserver(
+    return new DownloadTestObserver(
         download_manager, num_downloads,
         DownloadItem::IN_PROGRESS,      // Has started
         true,                           // Bail on select file
-        ON_DANGEROUS_DOWNLOAD_FAIL);
+        DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_FAIL);
   }
 
-  // Create a DownloadsObserver that will wait for the
+  // Create a DownloadTestObserver that will wait for the
   // specified number of downloads to finish, or for
   // a dangerous download warning to be shown.
-  DownloadsObserver* DangerousInstallWaiter(
+  DownloadTestObserver* DangerousInstallWaiter(
       Browser* browser,
       int num_downloads,
       DownloadItem::DownloadState final_state,
-      DangerousDownloadAction dangerous_download_action) {
+      DownloadTestObserver::DangerousDownloadAction dangerous_download_action) {
     DownloadManager* download_manager = DownloadManagerForBrowser(browser);
-    return new DownloadsObserver(
+    return new DownloadTestObserver(
         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).
   // |expectation| indicates whether or not a Select File dialog should be
   // open when the download is finished, or if we don't care.
   // If the dialog appears, the routine exits.  The only effect |expectation|
   // has is whether or not the test succeeds.
   // |browser_test_flags| indicate what to wait for, and is an OR of 0 or more
   // values in the ui_test_utils::BrowserTestWaitFlags enum.
   void DownloadAndWaitWithDisposition(Browser* browser,
                                       const GURL& url,
                                       WindowOpenDisposition disposition,
                                       SelectExpectation expectation,
                                       int browser_test_flags) {
     // Setup notification, navigate, and block.
-    scoped_ptr<DownloadsObserver> observer(CreateWaiter(browser, 1));
+    scoped_ptr<DownloadTestObserver> observer(CreateWaiter(browser, 1));
     // This call will block until the condition specified by
     // |browser_test_flags|, but will not wait for the download to finish.
     ui_test_utils::NavigateToURLWithDisposition(browser,
                                                 url,
                                                 disposition,
                                                 browser_test_flags);
     // Waits for the download to complete.
     observer->WaitForFinished();
 
     // If specified, check the state of the select file dialog.
@@ skipping 70 matching lines @@
     // |expected_title_finished| need to be checked.
     FilePath filename;
     net::FileURLToFilePath(url, &filename);
     string16 expected_title_in_progress(
         ASCIIToUTF16(partial_indication) + filename.LossyDisplayName());
     string16 expected_title_finished(
         ASCIIToUTF16(total_indication) + filename.LossyDisplayName());
 
     // Download a partial web page in a background tab and wait.
     // The mock system will not complete until it gets a special URL.
-    scoped_ptr<DownloadsObserver> observer(CreateWaiter(browser, 1));
+    scoped_ptr<DownloadTestObserver> observer(CreateWaiter(browser, 1));
     ui_test_utils::NavigateToURL(browser, url);
 
     // TODO(ahendrickson): check download status text before downloading.
     // Need to:
     //  - Add a member function to the |DownloadShelf| interface class, that
     //    indicates how many members it has.
     //  - Add a member function to |DownloadShelf| to get the status text
     //    of a given member (for example, via the name in |DownloadItemView|'s
     //    GetAccessibleState() member function), by index.
     //  - Iterate over browser->window()->GetDownloadShelf()'s members
@@ skipping 154 matching lines @@
 // downloads preferences settings.
 IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadMimeTypeSelect) {
   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(
+  scoped_ptr<DownloadTestObserver> observer(
+      new DownloadTestObserver(
           DownloadManagerForBrowser(browser()),
           1,
           DownloadItem::COMPLETE,  // Really done
           false,                   // Continue on select file.
-          ON_DANGEROUS_DOWNLOAD_FAIL));
+          DownloadTestObserver::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());
 
   // Check state.
   EXPECT_EQ(1, browser()->tab_count());
   CheckDownload(browser(), file, file);
   CheckDownloadUI(browser(), true, true, file);
@@ skipping 397 matching lines @@
   CheckDownloadUI(browser(), false, true, file);
 
   CheckDownload(browser(), file, file);
 }
 
 IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadCancelled) {
   ASSERT_TRUE(InitialSetup(false));
   EXPECT_EQ(1, browser()->tab_count());
 
   // TODO(rdsmith): Fragile code warning!  The code below relies on the
-  // DownloadsObserver only finishing when the new download has reached
+  // DownloadTestObserver only finishing when the new download has reached
   // the state of being entered into the history and being user-visible
   // (that's what's required for the Remove to be valid and for the
   // download shelf to be visible).  By the pure semantics of
-  // DownloadsObserver, that's not guaranteed; DownloadItems are created
+  // DownloadTestObserver, that's not guaranteed; DownloadItems are created
   // in the IN_PROGRESS state and made known to the DownloadManager
   // immediately, so any ModelChanged event on the DownloadManager after
   // navigation would allow the observer to return.  However, the only
   // ModelChanged() event the code will currently fire is in
   // OnCreateDownloadEntryComplete, at which point the download item will
   // be in the state we need.
   // The right way to fix this is to create finer grained states on the
   // DownloadItem, and wait for the state that indicates the item has been
   // entered in the history and made visible in the UI.
 
   // Create a download, wait until it's started, and confirm
   // we're in the expected state.
-  scoped_ptr<DownloadsObserver> observer(
+  scoped_ptr<DownloadTestObserver> observer(
       CreateInProgressWaiter(browser(), 1));
   ui_test_utils::NavigateToURL(
       browser(), GURL(URLRequestSlowDownloadJob::kUnknownSizeUrl));
   observer->WaitForFinished();
 
   std::vector<DownloadItem*> downloads;
   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(DownloadManagerForBrowser(browser())));
+  scoped_refptr<DownloadTestFlushObserver> flush_observer(
+      new DownloadTestFlushObserver(
+          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 93 matching lines @@
 }
 
 // Test to make sure the 'download' attribute in anchor tag is respected.
 IN_PROC_BROWSER_TEST_F(DownloadTest, AnchorDownloadTag) {
   ASSERT_TRUE(InitialSetup(false));
   FilePath file(FILE_PATH_LITERAL("download-anchor-attrib.html"));
   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
 
   // Create a download, wait until it's complete, and confirm
   // we're in the expected state.
-  scoped_ptr<DownloadsObserver> observer(CreateWaiter(browser(), 1));
+  scoped_ptr<DownloadTestObserver> observer(CreateWaiter(browser(), 1));
   ui_test_utils::NavigateToURL(browser(), url);
   observer->WaitForFinished();
 
   // Confirm the downloaded data exists.
   FilePath downloaded_file = GetDownloadDirectory(browser());
   downloaded_file = downloaded_file.Append(FILE_PATH_LITERAL("a_red_dot.png"));
   EXPECT_TRUE(file_util::PathExists(downloaded_file));
 }
 
 // Test to make sure auto-open works.
@@ skipping 25 matching lines @@
   // Download shelf should close. Download panel stays open on ChromeOS.
   CheckDownloadUI(browser(), false, true, FilePath());
 }
 
 // Download an extension.  Expect a dangerous download warning.
 // Deny the download.
 IN_PROC_BROWSER_TEST_F(DownloadTest, CrxDenyInstall) {
   ASSERT_TRUE(InitialSetup(false));
   GURL extension_url(URLRequestMockHTTPJob::GetMockUrl(kGoodCrxPath));
 
-  scoped_ptr<DownloadsObserver> observer(
-      DangerousInstallWaiter(browser(),
-                             1,
-                             DownloadItem::CANCELLED,
-                             ON_DANGEROUS_DOWNLOAD_DENY));
+  scoped_ptr<DownloadTestObserver> observer(
+      DangerousInstallWaiter(
+          browser(), 1, DownloadItem::CANCELLED,
+          DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_DENY));
   ui_test_utils::NavigateToURL(browser(), extension_url);
 
   observer->WaitForFinished();
   EXPECT_EQ(1u, observer->NumDangerousDownloadsSeen());
 
   // Download shelf should close. Download panel stays open on ChromeOS.
   CheckDownloadUI(browser(), false, true, FilePath());
 
   // Check that the CRX is not installed.
   ExtensionService* extension_service =
       browser()->profile()->GetExtensionService();
   ASSERT_FALSE(extension_service->GetExtensionById(kGoodCrxId, false));
 }
 
 // Download an extension.  Expect a dangerous download warning.
 // Allow the download, deny the install.
 IN_PROC_BROWSER_TEST_F(DownloadTest, CrxInstallDenysPermissions) {
   ASSERT_TRUE(InitialSetup(false));
   GURL extension_url(URLRequestMockHTTPJob::GetMockUrl(kGoodCrxPath));
 
   // Install a mock install UI that simulates a user denying permission to
   // finish the install.
   download_crx_util::SetMockInstallUIForTesting(
       new MockAbortExtensionInstallUI());
 
-  scoped_ptr<DownloadsObserver> observer(
-      DangerousInstallWaiter(browser(),
-                             1,
-                             DownloadItem::COMPLETE,
-                             ON_DANGEROUS_DOWNLOAD_ACCEPT));
+  scoped_ptr<DownloadTestObserver> observer(
+      DangerousInstallWaiter(
+          browser(), 1, DownloadItem::COMPLETE,
+          DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_ACCEPT));
   ui_test_utils::NavigateToURL(browser(), extension_url);
 
   observer->WaitForFinished();
   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 not installed.
   ExtensionService* extension_service =
       browser()->profile()->GetExtensionService();
   ASSERT_FALSE(extension_service->GetExtensionById(kGoodCrxId, false));
 }
 
 // Download an extension.  Expect a dangerous download warning.
 // Allow the download, and the install.
 IN_PROC_BROWSER_TEST_F(DownloadTest, CrxInstallAcceptPermissions) {
   ASSERT_TRUE(InitialSetup(false));
   GURL extension_url(URLRequestMockHTTPJob::GetMockUrl(kGoodCrxPath));
 
   // Install a mock install UI that simulates a user allowing permission to
   // finish the install.
   download_crx_util::SetMockInstallUIForTesting(
       new MockAutoConfirmExtensionInstallUI(browser()->profile()));
 
-  scoped_ptr<DownloadsObserver> observer(
-      DangerousInstallWaiter(browser(),
-                             1,
-                             DownloadItem::COMPLETE,
-                             ON_DANGEROUS_DOWNLOAD_ACCEPT));
+  scoped_ptr<DownloadTestObserver> observer(
+      DangerousInstallWaiter(
+          browser(), 1, DownloadItem::COMPLETE,
+          DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_ACCEPT));
   ui_test_utils::NavigateToURL(browser(), extension_url);
 
   observer->WaitForFinished();
   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(kGoodCrxId, false));
 }
 
 // Test installing a CRX that fails integrity checks.
 IN_PROC_BROWSER_TEST_F(DownloadTest, CrxInvalid) {
   ASSERT_TRUE(InitialSetup(false));
   FilePath file(FILE_PATH_LITERAL("extensions/bad_signature.crx"));
   GURL extension_url(URLRequestMockHTTPJob::GetMockUrl(file));
 
   // Install a mock install UI that simulates a user allowing permission to
   // finish the install, and dismisses any error message.  We check that the
   // install failed below.
   download_crx_util::SetMockInstallUIForTesting(
       new MockAutoConfirmExtensionInstallUI(browser()->profile()));
 
-  scoped_ptr<DownloadsObserver> observer(
-      DangerousInstallWaiter(browser(),
-                             1,
-                             DownloadItem::COMPLETE,
-                             ON_DANGEROUS_DOWNLOAD_ACCEPT));
+  scoped_ptr<DownloadTestObserver> observer(
+      DangerousInstallWaiter(
+          browser(), 1, DownloadItem::COMPLETE,
+          DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_ACCEPT));
   ui_test_utils::NavigateToURL(browser(), extension_url);
 
   observer->WaitForFinished();
 
   // Check that the extension was not installed.
   ExtensionService* extension_service =
       browser()->profile()->GetExtensionService();
   ASSERT_FALSE(extension_service->GetExtensionById(kGoodCrxId, false));
 }
 
 // Install a large (100kb) theme.
 IN_PROC_BROWSER_TEST_F(DownloadTest, CrxLargeTheme) {
   ASSERT_TRUE(InitialSetup(false));
   GURL extension_url(URLRequestMockHTTPJob::GetMockUrl(kLargeThemePath));
 
   // Install a mock install UI that simulates a user allowing permission to
   // finish the install.
   download_crx_util::SetMockInstallUIForTesting(
       new MockAutoConfirmExtensionInstallUI(browser()->profile()));
 
-  scoped_ptr<DownloadsObserver> observer(
-      DangerousInstallWaiter(browser(),
-                             1,
-                             DownloadItem::COMPLETE,
-                             ON_DANGEROUS_DOWNLOAD_ACCEPT));
+  scoped_ptr<DownloadTestObserver> observer(
+      DangerousInstallWaiter(
+          browser(), 1, DownloadItem::COMPLETE,
+          DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_ACCEPT));
   ui_test_utils::NavigateToURL(browser(), extension_url);
 
   observer->WaitForFinished();
   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));
 }