Remove Active Downloads UI.

chrome/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.
 
 #include <sstream>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
@@ skipping 21 matching lines @@
 #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/tab_contents/render_view_context_menu.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_window.h"
-#include "chrome/browser/ui/webui/chromeos/active_downloads_ui.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/download_item.h"
 #include "content/public/browser/download_manager.h"
 #include "content/public/browser/download_persistent_store_info.h"
@@ skipping 190 matching lines @@
     EXPECT_NOTHING,
     EXPECT_SELECT_DIALOG
   };
 
   // Choice of navigation or direct fetch.  Used by |DownloadFileCheckErrors()|.
   enum DownloadMethod {
     DOWNLOAD_NAVIGATE,
     DOWNLOAD_DIRECT
   };
 
+  // State of download shelf.
+  enum DownloadShelfVisibility {
+    SHELF_HIDDEN,
+    SHELF_VISIBLE
+  };
+
   // Information passed in to |DownloadFileCheckErrors()|.
   struct DownloadInfo {
     const char* url_name;  // URL for the download.
     DownloadMethod download_method;  // Navigation or Direct.
     // Download interrupt reason (NONE is OK).
     content::DownloadInterruptReason reason;
     bool show_download_item;  // True if the download item appears on the shelf.
     bool should_redirect_to_documents;  // True if we save it in "My Documents".
   };
 
@@ skipping 281 matching lines @@
     EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
     CheckDownloadStatesForBrowser(browser, 1, DownloadItem::COMPLETE);
 
     EXPECT_EQ(2, browser->tab_count());
 
     // TODO(ahendrickson): check download status text after downloading.
 
     FilePath basefilename(filename.BaseName());
     net::FileURLToFilePath(url, &filename);
     FilePath download_path = downloads_directory_.path().Append(basefilename);
-    CheckDownloadUI(browser, true, true, basefilename);
+    CheckDownloadShelfVisibility(browser, SHELF_VISIBLE);
 
     bool downloaded_path_exists = file_util::PathExists(download_path);
     EXPECT_TRUE(downloaded_path_exists);
     if (!downloaded_path_exists)
       return false;
 
     // Check the file contents.
     size_t file_size = URLRequestSlowDownloadJob::kFirstDownloadSize +
                        URLRequestSlowDownloadJob::kSecondDownloadSize;
     std::string expected_contents(file_size, '*');
     EXPECT_TRUE(VerifyFile(download_path, expected_contents, file_size));
 
     // 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 = 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) && !defined(USE_AURA)
