Move predictor dns unit tests to browser tests

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 "chrome/browser/net/predictor.h"
 
 #include <stddef.h>
 #include <time.h>
 
 #include <algorithm>
@@ skipping 23 matching lines @@
 #include "net/proxy/proxy_service.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::Time;
 using base::TimeDelta;
 using content::BrowserThread;
 
 namespace chrome_browser_net {
 
-class WaitForResolutionHelper;
-
-class WaitForResolutionHelper {
- public:
-  WaitForResolutionHelper(Predictor* predictor,
-                          const UrlList& hosts,
-                          base::RepeatingTimer* timer,
-                          int checks_until_quit)
-      : predictor_(predictor),
-        hosts_(hosts),
-        timer_(timer),
-        checks_until_quit_(checks_until_quit) {}
-
-  void CheckIfResolutionsDone() {
-    if (--checks_until_quit_ > 0) {
-      for (UrlList::const_iterator i = hosts_.begin(); i != hosts_.end(); ++i)
-        if (predictor_->GetResolutionDuration(*i) ==
-            UrlInfo::NullDuration())
-          return;  // We don't have resolution for that host.
-    }
-
-    // When all hostnames have been resolved, or we've hit the limit,
-    // exit the loop.
-    timer_->Stop();
-    base::MessageLoop::current()->QuitWhenIdle();
-    delete timer_;
-    delete this;
-  }
-
- private:
-  Predictor* predictor_;
-  const UrlList hosts_;
-  base::RepeatingTimer* timer_;
-  int checks_until_quit_;
-};
-
 class PredictorTest : public testing::Test {
  public:
   PredictorTest()
       : ui_thread_(BrowserThread::UI, &loop_),
-        io_thread_(BrowserThread::IO, &loop_),
-        host_resolver_(new net::MockCachingHostResolver()) {
-  }
-
- protected:
-  void SetUp() override {
-#if defined(OS_WIN)
-    net::EnsureWinsockInit();
-#endif
-    Predictor::set_max_parallel_resolves(
-        Predictor::kMaxSpeculativeParallelResolves);
-    Predictor::set_max_queueing_delay(
-        Predictor::kMaxSpeculativeResolveQueueDelayMs);
-    // Since we are using a caching HostResolver, the following latencies will
-    // only be incurred by the first request, after which the result will be
-    // cached internally by |host_resolver_|.
-    net::RuleBasedHostResolverProc* rules = host_resolver_->rules();
-    rules->AddRuleWithLatency("www.google.com", "127.0.0.1", 50);
-    rules->AddRuleWithLatency("gmail.google.com.com", "127.0.0.1", 70);
-    rules->AddRuleWithLatency("mail.google.com", "127.0.0.1", 44);
-    rules->AddRuleWithLatency("gmail.com", "127.0.0.1", 63);
-  }
-
-  void WaitForResolution(Predictor* predictor, const UrlList& hosts) {
-    base::RepeatingTimer* timer = new base::RepeatingTimer();
-    // By default allow the loop to run for a minute -- 600 iterations.
-    timer->Start(FROM_HERE, TimeDelta::FromMilliseconds(100),
-                 new WaitForResolutionHelper(predictor, hosts, timer, 600),
-                 &WaitForResolutionHelper::CheckIfResolutionsDone);
-    base::MessageLoop::current()->Run();
-  }
-
-  void WaitForResolutionWithLimit(
-      Predictor* predictor, const UrlList& hosts, int limit) {
-    base::RepeatingTimer* timer = new base::RepeatingTimer();
-    timer->Start(FROM_HERE, TimeDelta::FromMilliseconds(100),
-                 new WaitForResolutionHelper(predictor, hosts, timer, limit),
-                 &WaitForResolutionHelper::CheckIfResolutionsDone);
-    base::MessageLoop::current()->Run();
-  }
+        io_thread_(BrowserThread::IO, &loop_) {}
 
  private:
-  // IMPORTANT: do not move this below |host_resolver_|; the host resolver
-  // must not outlive the message loop, otherwise bad things can happen
-  // (like posting to a deleted message loop).
   base::MessageLoopForUI loop_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread io_thread_;
-
- protected:
-  std::unique_ptr<net::MockCachingHostResolver> host_resolver_;
 };
 
 //------------------------------------------------------------------------------
-
-TEST_F(PredictorTest, StartupShutdownTest) {
-  Predictor testing_master(true, true);
-  testing_master.Shutdown();
-}
-
-
-TEST_F(PredictorTest, ShutdownWhenResolutionIsPendingTest) {
-  std::unique_ptr<net::HostResolver> host_resolver(
-      new net::HangingHostResolver());
-
-  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::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
-      FROM_HERE, base::MessageLoop::QuitWhenIdleClosure(),
-      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, 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, 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;
-  names.push_back(goog);
-  names.push_back(goog3);
-  names.push_back(bad1);
-  names.push_back(goog2);
-  names.push_back(bad2);
-  names.push_back(goog4);
-  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));
-  EXPECT_TRUE(testing_master.WasFound(goog3));
-  EXPECT_TRUE(testing_master.WasFound(goog2));
-  EXPECT_TRUE(testing_master.WasFound(goog4));
-  EXPECT_FALSE(testing_master.WasFound(bad1));
-  EXPECT_FALSE(testing_master.WasFound(bad2));
-
-  base::MessageLoop::current()->RunUntilIdle();
-
-  EXPECT_FALSE(testing_master.WasFound(bad1));
-  EXPECT_FALSE(testing_master.WasFound(bad2));
-
-  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, 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);
-
-  WaitForResolution(&testing_master, names);
-
-  base::MessageLoop::current()->RunUntilIdle();
-
-  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();
-}
-
-//------------------------------------------------------------------------------
 // Functions to help synthesize and test serializations of subresource referrer
 // lists.
 
 // Return a motivation_list if we can find one for the given motivating_host (or
 // NULL if a match is not found).
 static const base::ListValue* FindSerializationMotivation(
     const GURL& motivation,
     const base::ListValue* referral_list) {
   CHECK_LT(0u, referral_list->GetSize());  // Room for version.
   int format_version = -1;
@@ skipping 78 matching lines @@
     EXPECT_TRUE(subresource_list->GetDouble(i++, use_rate));
     if (subresource == GURL(url_spec)) {
       return true;
     }
   }
   return false;
 }
 
 //------------------------------------------------------------------------------
 
