NoState Prefetch: nostate prefetch browser tests.

chrome/browser/prerender/prerender_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 <deque>
 #include <set>
 #include <string>
 #include <unordered_map>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/weak_ptr.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/scoped_observer.h"
 #include "base/stl_util.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
-#include "base/test/histogram_tester.h"
 #include "base/test/test_timeouts.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/browser/browsing_data/browsing_data_helper.h"
 #include "chrome/browser/browsing_data/browsing_data_remover.h"
 #include "chrome/browser/browsing_data/browsing_data_remover_factory.h"
 #include "chrome/browser/browsing_data/browsing_data_remover_test_util.h"
 #include "chrome/browser/chrome_content_browser_client.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/content_settings/host_content_settings_map_factory.h"
@@ skipping 18 matching lines @@
 #include "chrome/browser/task_manager/task_manager_browsertest_util.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/location_bar/location_bar.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/tabs/tab_strip_model_observer.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
-#include "chrome/grit/generated_resources.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "components/favicon/content/content_favicon_driver.h"
 #include "components/favicon/core/favicon_driver_observer.h"
 #include "components/omnibox/browser/omnibox_edit_model.h"
 #include "components/omnibox/browser/omnibox_popup_model.h"
 #include "components/omnibox/browser/omnibox_view.h"
 #include "components/safe_browsing_db/database_manager.h"
 #include "components/safe_browsing_db/util.h"
 #include "components/variations/entropy_provider.h"
@@ skipping 29 matching lines @@
 #include "net/test/cert_test_util.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "net/test/embedded_test_server/request_handler_util.h"
 #include "net/test/test_data_directory.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_filter.h"
 #include "net/url_request/url_request_job.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "ui/base/l10n/l10n_util.h"
 #include "url/gurl.h"
 
 using chrome_browser_net::NetworkPredictionOptions;
 using content::BrowserThread;
 using content::DevToolsAgentHost;
 using content::NavigationController;
 using content::OpenURLParams;
 using content::Referrer;
 using content::RenderFrameHost;
 using content::RenderViewHost;
@@ skipping 598 matching lines @@
     chrome::GoBack(current_browser(), WindowOpenDisposition::CURRENT_TAB);
     back_nav_observer.Wait();
     bool js_result;
     ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
         tab,
         "window.domAutomationController.send(DidBackToOriginalPagePass())",
         &js_result));
     EXPECT_TRUE(js_result);
   }
 
-  void UseHttpsSrcServer() {
-    if (https_src_server_)
-      return;
-    https_src_server_.reset(
-        new net::EmbeddedTestServer(net::EmbeddedTestServer::TYPE_HTTPS));
-    https_src_server_->ServeFilesFromSourceDirectory("chrome/test/data");
-    CHECK(https_src_server_->Start());
-  }
-
   void DisableJavascriptCalls() {
     call_javascript_ = false;
   }
 
   void DisableLoadEventCheck() {
     check_load_events_ = false;
   }
 
   const PrerenderLinkManager* GetPrerenderLinkManager() const {
     PrerenderLinkManager* prerender_link_manager =
@@ skipping 78 matching lines @@
     std::unique_ptr<base::DictionaryValue> prerender_dict =
         GetPrerenderManager()->GetAsValue();
     if (!prerender_dict)
       return std::numeric_limits<size_t>::max();
     base::ListValue* history_list;
     if (!prerender_dict->GetList("history", &history_list))
       return std::numeric_limits<size_t>::max();
     return history_list->GetSize();
   }
 
-  test_utils::FakeSafeBrowsingDatabaseManager*
-  GetFakeSafeBrowsingDatabaseManager() {
-    return static_cast<test_utils::FakeSafeBrowsingDatabaseManager*>(
-        safe_browsing_factory()
-            ->test_safe_browsing_service()
-            ->database_manager()
-            .get());
-  }
-
   void SetLoaderHostOverride(const std::string& host) {
     loader_host_override_ = host;
     host_resolver()->AddRule(host, "127.0.0.1");
   }
 
   void set_loader_path(const std::string& path) {
     loader_path_ = path;
   }
 
   void set_loader_query(const std::string& query) {
@@ skipping 40 matching lines @@
   }
 
   void AddPrerender(const GURL& url, int index) {
     std::string javascript = base::StringPrintf(
         "AddPrerender('%s', %d)", url.spec().c_str(), index);
     RenderFrameHost* render_frame_host = GetActiveWebContents()->GetMainFrame();
     render_frame_host->ExecuteJavaScriptForTests(
         base::ASCIIToUTF16(javascript));
   }
 
