[Downloads] Always call DM::StartDownload() for explicit downloads.

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 380 matching lines @@
 class DownloadTest : public InProcessBrowserTest {
  public:
   // Choice of navigation or direct fetch.  Used by |DownloadFileCheckErrors()|.
   enum DownloadMethod {
     DOWNLOAD_NAVIGATE,
     DOWNLOAD_DIRECT
   };
 
   // Information passed in to |DownloadFileCheckErrors()|.
   struct DownloadInfo {
-    const char* url_name;  // URL for the download.
-    DownloadMethod download_method;  // Navigation or Direct.
+    const char* starting_url;           // URL for initiating the download.
+    const char* expected_download_url;  // Expected value of DI::GetURL(). Can
+                                        // be different if |starting_url|
+                                        // initiates a download from another
+                                        // URL.
+    DownloadMethod download_method;     // Navigation or Direct.
     // Download interrupt reason (NONE is OK).
     content::DownloadInterruptReason reason;
     bool show_download_item;  // True if the download item appears on the shelf.
     bool should_redirect_to_documents;  // True if we save it in "My Documents".
   };
 
   struct FileErrorInjectInfo {
     DownloadInfo download_info;
     content::TestFileErrorInjector::FileErrorInfo error_info;
   };
@@ skipping 412 matching lines @@
     ASSERT_TRUE(embedded_test_server()->Start());
     std::vector<DownloadItem*> download_items;
     GetDownloads(browser(), &download_items);
     ASSERT_TRUE(download_items.empty());
 
     EnableFileChooser(true);
   }
 
   void DownloadFilesCheckErrorsLoopBody(const DownloadInfo& download_info,
                                         size_t i) {
-    SCOPED_TRACE(
-        ::testing::Message()
-        << " " << __FUNCTION__ << "()"
-        << " index = " << i << " url = '" << download_info.url_name << "'"
-        << " method = " << ((download_info.download_method == DOWNLOAD_DIRECT)
-                                ? "DOWNLOAD_DIRECT"
-                                : "DOWNLOAD_NAVIGATE")
-        << " show_item = " << download_info.show_download_item << " reason = "
-        << DownloadInterruptReasonToString(download_info.reason));
+    SCOPED_TRACE(testing::Message()
+                 << " " << __FUNCTION__ << "()"
+                 << " index = " << i << " starting_url = '"
+                 << download_info.starting_url << "'"
+                 << " download_url = '" << download_info.expected_download_url
+                 << "'"
+                 << " method = "
+                 << ((download_info.download_method == DOWNLOAD_DIRECT)
+                         ? "DOWNLOAD_DIRECT"
+                         : "DOWNLOAD_NAVIGATE")
+                 << " show_item = " << download_info.show_download_item
+                 << " reason = "
+                 << DownloadInterruptReasonToString(download_info.reason));
 
     std::vector<DownloadItem*> download_items;
     GetDownloads(browser(), &download_items);
     size_t downloads_expected = download_items.size();
 
-    std::string server_path = "/downloads/";
-    server_path += download_info.url_name;
-    GURL url = embedded_test_server()->GetURL(server_path);
-    ASSERT_TRUE(url.is_valid());
+    // GURL("http://foo/bar").Resolve("baz") => "http://foo/bar/baz"
+    // GURL("http://foo/bar").Resolve("http://baz") => "http://baz"
+    // I.e. both starting_url and expected_download_url can either be relative
+    // to the base test server URL or be an absolute URL.
+    GURL base_url = embedded_test_server()->GetURL("/downloads/");
+    GURL starting_url = base_url.Resolve(download_info.starting_url);
+    GURL download_url = base_url.Resolve(download_info.expected_download_url);
+    ASSERT_TRUE(starting_url.is_valid());
+    ASSERT_TRUE(download_url.is_valid());
 
     DownloadManager* download_manager = DownloadManagerForBrowser(browser());
     WebContents* web_contents =
         browser()->tab_strip_model()->GetActiveWebContents();
     ASSERT_TRUE(web_contents);
 
     scoped_ptr<content::DownloadTestObserver> observer;
     if (download_info.reason == content::DOWNLOAD_INTERRUPT_REASON_NONE) {
       observer.reset(new content::DownloadTestObserverTerminal(
           download_manager, 1,
           content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_FAIL));
     } else {
       observer.reset(new content::DownloadTestObserverInterrupted(
           download_manager, 1,
           content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_FAIL));
     }
 
     if (download_info.download_method == DOWNLOAD_DIRECT) {
       // Go directly to download.  Don't wait for navigation.
       scoped_refptr<content::DownloadTestItemCreationObserver>
           creation_observer(new content::DownloadTestItemCreationObserver);
 
       scoped_ptr<DownloadUrlParameters> params(
-          DownloadUrlParameters::FromWebContents(web_contents, url));
+          DownloadUrlParameters::FromWebContents(web_contents, starting_url));
       params->set_callback(creation_observer->callback());
       DownloadManagerForBrowser(browser())->DownloadUrl(std::move(params));
 
       // Wait until the item is created, or we have determined that it
       // won't be.
       creation_observer->WaitForDownloadItemCreation();
 
-      ASSERT_EQ(download_info.show_download_item,
-                creation_observer->succeeded());
-      if (download_info.show_download_item) {
-        EXPECT_EQ(content::DOWNLOAD_INTERRUPT_REASON_NONE,
-                  creation_observer->interrupt_reason());
-        EXPECT_NE(content::DownloadItem::kInvalidId,
-                  creation_observer->download_id());
-      } else {
-        EXPECT_NE(content::DOWNLOAD_INTERRUPT_REASON_NONE,
-                  creation_observer->interrupt_reason());
-        EXPECT_EQ(content::DownloadItem::kInvalidId,
-                  creation_observer->download_id());
-      }
+      EXPECT_NE(content::DownloadItem::kInvalidId,
+                creation_observer->download_id());
     } else {
       // Navigate to URL normally, wait until done.
-      ui_test_utils::NavigateToURL(browser(), url);
+      ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(
+          browser(), starting_url, 1);
     }
 
     if (download_info.show_download_item) {
       downloads_expected++;
       observer->WaitForFinished();
       DownloadItem::DownloadState final_state =
           (download_info.reason == content::DOWNLOAD_INTERRUPT_REASON_NONE) ?
               DownloadItem::COMPLETE :
               DownloadItem::INTERRUPTED;
       EXPECT_EQ(1u, observer->NumDownloadsSeenInState(final_state));
     }
 
     // Wait till the |DownloadFile|s are destroyed.
     content::RunAllPendingInMessageLoop(content::BrowserThread::FILE);
     content::RunAllPendingInMessageLoop(content::BrowserThread::UI);
 
     // Validate that the correct files were downloaded.
     download_items.clear();
     GetDownloads(browser(), &download_items);
     ASSERT_EQ(downloads_expected, download_items.size());
 
     if (download_info.show_download_item) {
       // Find the last download item.
       DownloadItem* item = download_items[0];
       for (size_t d = 1; d < downloads_expected; ++d) {
         if (download_items[d]->GetStartTime() > item->GetStartTime())
           item = download_items[d];
       }
 
-      ASSERT_EQ(url, item->GetOriginalUrl());
-      ASSERT_EQ(download_info.reason, item->GetLastReason());
+      EXPECT_EQ(download_url, item->GetURL());
+      EXPECT_EQ(download_info.reason, item->GetLastReason());
 
       if (item->GetState() == content::DownloadItem::COMPLETE) {
         // Clean up the file, in case it ended up in the My Documents folder.
         base::FilePath destination_folder = GetDownloadDirectory(browser());
         base::FilePath my_downloaded_file = item->GetTargetFilePath();
         EXPECT_TRUE(base::PathExists(my_downloaded_file));
         EXPECT_TRUE(base::DeleteFile(my_downloaded_file, false));
 
         EXPECT_EQ(download_info.should_redirect_to_documents ?
                       std::string::npos :
@@ skipping 58 matching lines @@
     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.url_name;
+      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,
@@ skipping 231 matching lines @@
   DownloadRequestLimiter::TabDownloadState* tab_download_state =
       g_browser_process->download_request_limiter()->GetDownloadState(
           web_contents, web_contents, true);
   ASSERT_TRUE(tab_download_state);
   tab_download_state->set_download_status(
       DownloadRequestLimiter::DOWNLOADS_NOT_ALLOWED);
 
   // Try to start the download via Javascript and wait for the corresponding
   // load stop event.
   content::TestNavigationObserver observer(web_contents);
-  bool download_assempted;
+  bool download_attempted;
   ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
       browser()->tab_strip_model()->GetActiveWebContents(),
       "window.domAutomationController.send(startDownload());",
-      &download_assempted));
-  ASSERT_TRUE(download_assempted);
+      &download_attempted));
+  ASSERT_TRUE(download_attempted);
   observer.Wait();
 
   // Check that we did not download the file.
   base::FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
   base::FilePath file_path(DestinationFile(browser(), file));
   EXPECT_FALSE(base::PathExists(file_path));
 
   // Check state.
   EXPECT_EQ(1, browser()->tab_strip_model()->count());
 
