[Downloads] Stop keying TestFileErrorInjector off of URLs.

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 "chrome/browser/download/download_browsertest.h"
 
 #include <stdint.h>
 #include <sstream>
 #include <utility>
 
@@ skipping 954 matching lines @@
 
     for (size_t i = 0; i < count; ++i) {
       DownloadFilesCheckErrorsLoopBody(download_info[i], i);
     }
   }
 
   void DownloadInsertFilesErrorCheckErrorsLoopBody(
       scoped_refptr<content::TestFileErrorInjector> injector,
       const FileErrorInjectInfo& info,
       size_t i) {
-    std::stringstream s;
-    s << " " << __FUNCTION__ << "()"
-      << " index = " << i
-      << " url = " << info.error_info.url
-      << " operation code = "
-      << content::TestFileErrorInjector::DebugString(info.error_info.code)
-      << " instance = " << info.error_info.operation_instance
-      << " error = "
-      << content::DownloadInterruptReasonToString(info.error_info.error);
+    SCOPED_TRACE(
+        ::testing::Message()
+        << " " << __FUNCTION__ << "()"
+        << " index = " << i << " operation code = "
+        << content::TestFileErrorInjector::DebugString(info.error_info.code)
+        << " instance = " << info.error_info.operation_instance << " error = "
+        << content::DownloadInterruptReasonToString(info.error_info.error));
 
-    injector->ClearErrors();
-    injector->AddError(info.error_info);
-
-    injector->InjectErrors();
+    injector->InjectError(info.error_info);
 
     DownloadFilesCheckErrorsLoopBody(info.download_info, i);
 
     size_t expected_successes = info.download_info.show_download_item ? 1u : 0u;
-    EXPECT_EQ(expected_successes, injector->TotalFileCount()) << s.str();
-    EXPECT_EQ(0u, injector->CurrentFileCount()) << s.str();
-
-    if (info.download_info.show_download_item)
-      EXPECT_TRUE(injector->HadFile(GURL(info.error_info.url))) << s.str();
+    EXPECT_EQ(expected_successes, injector->TotalFileCount());
+    EXPECT_EQ(0u, injector->CurrentFileCount());
   }
 
   void DownloadInsertFilesErrorCheckErrors(size_t count,
                                            FileErrorInjectInfo* info) {
     DownloadFilesCheckErrorsSetup();
 
     // Set up file failures.
     scoped_refptr<content::TestFileErrorInjector> injector(
         content::TestFileErrorInjector::Create(
             DownloadManagerForBrowser(browser())));
 
     for (size_t i = 0; i < count; ++i) {
-      // Set up the full URL, for download file tracking.
-      std::string server_path = "/downloads/";
-      server_path += info[i].download_info.starting_url;
-      GURL url = embedded_test_server()->GetURL(server_path);
-      info[i].error_info.url = url.spec();
-
       DownloadInsertFilesErrorCheckErrorsLoopBody(injector, info[i], i);
     }
   }
 
   // Attempts to download a file to a read-only folder, based on information
   // in |download_info|.
   void DownloadFilesToReadonlyFolder(size_t count,
                                      DownloadInfo* download_info) {
     DownloadFilesCheckErrorsSetup();
 
@@ skipping 12 matching lines @@
   // This method:
   // * Starts a mock download by navigating browser() to a URLRequestMockHTTPJob
   //   mock URL.
   // * Injects |error| on the first write using |error_injector|.
   // * Waits for the download to be interrupted.
   // * Clears the errors on |error_injector|.
   // * Returns the resulting interrupted download.
   DownloadItem* StartMockDownloadAndInjectError(
       content::TestFileErrorInjector* error_injector,
       content::DownloadInterruptReason error) {
-    GURL url = URLRequestMockHTTPJob::GetMockUrl(kDownloadTest1Path);
-
     content::TestFileErrorInjector::FileErrorInfo error_info;
-    error_info.url = url.spec();
     error_info.code = content::TestFileErrorInjector::FILE_OPERATION_WRITE;
     error_info.operation_instance = 0;
     error_info.error = error;
-    error_injector->ClearErrors();
-    error_injector->AddError(error_info);
-    error_injector->InjectErrors();
+    error_injector->InjectError(error_info);
 
     scoped_ptr<content::DownloadTestObserver> observer(
         new DownloadTestObserverResumable(
             DownloadManagerForBrowser(browser()), 1));
+
+    GURL url = URLRequestMockHTTPJob::GetMockUrl(kDownloadTest1Path);
     ui_test_utils::NavigateToURL(browser(), url);
     observer->WaitForFinished();
 
     content::DownloadManager::DownloadVector downloads;
     DownloadManagerForBrowser(browser())->GetAllDownloads(&downloads);
     EXPECT_EQ(1u, downloads.size());
 
     if (downloads.size() != 1)
       return NULL;
 
-    error_injector->ClearErrors();
-    error_injector->InjectErrors();
+    error_injector->ClearError();
     DownloadItem* download = downloads[0];
     EXPECT_EQ(DownloadItem::INTERRUPTED, download->GetState());
     EXPECT_EQ(error, download->GetLastReason());
     return download;
   }
 
  private:
   static void EnsureNoPendingDownloadJobsOnIO(bool* result) {
     if (net::URLRequestSlowDownloadJob::NumberOutstandingRequests())
       *result = false;
@@ skipping 1253 matching lines @@
 
   DownloadFilesCheckErrors(arraysize(download_info), download_info);
 }
 
 IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadErrorsFile) {
   FileErrorInjectInfo error_info[] = {
       {// Navigated download with injected "Disk full" error in Initialize().
        {"a_zip_file.zip", "a_zip_file.zip", DOWNLOAD_NAVIGATE,
         content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE, true, false},
        {
-           "", content::TestFileErrorInjector::FILE_OPERATION_INITIALIZE, 0,
+           content::TestFileErrorInjector::FILE_OPERATION_INITIALIZE, 0,
            content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE,
        }},
       {// Direct download with injected "Disk full" error in Initialize().
        {"a_zip_file.zip", "a_zip_file.zip", DOWNLOAD_DIRECT,
         content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE, true, false},
        {
-           "", content::TestFileErrorInjector::FILE_OPERATION_INITIALIZE, 0,
+           content::TestFileErrorInjector::FILE_OPERATION_INITIALIZE, 0,
            content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE,
        }},
       {// Navigated download with injected "Disk full" error in Write().
        {"a_zip_file.zip", "a_zip_file.zip", DOWNLOAD_NAVIGATE,
         content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE, true, false},
        {
-           "", content::TestFileErrorInjector::FILE_OPERATION_WRITE, 0,
+           content::TestFileErrorInjector::FILE_OPERATION_WRITE, 0,
            content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE,
        }},
       {// Direct download with injected "Disk full" error in Write().
        {"a_zip_file.zip", "a_zip_file.zip", DOWNLOAD_DIRECT,
         content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE, true, false},
        {
-           "", content::TestFileErrorInjector::FILE_OPERATION_WRITE, 0,
+           content::TestFileErrorInjector::FILE_OPERATION_WRITE, 0,
            content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE,
        }},
       {// Navigated download with injected "Failed" error in Initialize().
        {"a_zip_file.zip", "a_zip_file.zip", DOWNLOAD_NAVIGATE,
         content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED, true, false},
        {
-           "", content::TestFileErrorInjector::FILE_OPERATION_INITIALIZE, 0,
+           content::TestFileErrorInjector::FILE_OPERATION_INITIALIZE, 0,
            content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
        }},
       {// Direct download with injected "Failed" error in Initialize().
        {"a_zip_file.zip", "a_zip_file.zip", DOWNLOAD_DIRECT,
         content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED, true, false},
        {
-           "", content::TestFileErrorInjector::FILE_OPERATION_INITIALIZE, 0,
+           content::TestFileErrorInjector::FILE_OPERATION_INITIALIZE, 0,
            content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
        }},
       {// Navigated download with injected "Failed" error in Write().
        {"a_zip_file.zip", "a_zip_file.zip", DOWNLOAD_NAVIGATE,
         content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED, true, false},
        {
-           "", content::TestFileErrorInjector::FILE_OPERATION_WRITE, 0,
+           content::TestFileErrorInjector::FILE_OPERATION_WRITE, 0,
            content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
        }},
       {// Direct download with injected "Failed" error in Write().
        {"a_zip_file.zip", "a_zip_file.zip", DOWNLOAD_DIRECT,
         content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED, true, false},
        {
-           "", content::TestFileErrorInjector::FILE_OPERATION_WRITE, 0,
+           content::TestFileErrorInjector::FILE_OPERATION_WRITE, 0,
            content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
        }},
       {// Navigated download with injected "Name too long" error in
        // Initialize().
        {"a_zip_file.zip", "a_zip_file.zip", DOWNLOAD_NAVIGATE,
         content::DOWNLOAD_INTERRUPT_REASON_FILE_NAME_TOO_LONG, true, false},
        {
-           "", content::TestFileErrorInjector::FILE_OPERATION_INITIALIZE, 0,
+           content::TestFileErrorInjector::FILE_OPERATION_INITIALIZE, 0,
            content::DOWNLOAD_INTERRUPT_REASON_FILE_NAME_TOO_LONG,
        }},
       {// Direct download with injected "Name too long" error in Initialize().
        {"a_zip_file.zip", "a_zip_file.zip", DOWNLOAD_DIRECT,
         content::DOWNLOAD_INTERRUPT_REASON_FILE_NAME_TOO_LONG, true, false},
        {
-           "", content::TestFileErrorInjector::FILE_OPERATION_INITIALIZE, 0,
+           content::TestFileErrorInjector::FILE_OPERATION_INITIALIZE, 0,
            content::DOWNLOAD_INTERRUPT_REASON_FILE_NAME_TOO_LONG,
        }},
       {// Navigated download with injected "Name too long" error in Write().
        {"a_zip_file.zip", "a_zip_file.zip", DOWNLOAD_NAVIGATE,
         content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED, true, false},
        {
-           "", content::TestFileErrorInjector::FILE_OPERATION_WRITE, 0,
+           content::TestFileErrorInjector::FILE_OPERATION_WRITE, 0,
            content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
        }},
       {// Direct download with injected "Name too long" error in Write().
        {"a_zip_file.zip", "a_zip_file.zip", DOWNLOAD_DIRECT,
         content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED, true, false},
        {
-           "", content::TestFileErrorInjector::FILE_OPERATION_WRITE, 0,
+           content::TestFileErrorInjector::FILE_OPERATION_WRITE, 0,
            content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
        }},
       {// Direct download with injected "Disk full" error in 2nd Write().
        {"06bESSE21Evolution.ppt", "06bESSE21Evolution.ppt", DOWNLOAD_DIRECT,
         content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE, true, false},
        {
-           "", content::TestFileErrorInjector::FILE_OPERATION_WRITE, 1,
+           content::TestFileErrorInjector::FILE_OPERATION_WRITE, 1,
            content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE,
        }}};
 
   DownloadInsertFilesErrorCheckErrors(arraysize(error_info), error_info);
 }
 
 IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadErrorReadonlyFolder) {
   DownloadInfo download_info[] = {
       {"a_zip_file.zip", "a_zip_file.zip", DOWNLOAD_DIRECT,
        // This passes because we switch to the My Documents folder.
@@ skipping 614 matching lines @@
   scoped_ptr<content::DownloadTestObserver> resumable_observer(
       new DownloadTestObserverResumable(
           DownloadManagerForBrowser(browser()), 2));
 
   EnableFileChooser(true);
   DownloadItem* download = StartMockDownloadAndInjectError(
       error_injector.get(), content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED);
   ASSERT_TRUE(download);
 
   content::TestFileErrorInjector::FileErrorInfo error_info;
-  error_info.url = download->GetOriginalUrl().spec();
   error_info.code = content::TestFileErrorInjector::FILE_OPERATION_WRITE;
   error_info.operation_instance = 0;
   error_info.error = content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED;
-  error_injector->AddError(error_info);
-  error_injector->InjectErrors();
+  error_injector->InjectError(error_info);
 
   // Resuming should cause the download to be interrupted again due to the
   // errors we are injecting.
   download->Resume();
   resumable_observer->WaitForFinished();
   ASSERT_EQ(DownloadItem::INTERRUPTED, download->GetState());
   ASSERT_EQ(content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
             download->GetLastReason());
 
-  error_injector->ClearErrors();
-  error_injector->InjectErrors();
+  error_injector->ClearError();
 
   // No errors this time. The download should complete successfully.
   EXPECT_FALSE(completion_observer->IsFinished());
   completion_observer->StartObserving();
   download->Resume();
   completion_observer->WaitForFinished();
   EXPECT_EQ(DownloadItem::COMPLETE, download->GetState());
 
   EXPECT_FALSE(DidShowFileChooser());
 }
@@ skipping 452 matching lines @@
 
   scoped_ptr<content::DownloadTestObserver> observer(DangerousDownloadWaiter(
       browser(), 1, content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_DENY));
   ui_test_utils::NavigateToURL(browser(), extension_url);
 
   observer->WaitForFinished();
 
   // Download shelf should close.
   EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
 }