Third patch in getting rid of caching MessageLoop pointers and always using C...

chrome/browser/net/dns_master_unittest.cc

 // Copyright (c) 2006-2008 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>
 
 #include "base/message_loop.h"
 #include "base/scoped_ptr.h"
 #include "base/string_util.h"
 #include "base/timer.h"
+#include "chrome/browser/chrome_thread.h"
 #include "chrome/browser/net/dns_global.h"
 #include "chrome/browser/net/dns_host_info.h"
 #include "chrome/common/net/dns.h"
 #include "net/base/address_list.h"
 #include "net/base/mock_host_resolver.h"
 #include "net/base/winsock_init.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::Time;
 using base::TimeDelta;
@@ skipping 27 matching lines @@
 
  private:
   DnsMaster* master_;
   const NameList hosts_;
   HelperTimer* timer_;
 };
 
 class DnsMasterTest : public testing::Test {
  public:
   DnsMasterTest()
-      : host_resolver_(new net::MockCachingHostResolver()),
+      : io_thread_(ChromeThread::IO, &loop_),
+        host_resolver_(new net::MockCachingHostResolver()),
         default_max_queueing_delay_(TimeDelta::FromMilliseconds(
             DnsPrefetcherInit::kMaxQueueingDelayMs)) {
   }
 
  protected:
   virtual void SetUp() {
 #if defined(OS_WIN)
     net::EnsureWinsockInit();
 #endif
     // Since we are using a caching HostResolver, the following latencies will
@@ skipping 11 matching lines @@
     timer->Start(TimeDelta::FromMilliseconds(100),
                  new WaitForResolutionHelper(master, hosts, timer),
                  &WaitForResolutionHelper::Run);
     MessageLoop::current()->Run();
   }
 
  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).
-  MessageLoop loop;
+  MessageLoop loop_;
+  ChromeThread io_thread_;
 
  protected:
   scoped_refptr<net::MockCachingHostResolver> host_resolver_;
 
   // Shorthand to access TimeDelta of DnsPrefetcherInit::kMaxQueueingDelayMs.
   // (It would be a static constant... except style rules preclude that :-/ ).
   const TimeDelta default_max_queueing_delay_;
 };
 
 //------------------------------------------------------------------------------
 
 TEST_F(DnsMasterTest, StartupShutdownTest) {
   scoped_refptr<DnsMaster> testing_master = new DnsMaster(host_resolver_,
-      MessageLoop::current(), default_max_queueing_delay_,
-      DnsPrefetcherInit::kMaxConcurrentLookups);
+      default_max_queueing_delay_, DnsPrefetcherInit::kMaxConcurrentLookups);
   testing_master->Shutdown();
 }
 
 TEST_F(DnsMasterTest, BenefitLookupTest) {
   scoped_refptr<DnsMaster> testing_master = new DnsMaster(host_resolver_,
-      MessageLoop::current(), default_max_queueing_delay_,
-      DnsPrefetcherInit::kMaxConcurrentLookups);
+      default_max_queueing_delay_, DnsPrefetcherInit::kMaxConcurrentLookups);
 
   std::string goog("www.google.com"),
     goog2("gmail.google.com.com"),
     goog3("mail.google.com"),
     goog4("gmail.com");
   DnsHostInfo goog_info, goog2_info, goog3_info, goog4_info;
 
   // Simulate getting similar names from a network observer
   goog_info.SetHostname(goog);
   goog2_info.SetHostname(goog2);
@@ skipping 43 matching lines @@
 
   testing_master->Shutdown();
 }
 
 TEST_F(DnsMasterTest, ShutdownWhenResolutionIsPendingTest) {
   scoped_refptr<net::WaitingHostResolverProc> resolver_proc =
       new net::WaitingHostResolverProc(NULL);
   host_resolver_->Reset(resolver_proc);
 
   scoped_refptr<DnsMaster> testing_master = new DnsMaster(host_resolver_,
-      MessageLoop::current(), default_max_queueing_delay_,
-      DnsPrefetcherInit::kMaxConcurrentLookups);
+      default_max_queueing_delay_, DnsPrefetcherInit::kMaxConcurrentLookups);
 
   std::string localhost("127.0.0.1");
   NameList names;
   names.insert(names.end(), localhost);
 
   testing_master->ResolveList(names, DnsHostInfo::PAGE_SCAN_MOTIVATED);
 
   MessageLoop::current()->PostDelayedTask(FROM_HERE,
                                           new MessageLoop::QuitTask(), 500);
   MessageLoop::current()->Run();
 
   EXPECT_FALSE(testing_master->WasFound(localhost));
 
   testing_master->Shutdown();
 
   // Clean up after ourselves.
   resolver_proc->Signal();
   MessageLoop::current()->RunAllPending();
 }
 
 TEST_F(DnsMasterTest, SingleLookupTest) {
   scoped_refptr<DnsMaster> testing_master = new DnsMaster(host_resolver_,
-      MessageLoop::current(), default_max_queueing_delay_,
-      DnsPrefetcherInit::kMaxConcurrentLookups);
+      default_max_queueing_delay_, DnsPrefetcherInit::kMaxConcurrentLookups);
 
   std::string goog("www.google.com");
 
   NameList names;
   names.insert(names.end(), goog);
 
   // Try to flood the master with many concurrent requests.
   for (int i = 0; i < 10; i++)
     testing_master->ResolveList(names, DnsHostInfo::PAGE_SCAN_MOTIVATED);
 
   WaitForResolution(testing_master, names);
 
   EXPECT_TRUE(testing_master->WasFound(goog));
 
   MessageLoop::current()->RunAllPending();
 
   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_lookups());
 
   testing_master->Shutdown();
 }
 
 TEST_F(DnsMasterTest, ConcurrentLookupTest) {
   host_resolver_->rules()->AddSimulatedFailure("*.notfound");
 
   scoped_refptr<DnsMaster> testing_master = new DnsMaster(host_resolver_,
-      MessageLoop::current(), default_max_queueing_delay_,
-      DnsPrefetcherInit::kMaxConcurrentLookups);
+      default_max_queueing_delay_, DnsPrefetcherInit::kMaxConcurrentLookups);
 
   std::string goog("www.google.com"),
     goog2("gmail.google.com.com"),
     goog3("mail.google.com"),
     goog4("gmail.com");
   std::string bad1("bad1.notfound"),
     bad2("bad2.notfound");
 
   NameList names;
   names.insert(names.end(), goog);