@@ skipping 1007 matching lines @@
   download_items.clear();
   GetDownloads(browser(), &download_items);
   EXPECT_TRUE(DidShowFileChooser());
   ASSERT_EQ(2u, download_items.size());
   ASSERT_EQ(jpeg_url, download_items[0]->GetOriginalUrl());
   ASSERT_EQ(jpeg_url, download_items[1]->GetOriginalUrl());
 }
 
 IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadErrorsServer) {
   DownloadInfo download_info[] = {
-    {  // Normal navigated download.
-      "a_zip_file.zip",
-      DOWNLOAD_NAVIGATE,
-      content::DOWNLOAD_INTERRUPT_REASON_NONE,
-      true,
-      false
-    },
-    {  // Normal direct download.
-      "a_zip_file.zip",
-      DOWNLOAD_DIRECT,
-      content::DOWNLOAD_INTERRUPT_REASON_NONE,
-      true,
-      false
-    },
-    {  // Direct download with 404 error.
-      "there_IS_no_spoon.zip",
-      DOWNLOAD_DIRECT,
-      content::DOWNLOAD_INTERRUPT_REASON_SERVER_BAD_CONTENT,
-      true,
-      false
-    },
-    {  // Navigated download with 404 error.
-      "there_IS_no_spoon.zip",
-      DOWNLOAD_NAVIGATE,
-      content::DOWNLOAD_INTERRUPT_REASON_SERVER_BAD_CONTENT,
-      false,
-      false
-    },
-    {  // Direct download with 400 error.
-      "zip_file_not_found.zip",
-      DOWNLOAD_DIRECT,
-      content::DOWNLOAD_INTERRUPT_REASON_SERVER_FAILED,
-      true,
-      false
-    },
-    {  // Navigated download with 400 error.
-      "zip_file_not_found.zip",
-      DOWNLOAD_NAVIGATE,
-      content::DOWNLOAD_INTERRUPT_REASON_SERVER_FAILED,
-      false,
-      false
-    }
-  };
+      {// Normal navigated download.
+       "a_zip_file.zip", "a_zip_file.zip", DOWNLOAD_NAVIGATE,
+       content::DOWNLOAD_INTERRUPT_REASON_NONE, true, false},
+      {// Normal direct download.
+       "a_zip_file.zip", "a_zip_file.zip", DOWNLOAD_DIRECT,
+       content::DOWNLOAD_INTERRUPT_REASON_NONE, true, false},
+      {// Direct download with 404 error.
+       "there_IS_no_spoon.zip", "there_IS_no_spoon.zip", DOWNLOAD_DIRECT,
+       content::DOWNLOAD_INTERRUPT_REASON_SERVER_BAD_CONTENT, true, false},
+      {// Navigated download with 404 error.
+       "there_IS_no_spoon.zip", "there_IS_no_spoon.zip", DOWNLOAD_NAVIGATE,
+       content::DOWNLOAD_INTERRUPT_REASON_SERVER_BAD_CONTENT, false, false},
+      {// Direct download with 400 error.
+       "zip_file_not_found.zip", "zip_file_not_found.zip", DOWNLOAD_DIRECT,
+       content::DOWNLOAD_INTERRUPT_REASON_SERVER_FAILED, true, false},
+      {// Navigated download with 400 error.
+       "zip_file_not_found.zip", "", DOWNLOAD_NAVIGATE,
+       content::DOWNLOAD_INTERRUPT_REASON_SERVER_FAILED, false, false},
+      {// Simulates clicking on <a href="http://..." download="">. The name does
+       // not resolve. But since this is an explicit download, the download
+       // should appear on the shelf and the error should be indicated.
+       "download-anchor-attrib-name-not-resolved.html",
+       "http://doesnotexist/shouldnotberesolved", DOWNLOAD_NAVIGATE,
+       content::DOWNLOAD_INTERRUPT_REASON_NETWORK_FAILED, true, false},
+      {// Simulates clicking on <a href="http://..." download=""> where the URL
+       // leads to a 404 response. This is different from the previous test case
+       // in that the ResourceLoader issues a OnResponseStarted() callback since
+       // the headers are successfully received.
+       "download-anchor-attrib-404.html", "there_IS_no_spoon.zip",
+       DOWNLOAD_NAVIGATE, content::DOWNLOAD_INTERRUPT_REASON_SERVER_BAD_CONTENT,
+       true, false},
+      {// Similar to the above, but the resulting response contains a status
+       // code of 400.
+       "download-anchor-attrib-400.html", "zip_file_not_found.zip",
+       DOWNLOAD_NAVIGATE, content::DOWNLOAD_INTERRUPT_REASON_SERVER_FAILED,
+       true, false},
+      {// Direct download of a URL where the hostname doesn't resolve.
+       "http://doesnotexist/shouldnotdownloadsuccessfully",
+       "http://doesnotexist/shouldnotdownloadsuccessfully", DOWNLOAD_DIRECT,
+       content::DOWNLOAD_INTERRUPT_REASON_NETWORK_FAILED, true, false}};
 
   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",
