CL for src perf tryjob to run page_cycler_v2.intl_ko_th_vi benchmark on all-android platform(s)

chrome/browser/net/predictor_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 <algorithm>
 #include <memory>
 #include <set>
@@ skipping 55 matching lines @@
                                               net::NetworkDelegate* delegate) {
   const char kPlainTextHeaders[] =
       "HTTP/1.1 200 OK\n"
       "Content-Type: text/plain\n"
       "Access-Control-Allow-Origin: *\n"
       "\n";
   return new net::URLRequestTestJob(request, delegate, kPlainTextHeaders, "",
                                     true);
 }
 
-net::URLRequestJob* CreateRedirectRequestJob(std::string location,
-                                             net::URLRequest* request,
-                                             net::NetworkDelegate* delegate) {
-  char kPlainTextHeaders[] =
-      "HTTP/1.1 302 \n"
-      "Location: %s\n"
-      "Access-Control-Allow-Origin: *\n"
-      "\n";
-  return new net::URLRequestTestJob(
-      request, delegate,
-      base::StringPrintf(kPlainTextHeaders, location.c_str()), "", true);
-}
-
 // Override the test server to redirect requests matching some path. This is
 // used because the predictor only learns simple redirects with a path of "/"
 std::unique_ptr<net::test_server::HttpResponse> RedirectForPathHandler(
     const std::string& path,
     const GURL& redirect_url,
     const net::test_server::HttpRequest& request) {
   if (request.GetURL().path() != path)
     return nullptr;
   std::unique_ptr<net::test_server::BasicHttpResponse> response(
       new net::test_server::BasicHttpResponse);
@@ skipping 205 matching lines @@
 class CrossSitePredictorObserver
     : public chrome_browser_net::PredictorObserver {
  public:
   CrossSitePredictorObserver(const GURL& source_host,
                              const GURL& cross_site_host)
       : source_host_(source_host),
         cross_site_host_(cross_site_host),
         cross_site_learned_(0),
         cross_site_preconnected_(0),
         same_site_preconnected_(0),
-        dns_run_loop_(nullptr),
-        strict_(true) {}
+        dns_run_loop_(nullptr) {}
 
   void OnPreconnectUrl(
       const GURL& original_url,
       const GURL& first_party_for_cookies,
       chrome_browser_net::UrlInfo::ResolutionMotivation motivation,
       int count) override {
     base::AutoLock lock(lock_);
     if (original_url == cross_site_host_) {
       cross_site_preconnected_ = std::max(cross_site_preconnected_, count);
     } else if (original_url == source_host_) {
       same_site_preconnected_ = std::max(same_site_preconnected_, count);
-    } else if (strict_) {
+    } else {
       ADD_FAILURE() << "Preconnected " << original_url
                     << " when should only be preconnecting the source host: "
                     << source_host_
                     << " or the cross site host: " << cross_site_host_;
     }
   }
 
   void OnLearnFromNavigation(const GURL& referring_url,
                              const GURL& target_url) override {
     base::AutoLock lock(lock_);
     // There are three possibilities:
     //     source => target
     //     source => source
     //     target => target
     if (referring_url == source_host_ && target_url == cross_site_host_) {
       cross_site_learned_++;
     } else if (referring_url == source_host_ && target_url == source_host_) {
       // Same site learned. Branch retained for clarity.
-    } else if (strict_ &&
-               !(referring_url == cross_site_host_ &&
+    } else if (!(referring_url == cross_site_host_ &&
                  target_url == cross_site_host_)) {
       ADD_FAILURE() << "Learned " << referring_url << " => " << target_url
                     << " when should only be learning the source host: "
                     << source_host_
                     << " or the cross site host: " << cross_site_host_;
     }
   }
 
   void OnDnsLookupFinished(const GURL& url, bool found) override {
     base::AutoLock lock(lock_);
@@ skipping 77 matching lines @@
     EXPECT_TRUE(HasHostBeenLookedUpLocked(url)) << "Expected to have looked up "
                                                 << url.spec();
     return base::ContainsKey(successful_dns_lookups_, url);
   }
 
   void set_task_runner(
       scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
     task_runner_.swap(task_runner);
   }
 
-  // Optionally allows the object to observe preconnects / learning from other
-  // hosts.
-  void SetStrict(bool strict) {
-    base::AutoLock lock(lock_);
-    strict_ = strict;
-  }
-
  private:
   const GURL source_host_;
   const GURL cross_site_host_;
 
   GURL waiting_on_dns_;
 
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
   // Protects all following members. They are read and updated from different
   // threads.
   base::Lock lock_;
 
   int cross_site_learned_;
   int cross_site_preconnected_;
   int same_site_preconnected_;
 
   std::set<GURL> successful_dns_lookups_;
   std::set<GURL> unsuccessful_dns_lookups_;
   base::RunLoop* dns_run_loop_;
 
-  // This member can be set to optionally allow url learning other than from
-  // source => source, source => target, or target => target. It will also allow
-  // preconnects to other hosts.
-  bool strict_;
-
   DISALLOW_COPY_AND_ASSIGN(CrossSitePredictorObserver);
 };
 
 }  // namespace
 
 namespace chrome_browser_net {
 
 class PredictorBrowserTest : public InProcessBrowserTest {
  public:
   PredictorBrowserTest()
@@ skipping 45 matching lines @@
         base::Bind(&RedirectForPathHandler, "/",
                    cross_site_test_server()->GetURL("/title1.html")));
 
     predictor()->SetPredictorEnabledForTest(true);
     InstallPredictorObserver(embedded_test_server()->base_url(),
                              cross_site_test_server()->base_url());
     observer()->set_task_runner(task_runner_);
     StartInterceptingCrossSiteOnUI();
   }
 
-  static void StartInterceptingHostWithCreateJobCallback(
-      const GURL& url,
-      const MatchingPortRequestInterceptor::CreateJobCallback& callback) {
+  // Intercepts all requests to the specified host and returns a response with
+  // an empty body. Needed to prevent requests from actually going to the test
+  // server, to avoid any races related to socket accounting. Note, the
+  // interceptor also looks at the port, to differentiate between the
+  // two test servers.
+  static void StartInterceptingHost(const GURL& url) {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
     net::URLRequestFilter::GetInstance()->AddHostnameInterceptor(
         url.scheme(), url.host(),
         base::MakeUnique<MatchingPortRequestInterceptor>(url.EffectiveIntPort(),
                                                          callback));
   }
 
   static void StopInterceptingHost(const GURL& url) {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
     net::URLRequestFilter::GetInstance()->RemoveHostnameHandler(url.scheme(),
                                                                 url.host());
   }
 
-  // Intercepts all requests to the specified host and returns a response with
-  // an empty body. Needed to prevent requests from actually going to the test
-  // server, to avoid any races related to socket accounting. Note, the
-  // interceptor also looks at the port, to differentiate between the
-  // two test servers.
   void StartInterceptingCrossSiteOnUI() {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     content::BrowserThread::PostTask(
         content::BrowserThread::IO, FROM_HERE,
-        base::Bind(
-            &PredictorBrowserTest::StartInterceptingHostWithCreateJobCallback,
-            cross_site_test_server()->base_url(),
-            base::Bind(&CreateEmptyBodyRequestJob)));
+        base::Bind(&PredictorBrowserTest::StartInterceptingHost,
+                   cross_site_test_server()->base_url()));
   }
 
   void StopInterceptingCrossSiteOnUI() {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     content::BrowserThread::PostTask(
         content::BrowserThread::IO, FROM_HERE,
         base::Bind(&PredictorBrowserTest::StopInterceptingHost,
                    cross_site_test_server()->base_url()));
   }
 
@@ skipping 358 matching lines @@
   // embedded test servers have the same host_piece, an extra preconnect is
   // issued. This results in ceil(2.33) + 1 = 4 preconnects.
   ui_test_utils::NavigateToURL(browser(),
                                embedded_test_server()->GetURL("/title1.html"));
   // Just check that predictor has initiated preconnects to the cross site test
   // server. It's tricky to reset the connections to the test server, and
   // sockets can be reused.
   EXPECT_EQ(4, observer()->CrossSitePreconnected());
 }
 