-    Browser* popup = ActiveDownloadsUI::GetPopup();
-    EXPECT_EQ(expected_cros, popup != NULL);
-    if (!popup || filename.empty())
-      return;
-
-    ActiveDownloadsUI* downloads_ui = static_cast<ActiveDownloadsUI*>(
-        popup->GetSelectedWebContents()->GetWebUI()->GetController());
-
-    ASSERT_TRUE(downloads_ui);
-    const ActiveDownloadsUI::DownloadList& downloads =
-        downloads_ui->GetDownloads();
-    EXPECT_EQ(downloads.size(), 1U);
-
-    FilePath full_path(DestinationFile(browser, filename));
-    bool exists = false;
-    for (size_t i = 0; i < downloads.size(); ++i) {
-      if (downloads[i]->GetFullPath() == full_path) {
-        exists = true;
-        break;
-      }
-    }
-    EXPECT_TRUE(exists);
-#else
-    EXPECT_EQ(expected_non_cros, browser->window()->IsDownloadShelfVisible());
+  // Check that the download shelf is visible or not as expected.
+  void CheckDownloadShelfVisibility(Browser* browser,

[achuithb, 2012/04/16 14:27:05]

Not sure if this function and the enum is worth it. Might be more readable to
directly use EXPECT_EQ(true, browser->window()->IsDownloadShelfVisible());

[asanka, 2012/04/17 20:02:25]

Done.

+                                    DownloadShelfVisibility expected) {
+    EXPECT_EQ((expected == SHELF_VISIBLE),
+              browser->window()->IsDownloadShelfVisible());
     // TODO: Check for filename match in download shelf.
-#endif
   }
   static void ExpectWindowCountAfterDownload(size_t expected) {
-#if defined(OS_CHROMEOS) && !defined(USE_AURA)
-    // On ChromeOS, a download panel is created to display
-    // download information, and this counts as a window.
-    expected++;
-#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());
 
     // Gives ownership to DownloadService.
@@ skipping 279 matching lines @@
   ASSERT_TRUE(InitialSetup(false));
   FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
 
   // Download the file and wait.  We do not expect the Select File dialog.
   DownloadAndWait(browser(), url, EXPECT_NO_SELECT_DIALOG);
 
   // Check state.
   EXPECT_EQ(1, browser()->tab_count());
   CheckDownload(browser(), file, file);
-  CheckDownloadUI(browser(), true, true, file);
+  CheckDownloadShelfVisibility(browser(), SHELF_VISIBLE);
 }
 
 #if defined(OS_WIN)
 // Download a file and confirm that the zone identifier (on windows)
 // is set to internet.
 IN_PROC_BROWSER_TEST_F(DownloadTest, CheckInternetZone) {
   ASSERT_TRUE(InitialSetup(false));
   FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
 
   // Download the file and wait.  We do not expect the Select File dialog.
   DownloadAndWait(browser(), url, EXPECT_NO_SELECT_DIALOG);
 
   // Check state.  Special file state must be checked before CheckDownload,
   // as CheckDownload will delete the output file.
   EXPECT_EQ(1, browser()->tab_count());
   FilePath downloaded_file(DestinationFile(browser(), file));
   if (file_util::VolumeSupportsADS(downloaded_file))
     EXPECT_TRUE(file_util::HasInternetZoneIdentifier(downloaded_file));
   CheckDownload(browser(), file, file);
-  CheckDownloadUI(browser(), true, true, file);
+  CheckDownloadShelfVisibility(browser(), SHELF_VISIBLE);
 }
 #endif
 
 // Put up a Select File dialog when the file is downloaded, due to
 // 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));
 
@@ skipping 11 matching lines @@
       browser(), url, CURRENT_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
   observer->WaitForFinished();
   EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
   CheckDownloadStates(1, DownloadItem::COMPLETE);
   EXPECT_TRUE(observer->select_file_dialog_seen());
 
   // Check state.
   EXPECT_EQ(1, browser()->tab_count());
   CheckDownload(browser(), file, file);
-  CheckDownloadUI(browser(), true, true, file);
+  CheckDownloadShelfVisibility(browser(), SHELF_VISIBLE);
 }
 
 // Access a file with a viewable mime-type, verify that a download
 // did not initiate.
 IN_PROC_BROWSER_TEST_F(DownloadTest, NoDownload) {
   ASSERT_TRUE(InitialSetup(false));
   FilePath file(FILE_PATH_LITERAL("download-test2.html"));
   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
   FilePath file_path(DestinationFile(browser(), file));
 
   // Open a web page and wait.
   ui_test_utils::NavigateToURL(browser(), url);
 
   // Check that we did not download the web page.
   EXPECT_FALSE(file_util::PathExists(file_path));
 
   // Check state.
   EXPECT_EQ(1, browser()->tab_count());
-  CheckDownloadUI(browser(), false, false, FilePath());
+  CheckDownloadShelfVisibility(browser(), SHELF_HIDDEN);
 }
 
 // Verify that when the DownloadResourceThrottle cancels a download, the
 // download never makes it to the downloads system.
 IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadResourceThrottleCancels) {
   ASSERT_TRUE(InitialSetup(false));
 
   // Navigate to a page with the same domain as the file to download.  We can't
   // navigate directly to the file we don't want to download because cross-site
   // navigations reset the TabDownloadState.
@@ skipping 34 matching lines @@
       base::Bind(&MessageLoop::Quit,
                  base::Unretained(MessageLoopForUI::current())));
 
   // Check that we did not download the file.
   FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
   FilePath file_path(DestinationFile(browser(), file));
   EXPECT_FALSE(file_util::PathExists(file_path));
 
   // Check state.
   EXPECT_EQ(1, browser()->tab_count());
