Checking that items exist in the downloads panel on ChromeOS.

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/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-inl.h"
@@ skipping 590 matching lines @@
   }
 
   // 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) {
-

[achuithb, 2011/06/24 21:08:53]

Fix lint error.

     DownloadManager* download_manager =
         browser->profile()->GetDownloadManager();
     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.
@@ skipping 122 matching lines @@
         browser,
         finish_url,
         NEW_FOREGROUND_TAB,
         ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
     observer->WaitForFinished();
 
     EXPECT_EQ(2, browser->tab_count());
 
     // TODO(ahendrickson): check download status text after downloading.
 
-    // Make sure the download shelf is showing.
-    CheckDownloadUIVisible(browser, true, true);
-
     FilePath basefilename(filename.BaseName());
     net::FileURLToFilePath(url, &filename);
     FilePath download_path = downloads_directory_.path().Append(basefilename);
+    CheckDownloadUI(browser, true, true, basefilename);
 
     bool downloaded_path_exists = file_util::PathExists(download_path);
     EXPECT_TRUE(downloaded_path_exists);
     if (!downloaded_path_exists)
       return false;
 
     // 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();
     manager->SearchDownloads(string16(), downloads);
   }
 
-  // Figure out if the appropriate download visibility was done.  A
-  // utility function to support ChromeOS variations.
-  static void CheckDownloadUIVisible(Browser* browser,
-                                     bool expected_non_chromeos,
-                                     bool expected_chromeos) {
+  // 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 correct (currently only on chromeos).

[Randy Smith (Not in Mondays), 2011/06/26 21:11:45]

nit: Suggested comment change "filename is correct" --> "filename is present in
download UI".

[achuithb, 2011/06/27 18:34:21]

Done.

+  void CheckDownloadUI(Browser* browser, bool expected_non_cros,
+      bool expected_cros, const FilePath& filename) {
 #if defined(OS_CHROMEOS)
-    EXPECT_EQ(expected_chromeos,
-              NULL != ActiveDownloadsUI::GetPopup(browser->profile()));
+    Browser* popup = ActiveDownloadsUI::GetPopup(browser->profile());
+    EXPECT_EQ(expected_cros, popup != NULL);
+    if (!popup || filename.empty())
+      return;
+
+    ActiveDownloadsUI* downloads_ui = static_cast<ActiveDownloadsUI*>(
+        popup->GetSelectedTabContents()->web_ui());
+    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]->full_path() == full_path) {
+        exists = true;
+        break;
+      }
+    }
+    EXPECT_TRUE(exists);
 #else
-    EXPECT_EQ(expected_non_chromeos,
-              browser->window()->IsDownloadShelfVisible());
+    EXPECT_EQ(expected_non_cros, browser->window()->IsDownloadShelfVisible());
+    // TODO: Check for filename match in download shelf.
 #endif
   }
-
   static void ExpectWindowCountAfterDownload(size_t expected) {
 #if defined(OS_CHROMEOS)
     // On ChromeOS, a download panel is created to display
     // download information, and this counts as a window.
     expected++;
 #endif
     EXPECT_EQ(expected, BrowserList::size());
   }
 
  private:
@@ skipping 129 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);
-  CheckDownloadUIVisible(browser(), true, true);
+  CheckDownloadUI(browser(), true, true, file);
 }
 
 #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);
-  CheckDownloadUIVisible(browser(), true, true);
+  CheckDownloadUI(browser(), true, true, file);
 }
 #endif
 
 // Put up a Select File dialog when the file is downloaded, due to its MIME
 // type.
 //
 // This test runs correctly, but leaves behind turds in the test user's
 // download directory because of http://crbug.com/62099.  No big loss; it
 // was primarily confirming DownloadsObserver wait on select file dialog
 // functionality anyway.
 IN_PROC_BROWSER_TEST_F(DownloadTest, DISABLED_DownloadMimeTypeSelect) {
   ASSERT_TRUE(InitialSetup(true));
   FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
 
   // Download the file and wait.  We expect the Select File dialog to appear
   // due to the MIME type.
   DownloadAndWait(browser(), url, EXPECT_SELECT_DIALOG);
 
   // Check state.
   EXPECT_EQ(1, browser()->tab_count());
   // Since we exited while the Select File dialog was visible, there should not
   // be anything in the download shelf and so it should not be visible.
-  CheckDownloadUIVisible(browser(), false, false);
+  CheckDownloadUI(browser(), false, false, FilePath());
 }
 
 // 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());
-  CheckDownloadUIVisible(browser(), false, false);
+  CheckDownloadUI(browser(), false, false, FilePath());
 }
 
 // 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());
-  CheckDownloadUIVisible(browser(), true, true);
+  CheckDownloadUI(browser(), true, true, download_file);
 }
 
 #if !defined(OS_CHROMEOS)  // 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());
-  CheckDownloadUIVisible(browser(), true, true);
+  CheckDownloadUI(browser(), true, true, download_file);
 
   // Open a second tab and wait.
   EXPECT_NE(static_cast<TabContentsWrapper*>(NULL),
             browser()->AddSelectedTabWithURL(GURL(), PageTransition::TYPED));
   EXPECT_EQ(2, browser()->tab_count());
-  CheckDownloadUIVisible(browser(),  true, true);
+  CheckDownloadUI(browser(), true, true, download_file);
 
   // Hide the download shelf.
   browser()->window()->GetDownloadShelf()->Close();
-  CheckDownloadUIVisible(browser(), false, false);
+  CheckDownloadUI(browser(), false, false, FilePath());
 
   // Go to the first tab.
   browser()->ActivateTabAt(0, true);
   EXPECT_EQ(2, browser()->tab_count());
 
   // The download shelf should not be visible.
