Fixed issue with DownloadTestObserver.

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 "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"
@@ skipping 371 matching lines @@
 
   DownloadPrefs* GetDownloadPrefs(Browser* browser) {
     return DownloadPrefs::FromDownloadManager(
         DownloadManagerForBrowser(browser));
   }
 
   FilePath GetDownloadDirectory(Browser* browser) {
     return GetDownloadPrefs(browser)->download_path();
   }
 
-  // Create a DownloadTestObserver that will wait for the
+  // Create a DownloadTestObserverTerminal that will wait for the
   // specified number of downloads to finish.
   DownloadTestObserver* CreateWaiter(Browser* browser, int num_downloads) {
     DownloadManager* download_manager = DownloadManagerForBrowser(browser);
-    return new DownloadTestObserver(
+    return new DownloadTestObserverTerminal(
         download_manager, num_downloads,
-        DownloadItem::COMPLETE,  // Really done
         true,                   // Bail on select file
         DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_FAIL);
   }
 
-  // Create a DownloadTestObserver that will wait for the
+  // Create a DownloadTestObserverInProgress that will wait for the
   // specified number of downloads to start.
   DownloadTestObserver* CreateInProgressWaiter(Browser* browser,
                                             int num_downloads) {

[benjhayden, 2012/03/08 20:30:02]

pre-existing nit: indentation.

[ahendrickson, 2012/03/08 21:28:55]

Done.

     DownloadManager* download_manager = DownloadManagerForBrowser(browser);
-    return new DownloadTestObserver(
-        download_manager, num_downloads,
-        DownloadItem::IN_PROGRESS,      // Has started
-        true,                           // Bail on select file
-        DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_FAIL);
+    return new DownloadTestObserverInProgress(
+        download_manager, num_downloads);
   }
 
-  // Create a DownloadTestObserver that will wait for the
+  // Create a DownloadTestObserverTerminal that will wait for the
   // specified number of downloads to finish, or for
   // a dangerous download warning to be shown.
   DownloadTestObserver* DangerousInstallWaiter(
       Browser* browser,
       int num_downloads,
-      DownloadItem::DownloadState final_state,
       DownloadTestObserver::DangerousDownloadAction dangerous_download_action) {
     DownloadManager* download_manager = DownloadManagerForBrowser(browser);
-    return new DownloadTestObserver(
+    return new DownloadTestObserverTerminal(
         download_manager, num_downloads,
-        final_state,
         true,                         // Bail on select file
         dangerous_download_action);
   }
 
+  void CheckDownloadStatesForBrowser(Browser* browser,
+                                     size_t num,
+                                     DownloadItem::DownloadState state) {
+    std::vector<DownloadItem*> download_items;
+    GetDownloads(browser, &download_items);
+
+    EXPECT_EQ(num, download_items.size());
+
+    for (size_t i = 0; i < download_items.size(); ++i) {
+      EXPECT_EQ(state, download_items[i]->GetState()) << " Item " << i;
+    }
+  }
+
+  void CheckDownloadStates(size_t num, DownloadItem::DownloadState state) {
+    CheckDownloadStatesForBrowser(browser(), num, state);
+  }
+
   // 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<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();
+    DCHECK_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));

[Randy Smith (Not in Mondays), 2012/03/08 18:25:31]

I think of DCHECKs as not being good in test code, and from my perspective a lot
of your DCHECK_EQ() really should be EXPECT_EQ or ASSERT_EQ.  Could you change
them or help me understand why they're DCHECKs?

[ahendrickson, 2012/03/08 20:56:34]