-  CheckDownloadUI(browser(), false, false, FilePath());
+  CheckDownloadShelfVisibility(browser(), SHELF_HIDDEN);
 
   // Verify that there's no pending download.
   EXPECT_TRUE(EnsureNoPendingDownloads());
 }
 
 // Download a 0-size file with a content-disposition header, verify that the
 // download tab opened and the file exists as the filename specified in the
 // header.  This also ensures we properly handle empty file downloads.
 // The download shelf should be visible in the current tab.
 IN_PROC_BROWSER_TEST_F(DownloadTest, ContentDisposition) {
   ASSERT_TRUE(InitialSetup(false));
   FilePath file(FILE_PATH_LITERAL("download-test3.gif"));
   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
   FilePath download_file(FILE_PATH_LITERAL("download-test3-attachment.gif"));
 
   // Download a file and wait.
   DownloadAndWait(browser(), url, EXPECT_NO_SELECT_DIALOG);
 
   CheckDownload(browser(), download_file, file);
 
   // Check state.
   EXPECT_EQ(1, browser()->tab_count());
-  CheckDownloadUI(browser(), true, true, download_file);
+  CheckDownloadShelfVisibility(browser(), SHELF_VISIBLE);
 }
 
-#if !defined(OS_CHROMEOS) || defined(USE_AURA)
-// Download shelf is not per-window on ChromeOS.
 // Test that the download shelf is per-window by starting a download in one
 // tab, opening a second tab, closing the shelf, going back to the first tab,
 // and checking that the shelf is closed.
 IN_PROC_BROWSER_TEST_F(DownloadTest, PerWindowShelf) {
   ASSERT_TRUE(InitialSetup(false));
   FilePath file(FILE_PATH_LITERAL("download-test3.gif"));
   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
   FilePath download_file(FILE_PATH_LITERAL("download-test3-attachment.gif"));
 
   // Download a file and wait.
   DownloadAndWait(browser(), url, EXPECT_NO_SELECT_DIALOG);
 
   CheckDownload(browser(), download_file, file);
 
   // Check state.
   EXPECT_EQ(1, browser()->tab_count());
-  CheckDownloadUI(browser(), true, true, download_file);
+  CheckDownloadShelfVisibility(browser(), SHELF_VISIBLE);
 
   // Open a second tab and wait.
   EXPECT_NE(static_cast<TabContentsWrapper*>(NULL),
             browser()->AddSelectedTabWithURL(
                 GURL(), content::PAGE_TRANSITION_TYPED));
   EXPECT_EQ(2, browser()->tab_count());
-  CheckDownloadUI(browser(), true, true, download_file);
+  CheckDownloadShelfVisibility(browser(), SHELF_VISIBLE);
 
   // Hide the download shelf.
   browser()->window()->GetDownloadShelf()->Close();
-  CheckDownloadUI(browser(), false, false, FilePath());
+  CheckDownloadShelfVisibility(browser(), SHELF_HIDDEN);
 
   // Go to the first tab.
   browser()->ActivateTabAt(0, true);
   EXPECT_EQ(2, browser()->tab_count());
 
   // The download shelf should not be visible.
-  CheckDownloadUI(browser(), false, false, FilePath());
+  CheckDownloadShelfVisibility(browser(), SHELF_HIDDEN);
 }
-#endif  // !OS_CHROMEOS
 
-#if !defined(OS_CHROMEOS) || defined(USE_AURA)
 // Check whether the downloads shelf is closed when the downloads tab is
 // invoked.
 IN_PROC_BROWSER_TEST_F(DownloadTest, CloseShelfOnDownloadsTab) {
   ASSERT_TRUE(InitialSetup(false));
   FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
 
   // Download the file and wait.  We do not expect the Select File dialog.
   DownloadAndWait(browser(), url, EXPECT_NO_SELECT_DIALOG);
 
   // Check state.
   EXPECT_EQ(1, browser()->tab_count());
-  CheckDownloadUI(browser(), true, true, file);
+  CheckDownloadShelfVisibility(browser(), SHELF_VISIBLE);
 
   // Open the downloads tab.
   browser()->ShowDownloadsTab();
   // The shelf should now be closed.
-  CheckDownloadUI(browser(), false, false, FilePath());
+  CheckDownloadShelfVisibility(browser(), SHELF_HIDDEN);
 }
