Add a browser test for access control for file: scheme

chrome/browser/net/errorpage_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 <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/path_service.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/lock.h"
 #include "base/task_scheduler/post_task.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/browser/browsing_data/browsing_data_helper.h"
 #include "chrome/browser/browsing_data/chrome_browsing_data_remover_delegate.h"
+#include "chrome/browser/net/errorpage_test_util.h"
 #include "chrome/browser/net/net_error_diagnostics_dialog.h"
 #include "chrome/browser/net/url_request_mock_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search_engines/ui_thread_search_terms_data.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.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"
@@ skipping 45 matching lines @@
 #endif
 #include "components/policy/core/common/mock_configuration_policy_provider.h"
 
 using content::BrowserThread;
 using content::NavigationController;
 using net::URLRequestFailedJob;
 using net::URLRequestTestJob;
 
 namespace {
 
-// Returns true if |text| is displayed on the page |browser| is currently
-// displaying.  Uses "innerText", so will miss hidden text, and whitespace
-// space handling may be weird.
-bool WARN_UNUSED_RESULT IsDisplayingText(Browser* browser,
-                                         const std::string& text) {
-  // clang-format off
-  std::string command = base::StringPrintf(R"(
-    function isNodeVisible(node) {
-      if (!node || node.classList.contains('hidden'))
-        return false;
-      if (!node.parentElement)
-        return true;
-      // Otherwise, we must check all parent nodes
-      return isNodeVisible(node.parentElement);
-    }
-    var node = document.evaluate("//*[contains(text(),'%s')]", document,
-      null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;
-    domAutomationController.send(isNodeVisible(node));
-  )", text.c_str());
-  // clang-format on
-  bool result = false;
-  EXPECT_TRUE(content::ExecuteScriptAndExtractBool(
-      browser->tab_strip_model()->GetActiveWebContents(), command, &result));
-  return result;
-}
-
 // Expands the more box on the currently displayed error page.
 void ToggleHelpBox(Browser* browser) {
   EXPECT_TRUE(content::ExecuteScript(
       browser->tab_strip_model()->GetActiveWebContents(),
       "document.getElementById('details-button').click();"));
 }
 
 // Returns true if the diagnostics link suggestion is displayed.
 bool WARN_UNUSED_RESULT IsDisplayingDiagnosticsLink(Browser* browser) {
   std::string command = base::StringPrintf(
       "var diagnose_link = document.getElementById('diagnose-link');"
       "domAutomationController.send(diagnose_link != null);");
   bool result = false;
   EXPECT_TRUE(content::ExecuteScriptAndExtractBool(
       browser->tab_strip_model()->GetActiveWebContents(), command, &result));
   return result;
 }
 
 // Checks that the local error page is being displayed, without remotely
 // retrieved navigation corrections, and with the specified error string.
 void ExpectDisplayingLocalErrorPage(Browser* browser,
                                     const std::string& error_string) {
-  EXPECT_TRUE(IsDisplayingText(browser, error_string));
+  EXPECT_TRUE(errorpage_test_util::IsDisplayingText(browser, error_string));
 
   // Locally generated error pages should not have navigation corrections.
-  EXPECT_FALSE(IsDisplayingText(browser, "http://mock.http/title2.html"));
+  EXPECT_FALSE(errorpage_test_util::IsDisplayingText(
+      browser, "http://mock.http/title2.html"));
 
   // Locally generated error pages should not have a link with search terms.
-  EXPECT_FALSE(IsDisplayingText(browser, "search query"));
+  EXPECT_FALSE(errorpage_test_util::IsDisplayingText(browser, "search query"));
 }
 
 // Checks that the local error page is being displayed, without remotely
 // retrieved navigation corrections, and with the specified error code.
 void ExpectDisplayingLocalErrorPage(Browser* browser, net::Error error_code) {
   ExpectDisplayingLocalErrorPage(browser, net::ErrorToShortString(error_code));
 }
 
 // Checks that an error page with information retrieved from the navigation
 // correction service is being displayed, with the specified specified error
 // string.
 void ExpectDisplayingNavigationCorrections(Browser* browser,
                                            const std::string& error_string) {
-  EXPECT_TRUE(IsDisplayingText(browser, error_string));
+  EXPECT_TRUE(errorpage_test_util::IsDisplayingText(browser, error_string));
 
   // Check that the mock navigation corrections are displayed.
-  EXPECT_TRUE(IsDisplayingText(browser, "http://mock.http/title2.html"));
+  EXPECT_TRUE(errorpage_test_util::IsDisplayingText(
+      browser, "http://mock.http/title2.html"));
 
   // Check that the search terms are displayed as a link.
-  EXPECT_TRUE(IsDisplayingText(browser, "search query"));
+  EXPECT_TRUE(errorpage_test_util::IsDisplayingText(browser, "search query"));
 
   // The diagnostics button isn't displayed when corrections were
   // retrieved from a remote server.
   EXPECT_FALSE(IsDisplayingDiagnosticsLink(browser));
 }
 
 // Checks that an error page with information retrieved from the navigation
 // correction service is being displayed, with the specified specified error
 // code.
 void ExpectDisplayingNavigationCorrections(Browser* browser,
@@ skipping 814 matching lines @@
       browser()->profile()->GetRequestContext();
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::BindOnce(&InterceptNetworkTransactions,
                      base::RetainedRef(url_request_context_getter),
                      net::ERR_FAILED));
 
   // With no navigation corrections to load, there's only one navigation.
   ui_test_utils::NavigateToURL(browser(), test_url);
   EXPECT_TRUE(ProbeStaleCopyValue(true));
-  EXPECT_TRUE(IsDisplayingText(browser(), GetShowSavedButtonLabel()));
+  EXPECT_TRUE(errorpage_test_util::IsDisplayingText(browser(),
+                                                    GetShowSavedButtonLabel()));
   EXPECT_NE(base::ASCIIToUTF16("Nocache Test Page"),
             browser()->tab_strip_model()->GetActiveWebContents()->GetTitle());
 
   // Confirm that loading the stale copy from the cache works.
   content::TestNavigationObserver same_tab_observer(
       browser()->tab_strip_model()->GetActiveWebContents(), 1);
   ASSERT_TRUE(ReloadStaleCopyFromCache());
   same_tab_observer.Wait();
   EXPECT_EQ(base::ASCIIToUTF16("Nocache Test Page"),
             browser()->tab_strip_model()->GetActiveWebContents()->GetTitle());
 
   // Reload the same URL with a post request; confirm the error page is told
   // that there is no cached copy.
   ui_test_utils::NavigateToURLWithPost(browser(), test_url);
   EXPECT_TRUE(ProbeStaleCopyValue(false));
-  EXPECT_FALSE(IsDisplayingText(browser(), GetShowSavedButtonLabel()));
+  EXPECT_FALSE(errorpage_test_util::IsDisplayingText(
+      browser(), GetShowSavedButtonLabel()));
   EXPECT_EQ(0, link_doctor_interceptor()->num_requests());
 
   // Clear the cache and reload the same URL; confirm the error page is told
   // that there is no cached copy.
   content::BrowsingDataRemover* remover =
       content::BrowserContext::GetBrowsingDataRemover(browser()->profile());
   remover->Remove(base::Time(), base::Time::Max(),
                   content::BrowsingDataRemover::DATA_TYPE_CACHE,
                   content::BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB);
   ui_test_utils::NavigateToURL(browser(), test_url);
   EXPECT_TRUE(ProbeStaleCopyValue(false));
-  EXPECT_FALSE(IsDisplayingText(browser(), GetShowSavedButtonLabel()));
+  EXPECT_FALSE(errorpage_test_util::IsDisplayingText(
+      browser(), GetShowSavedButtonLabel()));
   EXPECT_EQ(0, link_doctor_interceptor()->num_requests());
 }
 
 // Check that the easter egg is present and initialised and is not disabled.
 IN_PROC_BROWSER_TEST_F(ErrorPageTest, CheckEasterEggIsNotDisabled) {
   ui_test_utils::NavigateToURL(browser(),
       URLRequestFailedJob::GetMockHttpUrl(net::ERR_INTERNET_DISCONNECTED));
 
   content::WebContents* web_contents =
       browser()->tab_strip_model()->GetActiveWebContents();
@@ skipping 83 matching lines @@
   GURL test_url("http://error.page.auto.reload");
   const int kRequestsToFail = 3;
   InstallInterceptor(test_url, kRequestsToFail);
   ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(
       browser(), test_url, 2);
 
   EXPECT_EQ(2, interceptor()->failures());
   EXPECT_EQ(2, interceptor()->requests());
 
   ToggleHelpBox(browser());
-  EXPECT_TRUE(IsDisplayingText(
+  EXPECT_TRUE(errorpage_test_util::IsDisplayingText(
       browser(), l10n_util::GetStringUTF8(
                      IDS_ERRORPAGES_SUGGESTION_CHECK_CONNECTION_HEADER)));
 
   content::WebContents* web_contents =
     browser()->tab_strip_model()->GetActiveWebContents();
   content::TestNavigationObserver nav_observer(web_contents, 1);
   web_contents->GetMainFrame()->ExecuteJavaScriptForTests(
       base::ASCIIToUTF16("document.getElementById('reload-button').click();"));
   nav_observer.Wait();
-  EXPECT_FALSE(IsDisplayingText(
+  EXPECT_FALSE(errorpage_test_util::IsDisplayingText(
       browser(), l10n_util::GetStringUTF8(
                      IDS_ERRORPAGES_SUGGESTION_CHECK_CONNECTION_HEADER)));
 }
 
 // Make sure that a same document navigation does not cause issues with the
 // auto-reload timer.  Note that this test was added due to this case causing
 // a crash.  On regression, this test may hang due to a crashed renderer.
 IN_PROC_BROWSER_TEST_F(ErrorPageAutoReloadTest, IgnoresSameDocumentNavigation) {
   GURL test_url("http://error.page.auto.reload");
   InstallInterceptor(test_url, 2);
@@ skipping 119 matching lines @@
   scoped_refptr<net::URLRequestContextGetter> url_request_context_getter =
       browser()->profile()->GetRequestContext();
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::BindOnce(&InterceptNetworkTransactions,
                      base::RetainedRef(url_request_context_getter),
                      net::ERR_CONNECTION_FAILED));
 
   ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(
       browser(), test_url, 2);
-  EXPECT_TRUE(IsDisplayingText(browser(), GetShowSavedButtonLabel()));
+  EXPECT_TRUE(errorpage_test_util::IsDisplayingText(browser(),
+                                                    GetShowSavedButtonLabel()));
   EXPECT_TRUE(ProbeStaleCopyValue(true));
 
   // Confirm that loading the stale copy from the cache works.
   content::TestNavigationObserver same_tab_observer(
       browser()->tab_strip_model()->GetActiveWebContents(), 1);
   ASSERT_TRUE(ReloadStaleCopyFromCache());
   same_tab_observer.Wait();
   EXPECT_EQ(base::ASCIIToUTF16("Nocache Test Page"),
             browser()->tab_strip_model()->GetActiveWebContents()->GetTitle());
 
   // Clear the cache and reload the same URL; confirm the error page is told
   // that there is no cached copy.
   content::BrowsingDataRemover* remover =
       content::BrowserContext::GetBrowsingDataRemover(browser()->profile());
   remover->Remove(base::Time(), base::Time::Max(),
                   content::BrowsingDataRemover::DATA_TYPE_CACHE,
                   content::BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB);
   ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(
       browser(), test_url, 2);
   EXPECT_TRUE(ProbeStaleCopyValue(false));
-  EXPECT_FALSE(IsDisplayingText(browser(), GetShowSavedButtonLabel()));
+  EXPECT_FALSE(errorpage_test_util::IsDisplayingText(
+      browser(), GetShowSavedButtonLabel()));
 }
 
 class ErrorPageOfflineTest : public ErrorPageTest {
  protected:
 
   void SetUpInProcessBrowserTestFixture() override {
 #if defined(OS_CHROMEOS)
     if (enroll_) {
       // Set up fake install attributes.
       std::unique_ptr<chromeos::StubInstallAttributes> attributes =
@@ skipping 182 matching lines @@
     "\\u043f\\u0440\\u0435\\u0437\\u0438\\u0434\\u0435\\u043d\\u0442."
     "\\u0440\\u0444";
 
 // Make sure error page shows correct unicode for IDN.
 IN_PROC_BROWSER_TEST_F(ErrorPageForIDNTest, IDN) {
   // ERR_UNSAFE_PORT will not trigger navigation corrections.
   ui_test_utils::NavigateToURL(
       browser(),
       URLRequestFailedJob::GetMockHttpUrlForHostname(net::ERR_UNSAFE_PORT,
                                                      kHostname));
-  EXPECT_TRUE(IsDisplayingText(browser(), kHostnameJSUnicode));
+  EXPECT_TRUE(
+      errorpage_test_util::IsDisplayingText(browser(), kHostnameJSUnicode));
 }
 
 // Make sure HTTP/0.9 is disabled on non-default ports by default.
 IN_PROC_BROWSER_TEST_F(ErrorPageTest, Http09WeirdPort) {
   ASSERT_TRUE(embedded_test_server()->Start());
   ui_test_utils::NavigateToURL(
       browser(), embedded_test_server()->GetURL("/echo-raw?spam"));
   ExpectDisplayingLocalErrorPage(browser(), net::ERR_INVALID_HTTP_RESPONSE);
 }
 
@@ skipping 20 matching lines @@
 };
 
 // Make sure HTTP/0.9 works on non-default ports when enabled by policy.
 IN_PROC_BROWSER_TEST_F(ErrorPageWithHttp09OnNonDefaultPortsTest,
                        Http09WeirdPortEnabled) {
   const char kHttp09Response[] = "JumboShrimp";
   ASSERT_TRUE(embedded_test_server()->Start());
   ui_test_utils::NavigateToURL(
       browser(), embedded_test_server()->GetURL(std::string("/echo-raw?") +
                                                 kHttp09Response));
-  EXPECT_TRUE(IsDisplayingText(browser(), kHttp09Response));
+  EXPECT_TRUE(
+      errorpage_test_util::IsDisplayingText(browser(), kHttp09Response));
 }
 
 }  // namespace