Poll CanPredictNetworkActions in Predictor class.

chrome/browser/net/predictor_unittest.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 <time.h>
 
 #include <algorithm>
 #include <sstream>
 #include <string>
 
@@ skipping 110 matching lines @@
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread io_thread_;
 
  protected:
   scoped_ptr<net::MockCachingHostResolver> host_resolver_;
 };
 
 //------------------------------------------------------------------------------
 
 TEST_F(PredictorTest, StartupShutdownTest) {
-  Predictor testing_master(true);
+  Predictor testing_master(true, true);
   testing_master.Shutdown();
 }
 
 
 TEST_F(PredictorTest, ShutdownWhenResolutionIsPendingTest) {
   scoped_ptr<net::HostResolver> host_resolver(new net::HangingHostResolver());
 
-  Predictor testing_master(true);
+  Predictor testing_master(true, true);
   testing_master.SetHostResolver(host_resolver.get());
 
   GURL localhost("http://localhost:80");
   UrlList names;
   names.push_back(localhost);
 
   testing_master.ResolveList(names, UrlInfo::PAGE_SCAN_MOTIVATED);
 
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::MessageLoop::QuitClosure(),
       base::TimeDelta::FromMilliseconds(500));
   base::MessageLoop::current()->Run();
 
   EXPECT_FALSE(testing_master.WasFound(localhost));
 
   testing_master.Shutdown();
 
   // Clean up after ourselves.
   base::MessageLoop::current()->RunUntilIdle();
 }
 
 TEST_F(PredictorTest, SingleLookupTest) {
-  Predictor testing_master(true);
+  Predictor testing_master(true, true);
   testing_master.SetHostResolver(host_resolver_.get());
 
   GURL goog("http://www.google.com:80");
 
   UrlList names;
   names.push_back(goog);
 
   // Try to flood the predictor with many concurrent requests.
   for (int i = 0; i < 10; i++)
     testing_master.ResolveList(names, UrlInfo::PAGE_SCAN_MOTIVATED);
 
   WaitForResolution(&testing_master, names);
 
   EXPECT_TRUE(testing_master.WasFound(goog));
 
   base::MessageLoop::current()->RunUntilIdle();
 
   EXPECT_GT(testing_master.peak_pending_lookups(), names.size() / 2);
   EXPECT_LE(testing_master.peak_pending_lookups(), names.size());
   EXPECT_LE(testing_master.peak_pending_lookups(),
             testing_master.max_concurrent_dns_lookups());
 
   testing_master.Shutdown();
 }
 
 TEST_F(PredictorTest, ConcurrentLookupTest) {
   host_resolver_->rules()->AddSimulatedFailure("*.notfound");
 
-  Predictor testing_master(true);
+  Predictor testing_master(true, true);
   testing_master.SetHostResolver(host_resolver_.get());
 
   GURL goog("http://www.google.com:80"),
       goog2("http://gmail.google.com.com:80"),
       goog3("http://mail.google.com:80"),
       goog4("http://gmail.com:80");
   GURL bad1("http://bad1.notfound:80"),
       bad2("http://bad2.notfound:80");
 
   UrlList names;
@@ skipping 26 matching lines @@
   EXPECT_LE(testing_master.peak_pending_lookups(), names.size());
   EXPECT_LE(testing_master.peak_pending_lookups(),
             testing_master.max_concurrent_dns_lookups());
 
   testing_master.Shutdown();
 }
 
 TEST_F(PredictorTest, MassiveConcurrentLookupTest) {
   host_resolver_->rules()->AddSimulatedFailure("*.notfound");
 
-  Predictor testing_master(true);
+  Predictor testing_master(true, true);
   testing_master.SetHostResolver(host_resolver_.get());
 
   UrlList names;
   for (int i = 0; i < 100; i++)
     names.push_back(GURL(
         "http://host" + base::IntToString(i) + ".notfound:80"));
 
   // Try to flood the predictor with many concurrent requests.
   for (int i = 0; i < 10; i++)
     testing_master.ResolveList(names, UrlInfo::PAGE_SCAN_MOTIVATED);
@@ skipping 103 matching lines @@
       return true;
     }
   }
   return false;
 }
 
 //------------------------------------------------------------------------------
 
 // Make sure nil referral lists really have no entries, and no latency listed.
 TEST_F(PredictorTest, ReferrerSerializationNilTest) {
-  Predictor predictor(true);
+  Predictor predictor(true, true);
   predictor.SetHostResolver(host_resolver_.get());
 
   scoped_ptr<base::ListValue> referral_list(NewEmptySerializationList());
   predictor.SerializeReferrers(referral_list.get());
   EXPECT_EQ(1U, referral_list->GetSize());
   EXPECT_FALSE(GetDataFromSerialization(
     GURL("http://a.com:79"), GURL("http://b.com:78"),
       *referral_list.get(), NULL));
 
   predictor.Shutdown();
 }
 
 // Make sure that when a serialization list includes a value, that it can be
 // deserialized into the database, and can be extracted back out via
 // serialization without being changed.
 TEST_F(PredictorTest, ReferrerSerializationSingleReferrerTest) {
-  Predictor predictor(true);
+  Predictor predictor(true, true);
   predictor.SetHostResolver(host_resolver_.get());
   const GURL motivation_url("http://www.google.com:91");
   const GURL subresource_url("http://icons.google.com:90");
   const double kUseRate = 23.4;
   scoped_ptr<base::ListValue> referral_list(NewEmptySerializationList());
 
   AddToSerializedList(motivation_url, subresource_url,
       kUseRate, referral_list.get());
 
   predictor.DeserializeReferrers(*referral_list.get());
 
   base::ListValue recovered_referral_list;
   predictor.SerializeReferrers(&recovered_referral_list);
   EXPECT_EQ(2U, recovered_referral_list.GetSize());
   double rate;
   EXPECT_TRUE(GetDataFromSerialization(
       motivation_url, subresource_url, recovered_referral_list, &rate));
   EXPECT_EQ(rate, kUseRate);
 
   predictor.Shutdown();
 }
 
 // Check that GetHtmlReferrerLists() doesn't crash when given duplicated
 // domains for referring URL, and that it sorts the results in the
 // correct order.
 TEST_F(PredictorTest, GetHtmlReferrerLists) {
-  Predictor predictor(true);
+  Predictor predictor(true, true);
   predictor.SetHostResolver(host_resolver_.get());
   const double kUseRate = 23.4;
   scoped_ptr<base::ListValue> referral_list(NewEmptySerializationList());
 
   AddToSerializedList(
       GURL("http://d.google.com/x1"),
       GURL("http://foo.com/"),
       kUseRate, referral_list.get());
 
   // Duplicated hostname (d.google.com). This should not cause any crashes
@@ skipping 64 matching lines @@
     double espilon_ratio = 1.01;  \
     if ((a) < 0.)  \
       espilon_ratio = 1 / espilon_ratio;  \
     EXPECT_LT(a, espilon_ratio * (b));   \
     EXPECT_GT((a) * espilon_ratio, b);   \
     } while (0)
 
 
 // Make sure the Trim() functionality works as expected.
 TEST_F(PredictorTest, ReferrerSerializationTrimTest) {
-  Predictor predictor(true);
+  Predictor predictor(true, true);
   predictor.SetHostResolver(host_resolver_.get());
   GURL motivation_url("http://www.google.com:110");
 
   GURL icon_subresource_url("http://icons.google.com:111");
   const double kRateIcon = 16.0 * Predictor::kDiscardableExpectedValue;
   GURL img_subresource_url("http://img.google.com:118");
   const double kRateImg = 8.0 * Predictor::kDiscardableExpectedValue;
 
   scoped_ptr<base::ListValue> referral_list(NewEmptySerializationList());
   AddToSerializedList(
@@ skipping 168 matching lines @@
   EXPECT_NE(Predictor::CanonicalizeUrl(http),
             Predictor::CanonicalizeUrl(https));
 
   // Https works fine.
   GURL long_https("https://host:999/path?query=value");
   EXPECT_EQ(Predictor::CanonicalizeUrl(long_https),
             long_https.GetWithEmptyPath());
 }
 
 TEST_F(PredictorTest, DiscardPredictorResults) {
-  Predictor predictor(true);
+  Predictor predictor(true, true);
   predictor.SetHostResolver(host_resolver_.get());
   base::ListValue referral_list;
   predictor.SerializeReferrers(&referral_list);
   EXPECT_EQ(1U, referral_list.GetSize());
 
   GURL host_1("http://test_1");
   GURL host_2("http://test_2");
   predictor.LearnFromNavigation(host_1, host_2);
 
   predictor.SerializeReferrers(&referral_list);
@@ skipping 22 matching lines @@
 // Tests that preconnects apply the HSTS list.
 TEST_F(PredictorTest, HSTSRedirect) {
   const GURL kHttpUrl("http://example.com");
   const GURL kHttpsUrl("https://example.com");
 
   const base::Time expiry =
       base::Time::Now() + base::TimeDelta::FromSeconds(1000);
   net::TransportSecurityState state;
   state.AddHSTS(kHttpUrl.host(), expiry, false);
 
-  Predictor predictor(true);
+  Predictor predictor(true, true);
   TestPredictorObserver observer;
   predictor.SetObserver(&observer);
   predictor.SetTransportSecurityState(&state);
 
   predictor.PreconnectUrl(kHttpUrl, GURL(), UrlInfo::OMNIBOX_MOTIVATED, 2);
   ASSERT_EQ(1u, observer.preconnected_urls_.size());
   EXPECT_EQ(kHttpsUrl, observer.preconnected_urls_[0]);
 
   predictor.Shutdown();
 }
 
 // Tests that preconnecting a URL on the HSTS list preconnects the subresources
 // for the SSL version.
 TEST_F(PredictorTest, HSTSRedirectSubresources) {
   const GURL kHttpUrl("http://example.com");
   const GURL kHttpsUrl("https://example.com");
   const GURL kSubresourceUrl("https://images.example.com");
   const double kUseRate = 23.4;
 
   const base::Time expiry =
       base::Time::Now() + base::TimeDelta::FromSeconds(1000);
   net::TransportSecurityState state;
   state.AddHSTS(kHttpUrl.host(), expiry, false);
 
-  Predictor predictor(true);
+  Predictor predictor(true, true);
   TestPredictorObserver observer;
   predictor.SetObserver(&observer);
   predictor.SetTransportSecurityState(&state);
 
   scoped_ptr<base::ListValue> referral_list(NewEmptySerializationList());
   AddToSerializedList(
       kHttpsUrl, kSubresourceUrl, kUseRate, referral_list.get());
   predictor.DeserializeReferrers(*referral_list.get());
 
   predictor.PreconnectUrlAndSubresources(kHttpUrl, GURL());
@@ skipping 28 matching lines @@
     ++would_proxy_count_;
     return would_proxy_;
   }
 
   bool would_proxy_;
   int advise_count_;
   int would_proxy_count_;
 };
 
 TEST_F(PredictorTest, SingleLookupTestWithDisabledAdvisor) {
-  Predictor testing_master(true);
+  Predictor testing_master(true, true);
   TestProxyAdvisor* advisor = new TestProxyAdvisor();
   testing_master.SetHostResolver(host_resolver_.get());
   testing_master.proxy_advisor_.reset(advisor);
 
   GURL goog("http://www.google.com:80");
 
   advisor->would_proxy_ = false;
 
   UrlList names;
   names.push_back(goog);
   testing_master.ResolveList(names, UrlInfo::PAGE_SCAN_MOTIVATED);
 
   WaitForResolution(&testing_master, names);
   EXPECT_TRUE(testing_master.WasFound(goog));
   EXPECT_EQ(advisor->would_proxy_count_, 1);
   EXPECT_EQ(advisor->advise_count_, 1);
 
   base::MessageLoop::current()->RunUntilIdle();
 
   testing_master.Shutdown();
 }
 
 TEST_F(PredictorTest, SingleLookupTestWithEnabledAdvisor) {
-  Predictor testing_master(true);
+  Predictor testing_master(true, true);
   testing_master.SetHostResolver(host_resolver_.get());
   TestProxyAdvisor* advisor = new TestProxyAdvisor();
   testing_master.proxy_advisor_.reset(advisor);
 
   GURL goog("http://www.google.com:80");
 
   advisor->would_proxy_ = true;
 
   UrlList names;
   names.push_back(goog);
 
   testing_master.ResolveList(names, UrlInfo::PAGE_SCAN_MOTIVATED);
 
   // Attempt to resolve a few times.
   WaitForResolutionWithLimit(&testing_master, names, 10);
 
   // Because the advisor indicated that the url would be proxied,
   // no resolution should have occurred.
   EXPECT_FALSE(testing_master.WasFound(goog));
   EXPECT_EQ(advisor->would_proxy_count_, 1);
   EXPECT_EQ(advisor->advise_count_, 1);
 
   base::MessageLoop::current()->RunUntilIdle();
 
   testing_master.Shutdown();
 }
 
 TEST_F(PredictorTest, TestSimplePreconnectAdvisor) {
-  Predictor testing_master(true);
+  Predictor testing_master(true, true);
   testing_master.SetHostResolver(host_resolver_.get());
   TestProxyAdvisor* advisor = new TestProxyAdvisor();
   testing_master.proxy_advisor_.reset(advisor);
 
   GURL goog("http://www.google.com:80");
 
   testing_master.PreconnectUrl(goog, goog, UrlInfo::OMNIBOX_MOTIVATED, 2);
 
   EXPECT_EQ(advisor->would_proxy_count_, 0);
   EXPECT_EQ(advisor->advise_count_, 1);
 
   testing_master.Shutdown();
 }
 
 #endif  // defined(OS_ANDROID) || defined(OS_IOS)
 
 }  // namespace chrome_browser_net