-#endif
 
 // UnknownSize and KnownSize are tests which depend on
 // URLRequestSlowDownloadJob to serve content in a certain way. Data will be
 // sent in two chunks where the first chunk is 35K and the second chunk is 10K.
 // The test will first attempt to download a file; but the server will "pause"
 // in the middle until the server receives a second request for
 // "download-finish".  At that time, the download will finish.
 // These tests don't currently test much due to holes in |RunSizeTest()|.  See
 // comments in that routine for details.
 IN_PROC_BROWSER_TEST_F(DownloadTest, UnknownSize) {
@@ skipping 24 matching lines @@
   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
   // Since |incognito| is a separate browser, we have to set it up explicitly.
   incognito->profile()->GetPrefs()->SetBoolean(prefs::kPromptForDownload,
                                                false);
   DownloadAndWait(incognito, url, EXPECT_NO_SELECT_DIALOG);
 
   // We should still have 2 windows.
   ExpectWindowCountAfterDownload(2);
 
   // Verify that the download shelf is showing for the Incognito window.
-  CheckDownloadUI(incognito, true, true, file);
+  CheckDownloadShelfVisibility(incognito, SHELF_VISIBLE);
 
 #if !defined(OS_MACOSX)
   // On Mac OS X, the UI window close is delayed until the outermost
   // message loop runs.  So it isn't possible to get a BROWSER_CLOSED
   // notification inside of a test.
   ui_test_utils::WindowedNotificationObserver signal(
       chrome::NOTIFICATION_BROWSER_CLOSED,
       content::Source<Browser>(incognito));
 #endif
 
   // Close the Incognito window and don't crash.
   incognito->CloseWindow();
 
 #if !defined(OS_MACOSX)
   signal.Wait();
   ExpectWindowCountAfterDownload(1);
 #endif
 
   // Verify that the regular window does not have a download shelf.
   // On ChromeOS, the download panel is common to both profiles, so
   // it is still visible.
-  CheckDownloadUI(browser(), false, true, file);
+  CheckDownloadShelfVisibility(browser(), SHELF_HIDDEN);
 
   CheckDownload(browser(), file, file);
 }
 
 // Navigate to a new background page, but don't download.  Confirm that the
 // download shelf is not visible and that we have two tabs.
 IN_PROC_BROWSER_TEST_F(DownloadTest, DontCloseNewTab1) {
   ASSERT_TRUE(InitialSetup(false));
   // Because it's an HTML link, it should open a web page rather than
   // downloading.
   FilePath file1(FILE_PATH_LITERAL("download-test2.html"));
   GURL url(URLRequestMockHTTPJob::GetMockUrl(file1));
 
   // Open a web page and wait.
   ui_test_utils::NavigateToURLWithDisposition(
       browser(),
       url,
       NEW_BACKGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 
   // We should have two tabs now.
   EXPECT_EQ(2, browser()->tab_count());
-  CheckDownloadUI(browser(), false, false, FilePath());
+  CheckDownloadShelfVisibility(browser(), SHELF_HIDDEN);
 }
 
 // Download a file in a background tab. Verify that the tab is closed
 // automatically, and that the download shelf is visible in the current tab.
 IN_PROC_BROWSER_TEST_F(DownloadTest, CloseNewTab1) {
   ASSERT_TRUE(InitialSetup(false));
 
   // Download a file in a new background tab and wait.  The tab is automatically
   // closed when the download begins.
   FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
   DownloadAndWaitWithDisposition(
       browser(),
       url,
       NEW_BACKGROUND_TAB,
       EXPECT_NO_SELECT_DIALOG,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 
   // When the download finishes, we should still have one tab.
-  CheckDownloadUI(browser(), true, true, file);
+  CheckDownloadShelfVisibility(browser(), SHELF_VISIBLE);
   EXPECT_EQ(1, browser()->tab_count());
 
   CheckDownload(browser(), file, file);
 }
 
 // Open a web page in the current tab, then download a file in another tab via
 // a Javascript call.
 // Verify that we have 2 tabs, and the download shelf is visible in the current
 // tab.
 //
@@ skipping 11 matching lines @@
 
   // Download a file in a new tab and wait (via Javascript).
   FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
   DownloadAndWaitWithDisposition(browser(),
                                  GURL("javascript:openNew()"),
                                  CURRENT_TAB,
                                  EXPECT_NO_SELECT_DIALOG,
                                  ui_test_utils::BROWSER_TEST_WAIT_FOR_TAB);
 
   // When the download finishes, we should have two tabs.
-  CheckDownloadUI(browser(), true, true, file);
+  CheckDownloadShelfVisibility(browser(), SHELF_VISIBLE);
   EXPECT_EQ(2, browser()->tab_count());
 
   CheckDownload(browser(), file, file);
 }
 
 // Open a web page in the current tab, open another tab via a Javascript call,
 // then download a file in the new tab.
 // Verify that we have 2 tabs, and the download shelf is visible in the current
 // tab.
 //
@@ skipping 21 matching lines @@
   // Download a file and wait.
   FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
   DownloadAndWaitWithDisposition(browser(),
                                  url,
                                  CURRENT_TAB,
                                  EXPECT_NO_SELECT_DIALOG,
                                  ui_test_utils::BROWSER_TEST_NONE);
 
   // When the download finishes, we should have two tabs.
-  CheckDownloadUI(browser(), true, true, file);
+  CheckDownloadShelfVisibility(browser(), SHELF_VISIBLE);
   EXPECT_EQ(2, browser()->tab_count());
 
   CheckDownload(browser(), file, file);
 }
 
 // Open a web page in the current tab, then download a file via Javascript,
 // which will do so in a temporary tab.
 // Verify that we have 1 tab, and the download shelf is visible.
 //
 // The download_page3.html page contains an openNew() function that opens a