@@ skipping 27 matching lines @@
   EXPECT_LE(testing_master->peak_pending_lookups(),
             testing_master->max_concurrent_lookups());
 
   testing_master->Shutdown();
 }
 
 TEST_F(DnsMasterTest, MassiveConcurrentLookupTest) {
   host_resolver_->rules()->AddSimulatedFailure("*.notfound");
 
   scoped_refptr<DnsMaster> testing_master = new DnsMaster(host_resolver_,
-      MessageLoop::current(), default_max_queueing_delay_,
-      DnsPrefetcherInit::kMaxConcurrentLookups);
+      default_max_queueing_delay_, DnsPrefetcherInit::kMaxConcurrentLookups);
 
   NameList names;
   for (int i = 0; i < 100; i++)
     names.push_back("host" + IntToString(i) + ".notfound");
 
   // Try to flood the master with many concurrent requests.
   for (int i = 0; i < 10; i++)
     testing_master->ResolveList(names, DnsHostInfo::PAGE_SCAN_MOTIVATED);
 
   WaitForResolution(testing_master, names);
@@ skipping 83 matching lines @@
     ++i;  // Skip latency value.
   }
   return kLatencyNotFound;
 }
 
 //------------------------------------------------------------------------------
 
 // Make sure nil referral lists really have no entries, and no latency listed.
 TEST_F(DnsMasterTest, ReferrerSerializationNilTest) {
   scoped_refptr<DnsMaster> master = new DnsMaster(host_resolver_,
-      MessageLoop::current(), default_max_queueing_delay_,
-      DnsPrefetcherInit::kMaxConcurrentLookups);
+      default_max_queueing_delay_, DnsPrefetcherInit::kMaxConcurrentLookups);
   ListValue referral_list;
   master->SerializeReferrers(&referral_list);
   EXPECT_EQ(0U, referral_list.GetSize());
   EXPECT_EQ(kLatencyNotFound, GetLatencyFromSerialization("a.com", "b.com",
                                                           referral_list));
 
   master->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(DnsMasterTest, ReferrerSerializationSingleReferrerTest) {
   scoped_refptr<DnsMaster> master = new DnsMaster(host_resolver_,
-      MessageLoop::current(), default_max_queueing_delay_,
-      DnsPrefetcherInit::kMaxConcurrentLookups);
+      default_max_queueing_delay_, DnsPrefetcherInit::kMaxConcurrentLookups);
   std::string motivation_hostname = "www.google.com";
   std::string subresource_hostname = "icons.google.com";
   const int kLatency = 3;
   ListValue referral_list;
 
   AddToSerializedList(motivation_hostname, subresource_hostname, kLatency,
                       &referral_list);
 
   master->DeserializeReferrers(referral_list);
 
   ListValue recovered_referral_list;
   master->SerializeReferrers(&recovered_referral_list);
   EXPECT_EQ(1U, recovered_referral_list.GetSize());
   EXPECT_EQ(kLatency, GetLatencyFromSerialization(motivation_hostname,
                                                   subresource_hostname,
                                                   recovered_referral_list));
 
   master->Shutdown();
 }
 
 // Make sure the Trim() functionality works as expected.
 TEST_F(DnsMasterTest, ReferrerSerializationTrimTest) {
   scoped_refptr<DnsMaster> master = new DnsMaster(host_resolver_,
-      MessageLoop::current(), default_max_queueing_delay_,
-      DnsPrefetcherInit::kMaxConcurrentLookups);
+      default_max_queueing_delay_, DnsPrefetcherInit::kMaxConcurrentLookups);
   std::string motivation_hostname = "www.google.com";
   std::string icon_subresource_hostname = "icons.google.com";
   std::string img_subresource_hostname = "img.google.com";
   ListValue referral_list;
 
   AddToSerializedList(motivation_hostname, icon_subresource_hostname, 10,
                       &referral_list);
   AddToSerializedList(motivation_hostname, img_subresource_hostname, 3,
                       &referral_list);
 
@@ skipping 108 matching lines @@
   EXPECT_EQ(queue.Pop(), "scan");
   EXPECT_EQ(queue.Pop(), "unit");
   EXPECT_EQ(queue.Pop(), "lmax");
   EXPECT_EQ(queue.Pop(), "omni");
   EXPECT_EQ(queue.Pop(), "startup");
   EXPECT_EQ(queue.Pop(), "omni");
 
   EXPECT_TRUE(queue.IsEmpty());
 }
 
-
-
-
 }  // namespace chrome_browser_net