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 00:10:06]

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 128 matching lines @@
     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);
+    CheckDownloadExistsInUI(browser, 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);
   }
 
+  void CheckDownloadExistsInUI(Browser* browser,
+                               const FilePath& file_path) {
+#if defined(OS_CHROMEOS)
+    Browser* popup = ActiveDownloadsUI::GetPopup(browser->profile());
+    DCHECK(popup);

[Paweł Hajdan Jr., 2011/06/24 08:36:33]

No DCHECKs in test code. They crash the entire thing and don't work in Release
mode. I'm pretty sure you want ASSERT_TRUE.

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

Done.

+    ActiveDownloadsUI* downloads_ui = static_cast<ActiveDownloadsUI*>(
+        popup->GetSelectedTabContents()->web_ui());
+    DCHECK(downloads_ui);
+    const ActiveDownloadsUI::DownloadList& downloads =
+        downloads_ui->GetDownloads();
+    EXPECT_EQ(downloads.size(), size_t(1));

[Paweł Hajdan Jr., 2011/06/24 08:36:33]

nit: 1U instead of size_t(1).

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

Done.

+
+    FilePath download_path;
+    FilePath full_path(DestinationFile(browser, file_path));
+    for (size_t i = 0; i < downloads.size(); ++i) {
+      if (downloads[i]->full_path() == full_path) {
+        download_path = full_path;
+        break;
+      }
+    }
+    EXPECT_EQ(full_path, download_path);
+#endif

[Paweł Hajdan Jr., 2011/06/24 08:36:33]

nit:  // defined(OS_CHROMEOS)

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

There's now also an else clause for non-chromeos. Since this thread:
http://groups.google.com/a/chromium.org/group/chromium-dev/browse_thread/thre...
didn't produce a good answer, I'm going to leave out the comments altogether
since the block is short enough to fit in one screen. Hope that's ok.

+  }
+
   // 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) {
 #if defined(OS_CHROMEOS)
     EXPECT_EQ(expected_chromeos,
               NULL != ActiveDownloadsUI::GetPopup(browser->profile()));
 #else
     EXPECT_EQ(expected_non_chromeos,
@@ skipping 144 matching lines @@
   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);
+  CheckDownloadExistsInUI(browser(), 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);
+  CheckDownloadExistsInUI(browser(), 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.
@@ skipping 43 matching lines @@
   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);
+  CheckDownloadExistsInUI(browser(), 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);
+  CheckDownloadExistsInUI(browser(), 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);
+  CheckDownloadExistsInUI(browser(), download_file);
 
   // Hide the download shelf.
   browser()->window()->GetDownloadShelf()->Close();
   CheckDownloadUIVisible(browser(), false, false);
 
   // Go to the first tab.
   browser()->ActivateTabAt(0, true);
   EXPECT_EQ(2, browser()->tab_count());
 
   // The download shelf should not be visible.
@@ skipping 39 matching lines @@
   // 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);
+  CheckDownloadExistsInUI(incognito, 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);
+  CheckDownloadExistsInUI(browser(), 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.
@@ skipping 23 matching lines @@
   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);
+  CheckDownloadExistsInUI(browser(), 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 12 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);
+  CheckDownloadExistsInUI(browser(), 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 22 matching lines @@
   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);
+  CheckDownloadExistsInUI(browser(), 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 13 matching lines @@
   // 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);
+  CheckDownloadExistsInUI(browser(), 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 15 matching lines @@
   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);
+  CheckDownloadExistsInUI(browser(), 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.
+  // Download shelf should close. Download panel stays open on ChromeOS.
   CheckDownloadUIVisible(browser(), false, true);
+  CheckDownloadExistsInUI(browser(), 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);
+  CheckDownloadExistsInUI(download_browser, 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.
+  // Download shelf should close. Download panel stays open on ChromeOS.
   CheckDownloadUIVisible(browser(), false, true);
+  CheckDownloadExistsInUI(browser(), 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 33 matching lines @@
   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.
+  // if it was there. Download panel stays open on ChromeOS.
   CheckDownloadUIVisible(browser(), false, true);
 }
 
 // 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);
+  CheckDownloadExistsInUI(browser(), 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.
+  // Download shelf should close. Download panel stays open on ChromeOS.
   CheckDownloadUIVisible(browser(), false, true);
+  CheckDownloadExistsInUI(browser(), 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());
 
+  // Download shelf should close. Download panel stays open on ChromeOS.
   CheckDownloadUIVisible(browser(), false, true);
 
   // 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.
+  // Download shelf should close. Download panel stays open on ChromeOS.
   CheckDownloadUIVisible(browser(), false, true);
 
   // 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.
+  // Download shelf should close. Download panel stays open on ChromeOS.
   CheckDownloadUIVisible(browser(), false, true);
 
   // 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) {
@@ skipping 35 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.
+  // Download shelf should close. Download panel stays open on ChromeOS.
   CheckDownloadUIVisible(browser(), false, true);
 
   // Check that the extension was installed.
   ExtensionService* extension_service =
       browser()->profile()->GetExtensionService();
   ASSERT_TRUE(extension_service->GetExtensionById(kLargeThemeCrxId, false));
 }