@@ skipping 12 matching lines @@
   // Download a file and wait.
   // The file to download is "download-test1.lib".
   FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
   DownloadAndWaitWithDisposition(browser(),
                                  GURL("javascript:openNew()"),
                                  CURRENT_TAB,
                                  EXPECT_NO_SELECT_DIALOG,
                                  ui_test_utils::BROWSER_TEST_WAIT_FOR_TAB);
 
   // When the download finishes, we should still have one tab.
-  CheckDownloadUI(browser(), true, true, file);
+  CheckDownloadShelfVisibility(browser(), SHELF_VISIBLE);
   EXPECT_EQ(1, browser()->tab_count());
 
   CheckDownload(browser(), file, file);
 }
 
 // Open a web page in the current tab, then call Javascript via a button to
 // download a file in a new tab, which is closed automatically when the
 // download begins.
 // Verify that we have 1 tab, and the download shelf is visible.
 //
@@ skipping 14 matching lines @@
   // The file to download is "download-test1.lib".
   FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
   DownloadAndWaitWithDisposition(
       browser(),
       GURL("javascript:document.getElementById('form').submit()"),
       CURRENT_TAB,
       EXPECT_NO_SELECT_DIALOG,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_TAB);
 
   // When the download finishes, we should still have one tab.
-  CheckDownloadUI(browser(), true, true, file);
+  CheckDownloadShelfVisibility(browser(), SHELF_VISIBLE);
   EXPECT_EQ(1, browser()->tab_count());
 
   CheckDownload(browser(), file, file);
 }
 
 // Download a file in a new window.
 // Verify that we have 2 windows, and the download shelf is not visible in the
 // first window, but is visible in the second window.
 // Close the new window.
 // Verify that we have 1 window, and the download shelf is not visible.
@@ skipping 13 matching lines @@
                                  url,
                                  NEW_WINDOW,
                                  EXPECT_NO_SELECT_DIALOG,
                                  ui_test_utils::BROWSER_TEST_NONE);
 
   // When the download finishes, the download shelf SHOULD NOT be visible in
   // the first window.
   ExpectWindowCountAfterDownload(2);
   EXPECT_EQ(1, browser()->tab_count());
   // Download shelf should close. Download panel stays open on ChromeOS.