Done.

 
     // If specified, check the state of the select file dialog.
     if (expectation != EXPECT_NOTHING) {
       EXPECT_EQ(expectation == EXPECT_SELECT_DIALOG,
                 observer->select_file_dialog_seen());
     }
   }
 
   // Download a file in the current tab, then wait for the download to finish.
   void DownloadAndWait(Browser* browser,
@@ skipping 92 matching lines @@
 
     // Allow the request to finish.  We do this by loading a second URL in a
     // separate tab.
     GURL finish_url(URLRequestSlowDownloadJob::kFinishDownloadUrl);
     ui_test_utils::NavigateToURLWithDisposition(
         browser,
         finish_url,
         NEW_FOREGROUND_TAB,
         ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
     observer->WaitForFinished();
+    DCHECK_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
+    CheckDownloadStatesForBrowser(browser, 1, DownloadItem::COMPLETE);

[Randy Smith (Not in Mondays), 2012/03/08 18:25:31]

These seem redundant.  You're welcome to leave it like this if you want, but I
don't think it's needed.  (Applies throughout file; as suggested elsewhere, if
you nuke one of these I'd nuke the NumDownloadsSeenInState.)

[ahendrickson, 2012/03/08 20:56:34]

For this test, they are somewhat redundant.  In others, NumDownloadsSeenInState
is more reliable.

 
     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);
 
@@ skipping 110 matching lines @@
     GetDownloads(browser(), &download_items);
     ASSERT_TRUE(download_items.empty());
 
     std::string server_path = "files/downloads/";
     server_path += download_info.url_name;
     GURL url = test_server()->GetURL(server_path);
     ASSERT_TRUE(url.is_valid());
 
     DownloadManager* download_manager = DownloadManagerForBrowser(browser());
     scoped_ptr<DownloadTestObserver> observer(
-        new DownloadTestObserver(
+        new DownloadTestObserverTerminal(
             download_manager,
             1,
-            download_info.reason == DOWNLOAD_INTERRUPT_REASON_NONE ?
-                DownloadItem::COMPLETE :  // Really done
-                DownloadItem::INTERRUPTED,
             true,                   // Bail on select file
             DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_FAIL));
 
     if (download_info.download_method == DOWNLOAD_DIRECT) {
       // Go directly to download.
       WebContents* web_contents = browser()->GetSelectedWebContents();
       ASSERT_TRUE(web_contents);
       DownloadSaveInfo save_info;
       save_info.prompt_for_save_location = false;
 
       DownloadManagerForBrowser(browser())->DownloadUrl(
           url, GURL(""), "", false, -1, save_info, web_contents);
     } else {
       // Navigate to URL normally, wait until done.
       ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(browser(),
                                                                 url,
                                                                 1);
     }
 
-    if (download_info.show_download_item)
+    if (download_info.show_download_item) {
       observer->WaitForFinished();
+      DownloadItem::DownloadState final_state =
+          (download_info.reason == DOWNLOAD_INTERRUPT_REASON_NONE) ?
+              DownloadItem::COMPLETE :
+              DownloadItem::INTERRUPTED;
+      DCHECK_EQ(1u, observer->NumDownloadsSeenInState(final_state));
+    }
 
     // Validate that the correct file was downloaded.
     download_items.clear();
     GetDownloads(browser(), &download_items);
     size_t item_count = download_info.show_download_item ? 1 : 0;
     ASSERT_EQ(item_count, download_items.size());
 
     if (download_info.show_download_item) {
       DownloadItem* item = download_items[0];
       ASSERT_EQ(url, item->GetOriginalUrl());
@@ skipping 58 matching lines @@
 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<DownloadTestObserver> observer(
-      new DownloadTestObserver(
+      new DownloadTestObserverTerminal(
           DownloadManagerForBrowser(browser()),
           1,
-          DownloadItem::COMPLETE,  // Really done
           false,                   // Continue on select file.
           DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_FAIL));
   ui_test_utils::NavigateToURLWithDisposition(
       browser(), url, CURRENT_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
   observer->WaitForFinished();
+  DCHECK_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);
 }
 
 // Access a file with a viewable mime-type, verify that a download
 // did not initiate.
@@ skipping 500 matching lines @@
   // 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.
+  DCHECK_EQ(1u, observer2->NumDownloadsSeenInState(DownloadItem::COMPLETE));
 
   // Get the important info from other threads and check it.
   scoped_refptr<CancelTestDataCollector> info(new CancelTestDataCollector());
   info->WaitForDataCollected();
   EXPECT_EQ(0, info->dfm_pending_downloads());
 
   CheckDownloadUI(browser(), true, true, FilePath());
 
   // 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));
 
   FilePath file2(download2->GetFullPath());
   ASSERT_TRUE(file_util::ContentsEqual(OriginFile(file), file2));
 }
 
 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
-  // 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
-  // DownloadTestObserver, that's not guaranteed; DownloadItems are created
-  // in the IN_PROGRESS state and made known to the DownloadManager
+  // DownloadTestObserverInProgress 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
+  // DownloadTestObserverInProgress, 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
@@ skipping 125 matching lines @@
 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<DownloadTestObserver> observer(CreateWaiter(browser(), 1));
   ui_test_utils::NavigateToURL(browser(), url);
   observer->WaitForFinished();
+  DCHECK_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
+  CheckDownloadStates(1, DownloadItem::COMPLETE);
 
   // 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.
 IN_PROC_BROWSER_TEST_F(DownloadTest, AutoOpen) {
   ASSERT_TRUE(InitialSetup(false));
@@ skipping 25 matching lines @@
 }
 
 // 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(
       DangerousInstallWaiter(
-          browser(), 1, DownloadItem::CANCELLED,
+          browser(), 1,
           DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_DENY));
   ui_test_utils::NavigateToURL(browser(), extension_url);
 
   observer->WaitForFinished();
+  DCHECK_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());
 
   // 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<DownloadTestObserver> observer(
       DangerousInstallWaiter(
-          browser(), 1, DownloadItem::COMPLETE,
+          browser(), 1,
           DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_ACCEPT));
   ui_test_utils::NavigateToURL(browser(), extension_url);
 
   observer->WaitForFinished();