-// 1. Navigate to A.com learning B.com
-// 2. Navigate to B.com with subresource from C.com redirecting to A.com.
-// 3. Assert that the redirect does not cause us to preconnect to B.com (via
-// A.com).
-IN_PROC_BROWSER_TEST_F(PredictorBrowserTest, DontPredictBasedOnSubresources) {
-  GURL redirector_url = GURL("http://redirector.com");
-
-  NavigateToCrossSiteHtmlUrl(1 /* num_cors */, "" /* file_suffix */);
-  EXPECT_EQ(1, observer()->CrossSiteLearned());
-  EXPECT_EQ(0, observer()->CrossSitePreconnected());
-
-  EXPECT_EQ(0u, cross_site_connection_listener_->GetAcceptedSocketCount());
-
-  // Stop intercepting so that the test can actually navigate to the cross site
-  // server.
-  StopInterceptingCrossSiteOnUI();
-
-  // All requests with the redirector url as base url should redirect to the
-  // embedded_test_server_.
-  content::BrowserThread::PostTask(
-      content::BrowserThread::IO, FROM_HERE,
-      base::Bind(
-          &PredictorBrowserTest::StartInterceptingHostWithCreateJobCallback,
-          redirector_url,
-          base::Bind(
-              &CreateRedirectRequestJob,
-              embedded_test_server()->GetURL("/predictor/empty.js").spec())));
-
-  // Reduce the strictness, because the below logic causes the predictor to
-  // learn cross_site_test_server_ => redirector, as well as
-  // cross_site_test_server_ => embedded_test_server_ (via referrer header).
-  observer()->SetStrict(false);
-
-  GURL redirect_requesting_url =
-      cross_site_test_server()->GetURL(base::StringPrintf(
-          "/predictor/"
-          "predictor_cross_site.html?subresourceHost=%s&numCORSResources=1",
-          redirector_url.spec().c_str()));
-  ui_test_utils::NavigateToURL(browser(), redirect_requesting_url);
-  bool result = false;
-
-  int navigation_preconnects = observer()->CrossSitePreconnected();
-  EXPECT_EQ(2, navigation_preconnects);
-
-  EXPECT_TRUE(content::ExecuteScriptAndExtractBool(
-      browser()->tab_strip_model()->GetActiveWebContents(),
-      "startFetchesAndWaitForReply()", &result));
-  EXPECT_TRUE(result);
-
-  // The number of preconnects should not increase. Note that the predictor
-  // would preconnect 4 sockets if it were doing so based on learning.
-  EXPECT_EQ(navigation_preconnects, observer()->CrossSitePreconnected());
-}
-
-IN_PROC_BROWSER_TEST_F(PredictorBrowserTest, PredictBasedOnSubframeRedirect) {
-  // A test server is needed here because data url navigations with redirect
-  // interceptors don't interact well with the ResourceTiming API.
-  // TODO(csharrison): Possibly this is a bug in either net or Blink, and it
-  // might be worthwhile to investigate.
-  std::unique_ptr<net::EmbeddedTestServer> redirector =
-      base::MakeUnique<net::EmbeddedTestServer>();
-  ASSERT_TRUE(redirector->Start());
-
-  NavigateToCrossSiteHtmlUrl(1 /* num_cors */, "" /* file_suffix */);
-  EXPECT_EQ(1, observer()->CrossSiteLearned());
-  EXPECT_EQ(0u, cross_site_connection_listener_->GetAcceptedSocketCount());
-
-  redirector->RegisterRequestHandler(
-      base::Bind(&RedirectForPathHandler, "/",
-                 embedded_test_server()->GetURL("/title1.html")));
-
-  // Note that the observer will see preconnects to the redirector, and the
-  // predictor will learn redirector->embedded_test_server.
-  observer()->SetStrict(false);
-
-  NavigateToDataURLWithContent(base::StringPrintf(
-      "<iframe src='%s'></iframe>", redirector->base_url().spec().c_str()));
-
-  EXPECT_EQ(4, observer()->CrossSitePreconnected());
-  cross_site_connection_listener_->WaitForAcceptedConnectionsOnUI(4u);
-}
-
 // Expect that the predictor correctly predicts subframe navigations.
 IN_PROC_BROWSER_TEST_F(PredictorBrowserTest, SubframeCrossSitePrediction) {
   ui_test_utils::NavigateToURL(
       browser(), embedded_test_server()->GetURL(
                      "/predictor/predictor_cross_site_subframe_nav.html"));
   bool result = false;
   EXPECT_TRUE(content::ExecuteScriptAndExtractBool(
       browser()->tab_strip_model()->GetActiveWebContents(),
       base::StringPrintf(
           "navigateSubframe('%s')",
@@ skipping 373 matching lines @@
   GetListFromPrefsAsString(prefs::kDnsPrefetchingStartupList,
                            &cleared_startup_list);
   GetListFromPrefsAsString(prefs::kDnsPrefetchingHostReferralList,
                            &cleared_referral_list);
   EXPECT_THAT(cleared_referral_list, Not(HasSubstr(referring_url_.host())));
   EXPECT_THAT(cleared_referral_list, Not(HasSubstr(target_url_.host())));
 }
 
 // The predictor should not evict recently used (navigated to) referrers.
 IN_PROC_BROWSER_TEST_F(PredictorBrowserTest, DoNotEvictRecentlyUsed) {
-  observer()->SetStrict(false);
   for (int i = 0; i < Predictor::kMaxReferrers; ++i) {
     LearnFromNavigation(
         GURL(base::StringPrintf("http://www.source%d.test", i)),
         GURL(base::StringPrintf("http://www.target%d.test", i)));
   }
   ui_test_utils::NavigateToURL(browser(), GURL("http://source0.test"));
 
   // This will evict http://source1.test.
   LearnFromNavigation(GURL("http://new_source"), GURL("http://new_target"));
 
@@ skipping 126 matching lines @@
   // Second navigation to content with an img.
   std::string img_content =
       "<img src=\"" + preconnect_url.spec() + "test.gif\">";
   NavigateToDataURLWithContent(img_content);
   connection_listener_->WaitUntilFirstConnectionRead();
   EXPECT_EQ(2u, connection_listener_->GetAcceptedSocketCount());
   EXPECT_EQ(1u, connection_listener_->GetReadSocketCount());
 }
 
 }  // namespace chrome_browser_net