-  CheckDownloadUI(browser(), false, true, file);
+  CheckDownloadShelfVisibility(browser(), SHELF_HIDDEN);
 
   // The download shelf SHOULD be visible in the second window.
   std::set<Browser*> original_browsers;
   original_browsers.insert(browser());
   Browser* download_browser =
       ui_test_utils::GetBrowserNotInSet(original_browsers);
   ASSERT_TRUE(download_browser != NULL);
   EXPECT_NE(download_browser, browser());
   EXPECT_EQ(1, download_browser->tab_count());
-  CheckDownloadUI(download_browser, true, true, file);
+  CheckDownloadShelfVisibility(download_browser, SHELF_VISIBLE);
 
 #if !defined(OS_MACOSX)
   // On Mac OS X, the UI window close is delayed until the outermost
   // message loop runs.  So it isn't possible to get a BROWSER_CLOSED
   // notification inside of a test.
   ui_test_utils::WindowedNotificationObserver signal(
       chrome::NOTIFICATION_BROWSER_CLOSED,
       content::Source<Browser>(download_browser));
 #endif
 
   // Close the new window.
   download_browser->CloseWindow();
 
 #if !defined(OS_MACOSX)
   signal.Wait();
   EXPECT_EQ(first_browser, browser());
   ExpectWindowCountAfterDownload(1);
 #endif
 
   EXPECT_EQ(1, browser()->tab_count());
   // Download shelf should close. Download panel stays open on ChromeOS.
-  CheckDownloadUI(browser(), false, true, file);
+  CheckDownloadShelfVisibility(browser(), SHELF_HIDDEN);
 
   CheckDownload(browser(), file, file);
 }
 
 // Check that downloading multiple (in this case, 2) files does not result in
 // corrupted files.
 IN_PROC_BROWSER_TEST_F(DownloadTest, MultiDownload) {
   ASSERT_TRUE(InitialSetup(false));
   EXPECT_EQ(1, browser()->tab_count());
 
   // Create a download, wait until it's started, and confirm
   // we're in the expected state.
   scoped_ptr<DownloadTestObserver> observer1(
       CreateInProgressWaiter(browser(), 1));
   ui_test_utils::NavigateToURL(
       browser(), GURL(URLRequestSlowDownloadJob::kUnknownSizeUrl));
   observer1->WaitForFinished();
 
   std::vector<DownloadItem*> downloads;
   browser()->profile()->GetDownloadManager()->SearchDownloads(
       string16(), &downloads);
   ASSERT_EQ(1u, downloads.size());
   ASSERT_EQ(DownloadItem::IN_PROGRESS, downloads[0]->GetState());
-  CheckDownloadUI(browser(), true, true, FilePath());
+  CheckDownloadShelfVisibility(browser(), SHELF_VISIBLE);
   DownloadItem* download1 = downloads[0];  // The only download.
 
   // Start the second download and wait until it's done.
   FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
   // Download the file and wait.  We do not expect the Select File dialog.
   DownloadAndWait(browser(), url, EXPECT_NO_SELECT_DIALOG);
 
   // Should now have 2 items on the download shelf.
   downloads.clear();
   browser()->profile()->GetDownloadManager()->SearchDownloads(
       string16(), &downloads);
   ASSERT_EQ(2u, downloads.size());
   // We don't know the order of the downloads.
   DownloadItem* download2 = downloads[(download1 == downloads[0]) ? 1 : 0];
 
   ASSERT_EQ(DownloadItem::IN_PROGRESS, download1->GetState());
   ASSERT_EQ(DownloadItem::COMPLETE, download2->GetState());
   // The download shelf should be open.
-  CheckDownloadUI(browser(), true, true, FilePath());
+  CheckDownloadShelfVisibility(browser(), SHELF_VISIBLE);
 
   // Allow the first request to finish.  We do this by loading a third URL
   // in a separate tab.
   scoped_ptr<DownloadTestObserver> observer2(CreateWaiter(browser(), 1));
   GURL finish_url(URLRequestSlowDownloadJob::kFinishDownloadUrl);
   ui_test_utils::NavigateToURLWithDisposition(
       browser(),
       finish_url,
       NEW_FOREGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
   observer2->WaitForFinished();  // Wait for the third request.
   EXPECT_EQ(1u, observer2->NumDownloadsSeenInState(DownloadItem::COMPLETE));
 
   // Get the important info from other threads and check it.
   EXPECT_TRUE(EnsureNoPendingDownloads());
 
-  CheckDownloadUI(browser(), true, true, FilePath());
+  CheckDownloadShelfVisibility(browser(), SHELF_VISIBLE);
 
   // The |DownloadItem|s should now be done and have the final file names.
   // Verify that the files have the expected data and size.
   // |file1| should be full of '*'s, and |file2| should be the same as the
   // source file.
   FilePath file1(download1->GetFullPath());
   size_t file_size1 = URLRequestSlowDownloadJob::kFirstDownloadSize +
                       URLRequestSlowDownloadJob::kSecondDownloadSize;
   std::string expected_contents(file_size1, '*');
   ASSERT_TRUE(VerifyFile(file1, expected_contents, file_size1));
@@ skipping 28 matching lines @@
       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]->GetState());