+  DCHECK_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());
 
   // 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<DownloadTestObserver> observer(
       DangerousInstallWaiter(
-          browser(), 1, DownloadItem::COMPLETE,
+          browser(), 1,
           DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_ACCEPT));
   ui_test_utils::NavigateToURL(browser(), extension_url);
 
   observer->WaitForFinished();
+  DCHECK_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());
 
   // 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<DownloadTestObserver> observer(
       DangerousInstallWaiter(
-          browser(), 1, DownloadItem::COMPLETE,
+          browser(), 1,
           DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_ACCEPT));
   ui_test_utils::NavigateToURL(browser(), extension_url);
 
   observer->WaitForFinished();
+  DCHECK_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
+  CheckDownloadStates(1, DownloadItem::COMPLETE);
 
   // 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<DownloadTestObserver> observer(
       DangerousInstallWaiter(
-          browser(), 1, DownloadItem::COMPLETE,
+          browser(), 1,
           DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_ACCEPT));
   ui_test_utils::NavigateToURL(browser(), extension_url);
 
   observer->WaitForFinished();
+  DCHECK_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());
 
   // Check that the extension was installed.
   ExtensionService* extension_service =
       browser()->profile()->GetExtensionService();
   ASSERT_TRUE(extension_service->GetExtensionById(kLargeThemeCrxId, false));
 }
@@ skipping 136 matching lines @@
   FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
 
   // DownloadUrl always prompts; return acceptance of whatever it prompts.
   NullSelectFile(browser());
 
   WebContents* web_contents = browser()->GetSelectedWebContents();
   ASSERT_TRUE(web_contents);
 
   DownloadTestObserver* observer(
-    new DownloadTestObserver(
-        DownloadManagerForBrowser(browser()), 1,
-        DownloadItem::COMPLETE,  // Really done
-        false,                   // Ignore select file.
-        DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_FAIL));
+      new DownloadTestObserverTerminal(
+          DownloadManagerForBrowser(browser()), 1,
+          false,                   // Ignore select file.
+          DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_FAIL));
   DownloadSaveInfo save_info;
   save_info.prompt_for_save_location = true;
   DownloadManagerForBrowser(browser())->DownloadUrl(
       url, GURL(""), "", false, -1, save_info, web_contents);
   observer->WaitForFinished();
+  DCHECK_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);
 }
 
 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);
 
   ScopedTempDir other_directory;
   ASSERT_TRUE(other_directory.CreateUniqueTempDir());
   FilePath target_file_full_path
       = other_directory.path().Append(file.BaseName());
   DownloadSaveInfo save_info;
   save_info.file_path = target_file_full_path;
 
   DownloadTestObserver* observer(CreateWaiter(browser(), 1));
   DownloadManagerForBrowser(browser())->DownloadUrl(
       url, GURL(""), "", false, -1, save_info, web_contents);
   observer->WaitForFinished();
+  DCHECK_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);
 }