-  // Returns a string for pattern-matching TaskManager tab entries.
-  base::string16 MatchTaskManagerTab(const char* page_title) {
-    return l10n_util::GetStringFUTF16(IDS_TASK_MANAGER_TAB_PREFIX,
-                                      base::ASCIIToUTF16(page_title));
-  }
-
-  // Returns a string for pattern-matching TaskManager prerender entries.
-  base::string16 MatchTaskManagerPrerender(const char* page_title) {
-    return l10n_util::GetStringFUTF16(IDS_TASK_MANAGER_PRERENDER_PREFIX,
-                                      base::ASCIIToUTF16(page_title));
-  }
-
-  const base::HistogramTester& histogram_tester() { return histogram_tester_; }
-
  private:
   // TODO(davidben): Remove this altogether so the tests don't globally assume
   // only one prerender.
   TestPrerenderContents* GetPrerenderContents() const {
     return GetPrerenderContentsFor(dest_url_);
   }
 
   ScopedVector<TestPrerender> PrerenderTestURLImpl(
       const GURL& prerender_url,
       const std::vector<FinalStatus>& expected_final_status_queue,
       int expected_number_of_loads) override {
     dest_url_ = prerender_url;
 
     base::StringPairs replacement_text;
     replacement_text.push_back(
         make_pair("REPLACE_WITH_PRERENDER_URL", prerender_url.spec()));
     std::string replacement_path;
     net::test_server::GetFilePathWithReplacements(
         loader_path_, replacement_text, &replacement_path);
 
-    const net::EmbeddedTestServer* src_server = embedded_test_server();
-    if (https_src_server_)
-      src_server = https_src_server_.get();
-    GURL loader_url = src_server->GetURL(
-        replacement_path + "&" + loader_query_);
+    GURL loader_url =
+        src_server()->GetURL(replacement_path + "&" + loader_query_);
 
     GURL::Replacements loader_replacements;
     if (!loader_host_override_.empty())
       loader_replacements.SetHostStr(loader_host_override_);
     loader_url = loader_url.ReplaceComponents(loader_replacements);
 
-    CHECK(!expected_final_status_queue.empty());
-    ScopedVector<TestPrerender> prerenders;
-    for (size_t i = 0; i < expected_final_status_queue.size(); i++) {
-      prerenders.push_back(
-          prerender_contents_factory()
-              ->ExpectPrerenderContents(expected_final_status_queue[i])
-              .release());
-    }
+    ScopedVector<TestPrerender> prerenders = NavigateWithPrerenders(
+        loader_url, expected_final_status_queue, expected_number_of_loads);
 
     FinalStatus expected_final_status = expected_final_status_queue.front();
-
-    // Navigate to the loader URL and then wait for the first prerender to be
-    // created.
-    ui_test_utils::NavigateToURL(current_browser(), loader_url);
-    prerenders[0]->WaitForCreate();
-    prerenders[0]->WaitForLoads(expected_number_of_loads);
-
     if (ShouldAbortPrerenderBeforeSwap(expected_final_status)) {
       // The prerender will abort on its own. Assert it does so correctly.
       prerenders[0]->WaitForStop();
       EXPECT_FALSE(prerenders[0]->contents());
       EXPECT_TRUE(DidReceivePrerenderStopEventForLinkNumber(0));
     } else {
       // Otherwise, check that it prerendered correctly.
       TestPrerenderContents* prerender_contents = prerenders[0]->contents();
       CHECK(prerender_contents);
       EXPECT_EQ(FINAL_STATUS_MAX, prerender_contents->final_status());
@@ skipping 65 matching lines @@
     } else {
       NavigationOrSwapObserver observer(current_browser()->tab_strip_model(),
                                         web_contents);
       render_frame_host->ExecuteJavaScriptForTests(
           base::ASCIIToUTF16(javascript));
       observer.Wait();
     }
   }
 
   GURL dest_url_;
-  std::unique_ptr<net::EmbeddedTestServer> https_src_server_;
   bool call_javascript_;
   bool check_load_events_;
   std::string loader_host_override_;
   std::string loader_path_;
   std::string loader_query_;
-  base::HistogramTester histogram_tester_;
 };
 
 // Checks that a page is correctly prerendered in the case of a
 // <link rel=prerender> tag and then loaded into a tab in response to a
 // navigation.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPage) {
   PrerenderTestURL("/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
   EXPECT_EQ(1, GetPrerenderDomContentLoadedEventCountForLinkNumber(0));
   histogram_tester().ExpectTotalCount("Prerender.none_PerceivedPLT", 1);
   histogram_tester().ExpectTotalCount("Prerender.none_PerceivedPLTMatched", 0);
@@ skipping 578 matching lines @@
 
 // Checks that the referrer is set when prerendering.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderReferrer) {
   PrerenderTestURL("/prerender/prerender_referrer.html", FINAL_STATUS_USED, 1);
   NavigateToDestURL();
 }
 
 // Checks that the referrer is not set when prerendering and the source page is
 // HTTPS.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderNoSSLReferrer) {

[pasko, 2016/09/22 18:14:04]

nit: fits one line

[mattcary, 2016/09/23 09:00:15]

Done. Strange that git cl format didn't catch that. Oh, I bet this wasn't
actually in my CL, so git didn't touch it. Anyway, fixed now.

   UseHttpsSrcServer();