-  CheckDownloadUI(browser(), true, true, FilePath());
+  CheckDownloadShelfVisibility(browser(), SHELF_VISIBLE);
 
   // Cancel the download and wait for download system quiesce.
   downloads[0]->Delete(DownloadItem::DELETE_DUE_TO_USER_DISCARD);
   scoped_refptr<DownloadTestFlushObserver> flush_observer(
       new DownloadTestFlushObserver(
           DownloadManagerForBrowser(browser())));
   flush_observer->WaitForFlush();
 
   // Get the important info from other threads and check it.
   EXPECT_TRUE(EnsureNoPendingDownloads());
 
   // Using "DownloadItem::Remove" follows the discard dangerous download path,
   // which completely removes the browser from the shelf and closes the shelf
   // if it was there. Download panel stays open on ChromeOS.
-  CheckDownloadUI(browser(), false, true, FilePath());
+  CheckDownloadShelfVisibility(browser(), SHELF_HIDDEN);
 }
 
 // Confirm a download makes it into the history properly.
 IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadHistoryCheck) {
   ASSERT_TRUE(InitialSetup(false));
   FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
   FilePath origin_file(OriginFile(file));
   int64 origin_size;
   file_util::GetFileSize(origin_file, &origin_size);
 
   // Download the file and wait.  We do not expect the Select File dialog.
   DownloadAndWait(browser(), url, EXPECT_NO_SELECT_DIALOG);
 
   // Get details of what downloads have just happened.
   std::vector<DownloadItem*> downloads;
   GetDownloads(browser(), &downloads);
   ASSERT_EQ(1u, downloads.size());
   int64 db_handle = downloads[0]->GetDbHandle();
 
   // Check state.
   EXPECT_EQ(1, browser()->tab_count());
   CheckDownload(browser(), file, file);
-  CheckDownloadUI(browser(), true, true, file);
+  CheckDownloadShelfVisibility(browser(), SHELF_VISIBLE);
 
   // Check history results.
   DownloadsHistoryDataCollector history_collector(
       db_handle,
       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.
@@ skipping 102 matching lines @@
   DownloadManagerForBrowser(browser())->SearchDownloads(
       string16(), &downloads);
   ASSERT_EQ(1u, downloads.size());
   EXPECT_EQ(DownloadItem::COMPLETE, downloads[0]->GetState());
   EXPECT_TRUE(downloads[0]->GetOpened());
 
   // 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());
+  CheckDownloadShelfVisibility(browser(), SHELF_HIDDEN);
 }
 
 // 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<DownloadTestObserver> observer(
       DangerousDownloadWaiter(
           browser(), 1,
           DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_DENY));
   ui_test_utils::NavigateToURL(browser(), extension_url);
 
   observer->WaitForFinished();
   EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::CANCELLED));
   EXPECT_EQ(1u, observer->NumDangerousDownloadsSeen());
 
   // Download shelf should close. Download panel stays open on ChromeOS.
-  CheckDownloadUI(browser(), false, true, FilePath());
+  CheckDownloadShelfVisibility(browser(), SHELF_HIDDEN);
 
   // 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) {
@@ skipping 10 matching lines @@
           browser(), 1,
           DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_ACCEPT));
   ui_test_utils::NavigateToURL(browser(), extension_url);
 
   observer->WaitForFinished();
   EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
   CheckDownloadStates(1, DownloadItem::COMPLETE);
   EXPECT_EQ(1u, observer->NumDangerousDownloadsSeen());
 
   // Download shelf should close. Download panel stays open on ChromeOS.