@@ skipping 12 matching lines @@
   // each time.
   GURL url = test_server()->GetURL("files/downloads/image.jpg");
   ASSERT_TRUE(url.is_valid());
   ui_test_utils::NavigateToURL(browser(), url);
 
   // Stop the test server, and then try to save the page. If cache validation
   // is not bypassed then this will fail since the server is no longer
   // reachable.
   ASSERT_TRUE(test_server()->Stop());
   scoped_ptr<DownloadTestObserver> waiter(
-      new DownloadTestObserver(
-          DownloadManagerForBrowser(browser()), 1, DownloadItem::COMPLETE,
+      new DownloadTestObserverTerminal(
+          DownloadManagerForBrowser(browser()), 1,
           false, DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_FAIL));
   browser()->SavePage();
   waiter->WaitForFinished();
+  DCHECK_EQ(1u, waiter->NumDownloadsSeenInState(DownloadItem::COMPLETE));
+  CheckDownloadStates(1, DownloadItem::COMPLETE);
 
   // Validate that the correct file was downloaded.
   GetDownloads(browser(), &download_items);
   EXPECT_TRUE(waiter->select_file_dialog_seen());
   ASSERT_EQ(1u, download_items.size());
   ASSERT_EQ(url, download_items[0]->GetOriginalUrl());
 
   // Try to download it via a context menu.
   scoped_ptr<DownloadTestObserver> waiter_context_menu(
-      new DownloadTestObserver(
-          DownloadManagerForBrowser(browser()), 1, DownloadItem::COMPLETE,
+      new DownloadTestObserverTerminal(
+          DownloadManagerForBrowser(browser()), 1,
           false, DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_FAIL));
   content::ContextMenuParams context_menu_params;
   context_menu_params.media_type = WebKit::WebContextMenuData::MediaTypeImage;
   context_menu_params.src_url = url;
   context_menu_params.page_url = url;
   TestRenderViewContextMenu menu(browser()->GetSelectedWebContents(),
                                  context_menu_params);
   menu.Init();
   menu.ExecuteCommand(IDC_CONTENT_CONTEXT_SAVEIMAGEAS);
   waiter_context_menu->WaitForFinished();
+  DCHECK_EQ(
+      1u, waiter_context_menu->NumDownloadsSeenInState(DownloadItem::COMPLETE));
+  CheckDownloadStates(2, DownloadItem::COMPLETE);
 
   // Validate that the correct file was downloaded via the context menu.
   download_items.clear();
   GetDownloads(browser(), &download_items);
   EXPECT_TRUE(waiter_context_menu->select_file_dialog_seen());
   ASSERT_EQ(2u, download_items.size());
   ASSERT_EQ(url, download_items[0]->GetOriginalUrl());
   ASSERT_EQ(url, download_items[1]->GetOriginalUrl());
 }
 
@@ skipping 29 matching lines @@
         string16(), ASCIIToUTF16("SubmitForm()"));
   observer.Wait();
   EXPECT_EQ(jpeg_url, web_contents->GetURL());
 
   // Stop the test server, and then try to save the page. If cache validation
   // is not bypassed then this will fail since the server is no longer
   // reachable. This will also fail if it tries to be retrieved via "GET"
   // rather than "POST".
   ASSERT_TRUE(test_server()->Stop());
   scoped_ptr<DownloadTestObserver> waiter(
-      new DownloadTestObserver(
-          DownloadManagerForBrowser(browser()), 1, DownloadItem::COMPLETE,
+      new DownloadTestObserverTerminal(
+          DownloadManagerForBrowser(browser()), 1,
           false, DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_FAIL));
   browser()->SavePage();
   waiter->WaitForFinished();
+  DCHECK_EQ(1u, waiter->NumDownloadsSeenInState(DownloadItem::COMPLETE));
+  CheckDownloadStates(1, DownloadItem::COMPLETE);
 
   // Validate that the correct file was downloaded.
   GetDownloads(browser(), &download_items);
   EXPECT_TRUE(waiter->select_file_dialog_seen());
   ASSERT_EQ(1u, download_items.size());
   ASSERT_EQ(jpeg_url, download_items[0]->GetOriginalUrl());
 
   // Try to download it via a context menu.
   scoped_ptr<DownloadTestObserver> waiter_context_menu(
-      new DownloadTestObserver(
-          DownloadManagerForBrowser(browser()), 1, DownloadItem::COMPLETE,
+      new DownloadTestObserverTerminal(
+          DownloadManagerForBrowser(browser()), 1,
           false, DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_FAIL));
   content::ContextMenuParams context_menu_params;
   context_menu_params.media_type = WebKit::WebContextMenuData::MediaTypeImage;
   context_menu_params.src_url = jpeg_url;
   context_menu_params.page_url = jpeg_url;
   TestRenderViewContextMenu menu(web_contents, context_menu_params);
   menu.Init();
   menu.ExecuteCommand(IDC_CONTENT_CONTEXT_SAVEIMAGEAS);
   waiter_context_menu->WaitForFinished();
+  DCHECK_EQ(
+      1u, waiter_context_menu->NumDownloadsSeenInState(DownloadItem::COMPLETE));
+  CheckDownloadStates(2, DownloadItem::COMPLETE);
 
   // Validate that the correct file was downloaded via the context menu.
   download_items.clear();
   GetDownloads(browser(), &download_items);
   EXPECT_TRUE(waiter_context_menu->select_file_dialog_seen());
   ASSERT_EQ(2u, download_items.size());
   ASSERT_EQ(jpeg_url, download_items[0]->GetOriginalUrl());
   ASSERT_EQ(jpeg_url, download_items[1]->GetOriginalUrl());
 }
 
@@ skipping 67 matching lines @@
     "zip_file_not_found.zip",
     DOWNLOAD_NAVIGATE,
     DOWNLOAD_INTERRUPT_REASON_SERVER_FAILED,
     false
   };
 
   // Do initial setup.
   ASSERT_TRUE(InitialSetup(false));
   DownloadFileCheckErrors(download_info);
 }