-        DOWNLOAD_NAVIGATE,
-        content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE,
-        1
-      },
-      {
-        "",
-        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",
-        DOWNLOAD_DIRECT,
-        content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE,
-        1
-      },
-      {
-        "",
-        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",
-        DOWNLOAD_NAVIGATE,
-        content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE,
-        1
-      },
-      {
-        "",
-        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",
-        DOWNLOAD_DIRECT,
-        content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE,
-        1
-      },
-      {
-        "",
-        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",
-        DOWNLOAD_NAVIGATE,
-        content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
-        1
-      },
-      {
-        "",
-        content::TestFileErrorInjector::FILE_OPERATION_INITIALIZE,
-        0,
-        content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
-      }
-    },
-    {  // Direct download with injected "Failed" error in Initialize().
-      { "a_zip_file.zip",
-        DOWNLOAD_DIRECT,
-        content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
-        1
-      },
-      {
-        "",
-        content::TestFileErrorInjector::FILE_OPERATION_INITIALIZE,
-        0,
-        content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
-      }
-    },
-    {  // Navigated download with injected "Failed" error in Write().
-      { "a_zip_file.zip",
-        DOWNLOAD_NAVIGATE,
-        content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
-        1
-      },
-      {
-        "",
-        content::TestFileErrorInjector::FILE_OPERATION_WRITE,
-        0,
-        content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
-      }
-    },
-    {  // Direct download with injected "Failed" error in Write().
-      { "a_zip_file.zip",
-        DOWNLOAD_DIRECT,
-        content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
-        1
-      },
-      {
-        "",
-        content::TestFileErrorInjector::FILE_OPERATION_WRITE,
-        0,
-        content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
-      }
-    },
-    {  // Navigated download with injected "Name too long" error in
+      {// 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::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::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::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::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::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::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::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::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
+       }},
+      {// Navigated download with injected "Name too long" error in
        // Initialize().
-      { "a_zip_file.zip",
-        DOWNLOAD_NAVIGATE,
-        content::DOWNLOAD_INTERRUPT_REASON_FILE_NAME_TOO_LONG,
-        1
-      },
-      {
-        "",
-        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",
-        DOWNLOAD_DIRECT,
-        content::DOWNLOAD_INTERRUPT_REASON_FILE_NAME_TOO_LONG,
-        1
-      },
-      {
-        "",
-        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",
-        DOWNLOAD_NAVIGATE,
-        content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
-        1
-      },
-      {
-        "",
-        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",
-        DOWNLOAD_DIRECT,
-        content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
-        1
-      },
-      {
-        "",
-        content::TestFileErrorInjector::FILE_OPERATION_WRITE,
-        0,
-        content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
-      }
-    },
-    {  // Direct download with injected "Disk full" error in 2nd Write().
-      { "06bESSE21Evolution.ppt",
-        DOWNLOAD_DIRECT,
-        content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE,
-        1
-      },
-      {
-        "",
-        content::TestFileErrorInjector::FILE_OPERATION_WRITE,
-        1,
-        content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE,
-      }
-    }
-  };
+       {"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::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::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::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::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::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",
-      DOWNLOAD_DIRECT,
-      // This passes because we switch to the My Documents folder.
-      content::DOWNLOAD_INTERRUPT_REASON_NONE,
-      true,
-      true
-    },
-    {
-      "a_zip_file.zip",
-      DOWNLOAD_NAVIGATE,
-      // This passes because we switch to the My Documents folder.
-      content::DOWNLOAD_INTERRUPT_REASON_NONE,
-      true,
-      true
-    }
-  };
+      {"a_zip_file.zip", "a_zip_file.zip", DOWNLOAD_DIRECT,
+       // This passes because we switch to the My Documents folder.
+       content::DOWNLOAD_INTERRUPT_REASON_NONE, true, true},
+      {"a_zip_file.zip", "a_zip_file.zip", DOWNLOAD_NAVIGATE,
+       // This passes because we switch to the My Documents folder.
+       content::DOWNLOAD_INTERRUPT_REASON_NONE, true, true}};
 
   DownloadFilesToReadonlyFolder(arraysize(download_info), download_info);
 }
 
 // Test that we show a dangerous downloads warning for a dangerous file
 // downloaded through a blob: URL.
 IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadDangerousBlobData) {
 #if defined(OS_WIN)
   // On Windows, if SafeBrowsing is enabled, certain file types (.exe, .cab,
   // .msi) will be handled by the DownloadProtectionService. However, if the URL
@@ skipping 1089 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());
 }