-  CheckDownloadUIVisible(browser(), false, false);
+  CheckDownloadUI(browser(), false, false, FilePath());
 }
 #endif  // !OS_CHROMEOS
 
 // 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
@@ skipping 27 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.
-  CheckDownloadUIVisible(incognito, true, true);
+  CheckDownloadUI(incognito, true, true, file);
 
 #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(
       NotificationType::BROWSER_CLOSED,
       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.
-  CheckDownloadUIVisible(browser(), false, true);
+  CheckDownloadUI(browser(), false, true, file);
 
   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());
-  CheckDownloadUIVisible(browser(), false, false);
+  CheckDownloadUI(browser(), false, false, FilePath());
 }
 
 // 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.
-  CheckDownloadUIVisible(browser(), true, true);
+  CheckDownloadUI(browser(), true, true, file);
   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.
-  CheckDownloadUIVisible(browser(), true, true);
+  CheckDownloadUI(browser(), true, true, file);
   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.
-  CheckDownloadUIVisible(browser(), true, true);
+  CheckDownloadUI(browser(), true, true, file);
   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.
-  CheckDownloadUIVisible(browser(), true, true);
+  CheckDownloadUI(browser(), true, true, file);
   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.
-  CheckDownloadUIVisible(browser(), true, true);
+  CheckDownloadUI(browser(), true, true, file);
   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 12 matching lines @@
   DownloadAndWaitWithDisposition(browser(),
                                  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());
-  // Except on Chrome OS, where the download window sticks around.
-  CheckDownloadUIVisible(browser(), false, true);
+  // Download shelf should close. Download panel stays open on ChromeOS.
+  CheckDownloadUI(browser(), false, true, file);
 
   // 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());
-  CheckDownloadUIVisible(download_browser, true, true);
+  CheckDownloadUI(download_browser, true, true, file);
 
 #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(
       NotificationType::BROWSER_CLOSED,
       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());
-  // On ChromeOS, the popup sticks around.
-  CheckDownloadUIVisible(browser(), false, true);
+  // Download shelf should close. Download panel stays open on ChromeOS.
+  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
@@ skipping 17 matching lines @@
       CreateInProgressWaiter(browser(), 1));
   ui_test_utils::NavigateToURL(
       browser(), GURL(URLRequestSlowDownloadJob::kUnknownSizeUrl));
   observer->WaitForFinished();
 
   std::vector<DownloadItem*> downloads;
   browser()->profile()->GetDownloadManager()->SearchDownloads(
       string16(), &downloads);
   ASSERT_EQ(1u, downloads.size());
   ASSERT_EQ(DownloadItem::IN_PROGRESS, downloads[0]->state());
-  CheckDownloadUIVisible(browser(), true, true);
+  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()));
   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
-  // if it was there.  Chrome OS is an exception to this, where if we
-  // bring up the downloads panel, it stays there.
-  CheckDownloadUIVisible(browser(), false, true);
+  // if it was there. Download panel stays open on ChromeOS.
+  CheckDownloadUI(browser(), false, true, FilePath());
 }
 
 // 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]->db_handle();
 
   // Check state.
   EXPECT_EQ(1, browser()->tab_count());
   CheckDownload(browser(), file, file);
-  CheckDownloadUIVisible(browser(), true, true);
+  CheckDownloadUI(browser(), true, true, file);
 
   // Check history results.
   DownloadsHistoryDataCollector history_collector(
       db_handle,
       browser()->profile()->GetDownloadManager());
   DownloadHistoryInfo info;
   EXPECT_TRUE(history_collector.GetDownloadsHistoryEntry(&info)) << db_handle;
   EXPECT_EQ(file, info.path.BaseName());
   EXPECT_EQ(url, info.url);
   // Ignore start_time.
@@ skipping 77 matching lines @@
   std::vector<DownloadItem*> downloads;
   browser()->profile()->GetDownloadManager()->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);
-  // Dissapears on most UIs, but the download panel sticks around for
-  // chrome os.
-  CheckDownloadUIVisible(browser(), false, true);
+  // Download shelf should close. Download panel stays open on ChromeOS.
+  CheckDownloadUI(browser(), false, true, file);
 }
 
 // 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));
   ui_test_utils::NavigateToURL(browser(), extension_url);
 
   observer->WaitForFinished();
   EXPECT_EQ(1u, observer->NumDangerousDownloadsSeen());
 
-  CheckDownloadUIVisible(browser(), false, true);
+  // 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));
   ui_test_utils::NavigateToURL(browser(), extension_url);
 
   observer->WaitForFinished();
   EXPECT_EQ(1u, observer->NumDangerousDownloadsSeen());
 
-  // DL Shelf should close.  Download panel sticks around on ChromeOS.
-  CheckDownloadUIVisible(browser(), false, true);
+  // 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));
   ui_test_utils::NavigateToURL(browser(), extension_url);
 
   observer->WaitForFinished();
   EXPECT_EQ(1u, observer->NumDangerousDownloadsSeen());
 
-  // DL Shelf should close.  Download panel sticks around on ChromeOS.
-  CheckDownloadUIVisible(browser(), false, true);
+  // 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));
@@ skipping 34 matching lines @@
   scoped_ptr<DownloadsObserver> observer(
       DangerousInstallWaiter(browser(),
                              1,
                              DownloadItem::COMPLETE,
                              ON_DANGEROUS_DOWNLOAD_ACCEPT));
   ui_test_utils::NavigateToURL(browser(), extension_url);
 
   observer->WaitForFinished();
   EXPECT_EQ(1u, observer->NumDangerousDownloadsSeen());
 
-  // DL Shelf should close.  Download panel sticks around on ChromeOS.
-  CheckDownloadUIVisible(browser(), false, true);
+  // 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));
 }