-  PrerenderTestURL("/prerender/prerender_no_referrer.html", FINAL_STATUS_USED,
-                   1);
+  // Use non-https url for first page.

[pasko, 2016/09/22 18:14:04]

I am confused. Is this comment applying to the line below it? Does it say
something extra on top of the test description? The latter is just 3-4 lines
above...

[mattcary, 2016/09/23 09:00:15]

The test description says that the source page is HTTPS. This is clarifying that
the first prerendered page is *not* https, which is why we have to create the
URL directly rather than just
 PrerenderTestUrl("/prerender/prerender_no_referrer.html", ...)

[pasko, 2016/09/30 18:29:20]

OK, I think it would be more readable like that:
===
  // Use http:// url for the prerendered page.
  GURL url(
      embedded_test_server()->GetURL("/prerender/prerender_no_referrer.html"));

  UseHttpsSrcServer();
  PrerenderTestURL(url, FINAL_STATUS_USED, 1);
  NavigateToDestURL();
===

This would:
* by using extra spacing suggest which range of lines the comment corresponds to
* avoid ambiguity of 'first' that could refer to the page issuing the prerender
* more precise with 'http://' compared to 'non-https' (I know, my nits are
always great)

[mattcary, 2016/10/03 10:58:34]

Done, with slight modification.

+  GURL url(
+      embedded_test_server()->GetURL("/prerender/prerender_no_referrer.html"));
+  PrerenderTestURL(url, FINAL_STATUS_USED, 1);
   NavigateToDestURL();
 }
 
 // Checks that the referrer is set when prerendering is cancelled.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderCancelReferrer) {
   std::unique_ptr<TestContentBrowserClient> test_content_browser_client(
       new TestContentBrowserClient);
   content::ContentBrowserClient* original_browser_client =
       content::SetBrowserClientForTesting(test_content_browser_client.get());
 
@@ skipping 464 matching lines @@
 }
 
 // Checks that xhr DELETE cancels prerenders.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderXhrDelete) {
   PrerenderTestURL("/prerender/prerender_xhr_delete.html",
                    FINAL_STATUS_INVALID_HTTP_METHOD, 1);
 }
 
 // Checks that a top-level page which would trigger an SSL error is canceled.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderSSLErrorTopLevel) {
+  // We only send the loaded page, not the loader, through SSL.

[pasko, 2016/09/22 18:14:04]

Isn't this a subset of what the comment two lines above says? When we say about
something 'cancelled' in context of prerender, it is assumed to be about the
prerendered page.

[mattcary, 2016/09/23 09:00:15]

It's further detail that explains further why this test differs from other
tests, in particular why we are instantiating a separate EmbeddedTestServer here
rather than just calling UseHttpsSrcServer(). That's a key detail that probably
won't be obvious to someone changing this test in the future.

[pasko, 2016/09/30 18:29:20]

I see. I agree that manipulations in this test are somewhat surprising compared
to other tests, so extra commenting looks good.

For me confusing parts were:
1. use of 'we'
2. big overlap between the two comments begged for more efficiency in comments
:)
3. ambiguity in the term 'loader'

To fix the above my suggestion would be:

// Sets up initial page on HTTP and checks that an SSL error on the prerendered
page cancels the prerender.

[mattcary, 2016/10/03 10:58:34]

Done, thanks, I am still quite sloppy on use of "we".

   net::EmbeddedTestServer https_server(net::EmbeddedTestServer::TYPE_HTTPS);
   https_server.SetSSLConfig(net::EmbeddedTestServer::CERT_MISMATCHED_NAME);
   https_server.ServeFilesFromSourceDirectory("chrome/test/data");
   ASSERT_TRUE(https_server.Start());
   GURL https_url = https_server.GetURL("/prerender/prerender_page.html");
-  PrerenderTestURL(https_url,
-                   FINAL_STATUS_SSL_ERROR,
-                   0);
+  PrerenderTestURL(https_url, FINAL_STATUS_SSL_ERROR, 0);
 }
 
 // Checks that an SSL error that comes from a subresource does not cancel
 // the page. Non-main-frame requests are simply cancelled if they run into
 // an SSL problem.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderSSLErrorSubresource) {
   net::EmbeddedTestServer https_server(net::EmbeddedTestServer::TYPE_HTTPS);
   https_server.SetSSLConfig(net::EmbeddedTestServer::CERT_MISMATCHED_NAME);
   https_server.ServeFilesFromSourceDirectory("chrome/test/data");
   ASSERT_TRUE(https_server.Start());
@@ skipping 1191 matching lines @@
       browser()->tab_strip_model()->GetActiveWebContents();
   bool display_test_result = false;
   ASSERT_TRUE(content::ExecuteScriptAndExtractBool(web_contents,
                                                    "DidDisplayReallyPass()",
                                                    &display_test_result));
   ASSERT_TRUE(display_test_result);
 }
 #endif  // !defined(DISABLE_NACL)
 
 }  // namespace prerender