+TEST_F(PredictorTest, StartupShutdownTest) {
+  Predictor testing_master(true, true);
+  testing_master.Shutdown();
+}
+
 // Make sure nil referral lists really have no entries, and no latency listed.
 TEST_F(PredictorTest, ReferrerSerializationNilTest) {
   Predictor predictor(true, true);
-  predictor.SetHostResolver(host_resolver_.get());
 
   std::unique_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, 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;
   std::unique_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, true);
-  predictor.SetHostResolver(host_resolver_.get());
   const double kUseRate = 23.4;
   std::unique_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
   // (i.e. crbug.com/116345)
@@ skipping 64 matching lines @@
     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, 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;
 
   std::unique_ptr<base::ListValue> referral_list(NewEmptySerializationList());
   AddToSerializedList(
       motivation_url, icon_subresource_url, kRateIcon, referral_list.get());
@@ skipping 168 matching lines @@
             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) {
   SimplePredictor 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);
   EXPECT_EQ(2U, referral_list.GetSize());
@@ skipping 140 matching lines @@
   testing_master.Resolve(goog, UrlInfo::OMNIBOX_MOTIVATED);
 
   // Proxy may not be in use (the PAC script has not yet been evaluated), so the
   // name has been registered for pre-resolve.
   EXPECT_FALSE(testing_master.work_queue_.IsEmpty());
 
   testing_master.Shutdown();
 }
 
 }  // namespace chrome_browser_net