Test for auth dialog appearing during save-page-as.

chrome/browser/download/save_page_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 <stddef.h>
 #include <stdint.h>
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 15 matching lines @@
 #include "chrome/browser/download/download_history.h"
 #include "chrome/browser/download/download_prefs.h"
 #include "chrome/browser/download/download_service.h"
 #include "chrome/browser/download/download_service_factory.h"
 #include "chrome/browser/download/save_package_file_picker.h"
 #include "chrome/browser/net/url_request_mock_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/browser_window.h"
+#include "chrome/browser/ui/login/login_handler.h"
+#include "chrome/browser/ui/login/login_handler_test_utils.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "components/history/core/browser/download_constants.h"
 #include "components/history/core/browser/download_row.h"
 #include "components/prefs/pref_member.h"
 #include "components/prefs/pref_service.h"
 #include "content/public/browser/download_item.h"
 #include "content/public/browser/download_manager.h"
+#include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_switches.h"
+#include "content/public/common/referrer.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/test/browser_test_utils.h"
+#include "content/public/test/test_navigation_observer.h"
 #include "content/public/test/test_utils.h"
 #include "net/base/filename_util.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "net/test/url_request/url_request_mock_http_job.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::BrowserContext;
 using content::BrowserThread;
@@ skipping 910 matching lines @@
   EXPECT_TRUE(base::DirectoryExists(dir));
   EXPECT_TRUE(base::PathExists(full_file_name));
 }
 
 // Test suite that verifies that the frame tree "looks" the same before
 // and after a save-page-as.
 class SavePageOriginalVsSavedComparisonTest
     : public SavePageSitePerProcessBrowserTest,
       public ::testing::WithParamInterface<content::SavePageType> {
  protected:
-  void TestOriginalVsSavedPage(
+  void TestCurrentVsSavedPage(
       content::SavePageType save_page_type,
-      const GURL& url,
       int expected_number_of_frames,
       const std::vector<std::string>& expected_substrings) {
-    // Navigate to the test page and verify if test expectations
-    // are met (this is mostly a sanity check - a failure to meet
-    // expectations would probably mean that there is a test bug
-    // (i.e. that we got called with wrong expected_foo argument).
-    ui_test_utils::NavigateToURL(browser(), url);
+    // Verify if test expectations are met on the current page (this is mostly
+    // a sanity check - a failure to meet expectations would probably mean that
+    // there is a test bug (i.e. that we got called with wrong expected_foo
+    // argument).
+    GURL original_url = GetCurrentTab(browser())->GetLastCommittedURL();
     DLOG(INFO) << "Verifying test expectations for original page... : "
-               << GetCurrentTab(browser())->GetLastCommittedURL();
+               << original_url;
     AssertExpectationsAboutCurrentTab(expected_number_of_frames,
                                       expected_substrings);
 
     // Save the page.
     base::FilePath full_file_name, dir;
-    SaveCurrentTab(url, save_page_type, "save_result", -1, &dir,
+    SaveCurrentTab(original_url, save_page_type, "save_result", -1, &dir,
                    &full_file_name);
     ASSERT_FALSE(HasFailure());
 
     // Stop the test server (to make sure the locally saved page
     // is self-contained / won't try to open original resources).
     ASSERT_TRUE(embedded_test_server()->ShutdownAndWaitUntilComplete());
 
     // Open the saved page and verify if test expectations are
     // met (i.e. if the same expectations are met for "after"
     // [saved version of the page] as for the "before"
@@ skipping 63 matching lines @@
   std::string arr[] = {
       "frames-xsite.htm: 896fd88d-a77a-4f46-afd8-24db7d5af9c2",
       "a.htm: 1b8aae2b-e164-462f-bd5b-98aa366205f2",
       "b.htm: 3a35f7fa-96a9-4487-9f18-4470263907fa",
   };
   std::vector<std::string> expected_substrings(std::begin(arr), std::end(arr));
 
   GURL url(
       embedded_test_server()->GetURL("a.com", "/save_page/frames-xsite.htm"));
 
-  TestOriginalVsSavedPage(save_page_type, url, 3, expected_substrings);
+  ui_test_utils::NavigateToURL(browser(), url);
+  TestCurrentVsSavedPage(save_page_type, 3, expected_substrings);
 }
 
 // Test compares original-vs-saved for a page with <object> elements.
 // (see crbug.com/553478).
 IN_PROC_BROWSER_TEST_P(SavePageOriginalVsSavedComparisonTest, ObjectElements) {
   content::SavePageType save_page_type = GetParam();
 
   // 4 = main frame + iframe + object w/ html doc + object w/ pdf doc
   // (svg and png objects do not get a separate frame)
   int expected_number_of_frames = 6;
 
   std::string arr[] = {
       "frames-objects.htm: 8da13db4-a512-4d9b-b1c5-dc1c134234b9",
       "a.htm: 1b8aae2b-e164-462f-bd5b-98aa366205f2",
       "b.htm: 3a35f7fa-96a9-4487-9f18-4470263907fa",
       "frames-nested.htm: 4388232f-8d45-4d2e-9807-721b381be153",
       "frames-nested2.htm: 6d23dc47-f283-4977-96ec-66bcf72301a4",
   };
   std::vector<std::string> expected_substrings(std::begin(arr), std::end(arr));
 
-  GURL url(
-      embedded_test_server()->GetURL("a.com", "/save_page/frames-objects.htm"));
-
   // TODO(lukasza): crbug.com/553478: Enable <object> testing of MHTML.
   if (save_page_type == content::SAVE_PAGE_TYPE_AS_MHTML)
     return;
 
-  TestOriginalVsSavedPage(save_page_type, url, expected_number_of_frames,
-                          expected_substrings);
+  GURL url(
+      embedded_test_server()->GetURL("a.com", "/save_page/frames-objects.htm"));
+  ui_test_utils::NavigateToURL(browser(), url);
+  TestCurrentVsSavedPage(save_page_type, expected_number_of_frames,
+                         expected_substrings);
 }
 
 // Test compares original-vs-saved for a page with frames at about:blank uri.
 // This tests handling of iframe elements without src attribute (only with
 // srcdoc attribute) and how they get saved / cross-referenced.
 IN_PROC_BROWSER_TEST_P(SavePageOriginalVsSavedComparisonTest, AboutBlank) {
   content::SavePageType save_page_type = GetParam();
 
   std::string arr[] = {
       "main: acb0609d-eb10-4c26-83e2-ad8afb7b0ff3",
       "sub1: b124df3a-d39f-47a1-ae04-5bb5d0bf549e",
       "sub2: 07014068-604d-45ae-884f-a068cfe7bc0a",
       "sub3: 06cc8fcc-c692-4a1a-a10f-1645b746e8f4",
   };
   std::vector<std::string> expected_substrings(std::begin(arr), std::end(arr));
 
   GURL url(embedded_test_server()->GetURL("a.com",
                                           "/save_page/frames-about-blank.htm"));
-
-  TestOriginalVsSavedPage(save_page_type, url, 4, expected_substrings);
+  ui_test_utils::NavigateToURL(browser(), url);
+  TestCurrentVsSavedPage(save_page_type, 4, expected_substrings);
 }
 
 // Test compares original-vs-saved for a page with nested frames.
 // Two levels of nesting are especially good for verifying correct
 // link rewriting for subframes-vs-main-frame (see crbug.com/554666).
 IN_PROC_BROWSER_TEST_P(SavePageOriginalVsSavedComparisonTest, NestedFrames) {
   content::SavePageType save_page_type = GetParam();
 
   std::string arr[] = {
       "frames-nested.htm: 4388232f-8d45-4d2e-9807-721b381be153",
       "frames-nested2.htm: 6d23dc47-f283-4977-96ec-66bcf72301a4",
       "b.htm: 3a35f7fa-96a9-4487-9f18-4470263907fa",
   };
   std::vector<std::string> expected_substrings(std::begin(arr), std::end(arr));
 
   GURL url(
       embedded_test_server()->GetURL("a.com", "/save_page/frames-nested.htm"));
-
-  TestOriginalVsSavedPage(save_page_type, url, 3, expected_substrings);
+  ui_test_utils::NavigateToURL(browser(), url);
+  TestCurrentVsSavedPage(save_page_type, 3, expected_substrings);
 }
 
 // Test for crbug.com/106364 and crbug.com/538188.
 // Test frames have the same uri ...
 //   subframe1 and subframe2 - both have src=b.htm
 //   subframe3 and subframe4 - about:blank (no src, only srcdoc attribute).
 // ... but different content (generated by main frame's javascript).
 IN_PROC_BROWSER_TEST_P(SavePageOriginalVsSavedComparisonTest, RuntimeChanges) {
   content::SavePageType save_page_type = GetParam();
 
   std::string arr[] = {
       "frames-runtime-changes.htm: 4388232f-8d45-4d2e-9807-721b381be153",
       "subframe1: 21595339-61fc-4854-b6df-0668328ea263",
       "subframe2: adf55719-15e7-45be-9eda-d12fe782a1bd",
       "subframe3: 50e294bf-3a5b-499d-8772-651ead26952f",
       "subframe4: e0ea9289-7467-4d32-ba5c-c604e8d84cb7",
   };
   std::vector<std::string> expected_substrings(std::begin(arr), std::end(arr));
 
   GURL url(embedded_test_server()->GetURL(
       "a.com", "/save_page/frames-runtime-changes.htm?do_runtime_changes=1"));
-
-  TestOriginalVsSavedPage(save_page_type, url, 5, expected_substrings);
+  ui_test_utils::NavigateToURL(browser(), url);
+  TestCurrentVsSavedPage(save_page_type, 5, expected_substrings);
 }
 
 // Test for saving frames with various encodings:
 // - iso-8859-2: encoding declared via <meta> element
 // - utf16-le-bom.htm, utf16-be-bom.htm: encoding detected via BOM
 // - utf16-le-nobom.htm, utf16-le-nobom.htm, utf32.htm - encoding declared via
 //                                                       mocked http headers
 IN_PROC_BROWSER_TEST_P(SavePageOriginalVsSavedComparisonTest, Encoding) {
   content::SavePageType save_page_type = GetParam();
 
   std::string arr[] = {
       "frames-encodings.htm: f53295dd-a95b-4b32-85f5-b6e15377fb20",
       "iso-8859-2.htm: Za\xc5\xbc\xc3\xb3\xc5\x82\xc4\x87 "
           "g\xc4\x99\xc5\x9bl\xc4\x85 ja\xc5\xba\xc5\x84",
       "utf16-le-nobom.htm: Za\xc5\xbc\xc3\xb3\xc5\x82\xc4\x87 "
           "g\xc4\x99\xc5\x9bl\xc4\x85 ja\xc5\xba\xc5\x84",
       "utf16-le-bom.htm: Za\xc5\xbc\xc3\xb3\xc5\x82\xc4\x87 "
           "g\xc4\x99\xc5\x9bl\xc4\x85 ja\xc5\xba\xc5\x84",
       "utf16-be-nobom.htm: Za\xc5\xbc\xc3\xb3\xc5\x82\xc4\x87 "
           "g\xc4\x99\xc5\x9bl\xc4\x85 ja\xc5\xba\xc5\x84",
       "utf16-be-bom.htm: Za\xc5\xbc\xc3\xb3\xc5\x82\xc4\x87 "
           "g\xc4\x99\xc5\x9bl\xc4\x85 ja\xc5\xba\xc5\x84",
       "utf32.htm: Za\xc5\xbc\xc3\xb3\xc5\x82\xc4\x87 "
           "g\xc4\x99\xc5\x9bl\xc4\x85 ja\xc5\xba\xc5\x84",
   };
   std::vector<std::string> expected_substrings(std::begin(arr), std::end(arr));
 
-  GURL url(embedded_test_server()->GetURL("a.com",
-                                          "/save_page/frames-encodings.htm"));
-
   // TODO(lukasza): crbug.com/541699: MHTML needs to handle multi-byte encodings
   // by either:
   // 1. Continuing to preserve the original encoding, but starting to round-trip
   //    the encoding declaration (in Content-Type MIME/MHTML header?)
   // 2. Saving html docs in UTF8.
   // 3. Saving the BOM (not sure if this will help for all cases though).
   if (save_page_type == content::SAVE_PAGE_TYPE_AS_MHTML)
     return;
 
-  TestOriginalVsSavedPage(save_page_type, url, 7, expected_substrings);
+  GURL url(embedded_test_server()->GetURL("a.com",
+                                          "/save_page/frames-encodings.htm"));
+  ui_test_utils::NavigateToURL(browser(), url);
+  TestCurrentVsSavedPage(save_page_type, 7, expected_substrings);
 }
 
 // Test for saving style element and attribute (see also crbug.com/568293).
 IN_PROC_BROWSER_TEST_P(SavePageOriginalVsSavedComparisonTest, Style) {
   content::SavePageType save_page_type = GetParam();
 
   std::string arr[] = {
       "style.htm: af84c3ca-0fc6-4b0d-bf7a-5ac18a4dab62",
       "frameE: c9539ccd-47b0-47cf-a03b-734614865872",
   };
   std::vector<std::string> expected_substrings(std::begin(arr), std::end(arr));
 
   GURL url(embedded_test_server()->GetURL("a.com", "/save_page/style.htm"));
-
-  TestOriginalVsSavedPage(save_page_type, url, 6, expected_substrings);
+  ui_test_utils::NavigateToURL(browser(), url);
+  TestCurrentVsSavedPage(save_page_type, 6, expected_substrings);
 }
 
 // Test for saving a page with broken subresources:
 // - Broken, undecodable image (see also https://crbug.com/586680)
 // - Broken link, to unresolvable host (see also https://crbug.com/594219)
+// - Resource requiring authentication
 IN_PROC_BROWSER_TEST_P(SavePageOriginalVsSavedComparisonTest, BrokenImage) {
   // Clear resolver rules to make sure that *.no.such.host used in the test html
   // doesn't resolve to 127.0.0.1
   host_resolver()->ClearRules();
 
   content::SavePageType save_page_type = GetParam();
 
   std::string arr[] = {
       "broken-image.htm: 1e846775-b3ed-4d9c-a124-029554a1eb9d",
   };
   std::vector<std::string> expected_substrings(std::begin(arr), std::end(arr));
 
+  // Navigate to the test URL and dismiss the auth dialog.
   GURL url(embedded_test_server()->GetURL("127.0.0.1",
                                           "/save_page/broken-image.htm"));
+  content::WebContents* web_contents =
+      browser()->tab_strip_model()->GetActiveWebContents();
+  content::TestNavigationObserver navigation_observer(web_contents, 1);
+  content::NavigationController* navigation_controller =
+      &web_contents->GetController();
+  LoginPromptBrowserTestObserver login_observer;
+  login_observer.Register(
+      content::Source<content::NavigationController>(navigation_controller));
+  WindowedAuthNeededObserver auth_needed_waiter(navigation_controller);
+  web_contents->OpenURL(content::OpenURLParams(
+      url, content::Referrer(), CURRENT_TAB, ui::PAGE_TRANSITION_TYPED, false));
+  auth_needed_waiter.Wait();
+  ASSERT_EQ(1u, login_observer.handlers().size());
+  login_observer.handlers().front()->CancelAuth();
+  navigation_observer.Wait();
 
-  TestOriginalVsSavedPage(save_page_type, url, 1, expected_substrings);
+  TestCurrentVsSavedPage(save_page_type, 1, expected_substrings);
 }
 
 INSTANTIATE_TEST_CASE_P(
     SaveType,
     SavePageOriginalVsSavedComparisonTest,
     ::testing::Values(content::SAVE_PAGE_TYPE_AS_COMPLETE_HTML,
                       content::SAVE_PAGE_TYPE_AS_MHTML));
 
 }  // namespace