-  CheckDownloadUI(browser(), false, true, FilePath());
+  CheckDownloadShelfVisibility(browser(), SHELF_HIDDEN);
 
   // 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) {
@@ skipping 10 matching lines @@
           browser(), 1,
           DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_ACCEPT));
   ui_test_utils::NavigateToURL(browser(), extension_url);
 
   observer->WaitForFinished();
   EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
   CheckDownloadStates(1, DownloadItem::COMPLETE);
   EXPECT_EQ(1u, observer->NumDangerousDownloadsSeen());
 
   // Download shelf should close. Download panel stays open on ChromeOS.
-  CheckDownloadUI(browser(), false, true, FilePath());
+  CheckDownloadShelfVisibility(browser(), SHELF_HIDDEN);
 
   // 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));
@@ skipping 37 matching lines @@
           browser(), 1,
           DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_ACCEPT));
   ui_test_utils::NavigateToURL(browser(), extension_url);
 
   observer->WaitForFinished();
   EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
   CheckDownloadStates(1, DownloadItem::COMPLETE);
   EXPECT_EQ(1u, observer->NumDangerousDownloadsSeen());
 
   // Download shelf should close. Download panel stays open on ChromeOS.
-  CheckDownloadUI(browser(), false, true, FilePath());
+  CheckDownloadShelfVisibility(browser(), SHELF_HIDDEN);
 
   // Check that the extension was installed.
   ExtensionService* extension_service =
       browser()->profile()->GetExtensionService();
   ASSERT_TRUE(extension_service->GetExtensionById(kLargeThemeCrxId, false));
 }
 
 // Sort download items by db_handle.
 static bool DownloadItemSorter(DownloadItem* d1, DownloadItem* d2) {
   return d1->GetDbHandle() < d2->GetDbHandle();
@@ skipping 149 matching lines @@
       url, GURL(""), "", false, -1, save_info, web_contents,
       DownloadManager::OnStartedCallback());
   observer->WaitForFinished();
   EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
   CheckDownloadStates(1, DownloadItem::COMPLETE);
   EXPECT_TRUE(observer->select_file_dialog_seen());
 
   // Check state.
   EXPECT_EQ(1, browser()->tab_count());
   ASSERT_TRUE(CheckDownload(browser(), file, file));
-  CheckDownloadUI(browser(), true, true, file);
+  CheckDownloadShelfVisibility(browser(), SHELF_VISIBLE);
 }
 
 IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadUrlToPath) {
   ASSERT_TRUE(InitialSetup(false));
   FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
 
   WebContents* web_contents = browser()->GetSelectedWebContents();
   ASSERT_TRUE(web_contents);
 
@@ skipping 11 matching lines @@
   observer->WaitForFinished();
   EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
 
   // Check state.
   EXPECT_EQ(1, browser()->tab_count());
   ASSERT_TRUE(CheckDownloadFullPaths(browser(),
                                      target_file_full_path,
                                      OriginFile(file)));
 
   // Temporary downloads won't be visible.
-  CheckDownloadUI(browser(), false, false, file);
+  CheckDownloadShelfVisibility(browser(), SHELF_HIDDEN);
 }
 
 IN_PROC_BROWSER_TEST_F(DownloadTest, SavePageNonHTMLViaGet) {
   // Do initial setup.
   ASSERT_TRUE(InitialSetup(false));
   ASSERT_TRUE(test_server()->Start());
   NullSelectFile(browser());
   std::vector<DownloadItem*> download_items;
   GetDownloads(browser(), &download_items);
   ASSERT_TRUE(download_items.empty());
@@ skipping 465 matching lines @@
   downloads.clear();
   GetDownloads(browser(), &downloads);
   EXPECT_EQ(0u, downloads.size());
 
   if (creation_observer->succeeded()) {
     // Wait until the download is done.  We don't care how it's finished.
     backup_observer.WaitForFinished();
   }
   DownloadManagerForBrowser(browser())->RemoveAllDownloads();
 }