[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 <sstream>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
@@ skipping 408 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.
+    const char* starting_url;           // URL for initiating the download.
+    const char* expected_download_url;  // Expected value of DI::GetURL().
     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 400 matching lines @@
     ASSERT_TRUE(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) {
-    std::stringstream s;
-    s << " " << __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 = "files/downloads/";
-    server_path += download_info.url_name;
-    GURL url = test_server()->GetURL(server_path);
-    ASSERT_TRUE(url.is_valid()) << s.str();
+    // 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 = test_server()->GetURL("files/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) << s.str();
+    ASSERT_TRUE(web_contents);
 
     scoped_ptr<content::DownloadTestObserver> observer(
         new content::DownloadTestObserverTerminal(
             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(params.Pass());
 
       // Wait until the item is created, or we have determined that it
       // won't be.
       creation_observer->WaitForDownloadItemCreation();
 
-      EXPECT_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::NavigateToURLBlockUntilNavigationsComplete(browser(),
-                                                                url,
-                                                                1);
+      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()) << s.str();
+    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()) << s.str();
-
-      ASSERT_EQ(download_info.reason, item->GetLastReason()) << s.str();
+      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 = "files/downloads/";
-      server_path += info[i].download_info.url_name;
+      server_path += info[i].download_info.starting_url;
       GURL url = 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 229 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());
   EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
@@ skipping 1122 matching lines @@
   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",
+      "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_UNSAFE(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",
+        "a_zip_file.zip",
         DOWNLOAD_NAVIGATE,
         content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE,
-        1
+        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",
+        "a_zip_file.zip",
         DOWNLOAD_DIRECT,
         content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE,
-        1
+        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",
+        "a_zip_file.zip",
         DOWNLOAD_NAVIGATE,
         content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE,
-        1
+        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",
+        "a_zip_file.zip",
         DOWNLOAD_DIRECT,
         content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE,
-        1
+        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",
+        "a_zip_file.zip",
         DOWNLOAD_NAVIGATE,
         content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
-        1
+        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",
+        "a_zip_file.zip",
         DOWNLOAD_DIRECT,
         content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
-        1
+        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",
+        "a_zip_file.zip",
         DOWNLOAD_NAVIGATE,
         content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
-        1
+        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",
+        "a_zip_file.zip",
         DOWNLOAD_DIRECT,
         content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
-        1
+        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",
+      {
+        "a_zip_file.zip",
+        "a_zip_file.zip",
         DOWNLOAD_NAVIGATE,
         content::DOWNLOAD_INTERRUPT_REASON_FILE_NAME_TOO_LONG,
-        1
+        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",
+        "a_zip_file.zip",
         DOWNLOAD_DIRECT,
         content::DOWNLOAD_INTERRUPT_REASON_FILE_NAME_TOO_LONG,
-        1
+        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",
+        "a_zip_file.zip",
         DOWNLOAD_NAVIGATE,
         content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
-        1
+        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",
+        "a_zip_file.zip",
         DOWNLOAD_DIRECT,
         content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
-        1
+        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",
+        "06bESSE21Evolution.ppt",
         DOWNLOAD_DIRECT,
         content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE,
-        1
+        true,
+        false
       },
       {
         "",
         content::TestFileErrorInjector::FILE_OPERATION_WRITE,
         1,
         content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE,
       }
     }
   };
 
   DownloadInsertFilesErrorCheckErrors(ARRAYSIZE_UNSAFE(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.
       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_UNSAFE(download_info), download_info);
 }
@@ skipping 561 matching lines @@
 
   // 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());
 }