Convert implicit scoped_refptr constructor calls to explicit ones, part 1

chrome/browser/net/predictor_unittest.cc

 // Copyright (c) 2010 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 91 matching lines @@
   scoped_ptr<net::MockCachingHostResolver> host_resolver_;
 
   // Shorthand to access TimeDelta of PredictorInit::kMaxQueueingDelayMs.
   // (It would be a static constant... except style rules preclude that :-/ ).
   const TimeDelta default_max_queueing_delay_;
 };
 
 //------------------------------------------------------------------------------
 
 TEST_F(PredictorTest, StartupShutdownTest) {
-  scoped_refptr<Predictor> testing_master =
+  scoped_refptr<Predictor> testing_master(
       new Predictor(host_resolver_.get(),
                     default_max_queueing_delay_,
                     PredictorInit::kMaxSpeculativeParallelResolves,
-                    false);
+                    false));
   testing_master->Shutdown();
 }
 
 
 TEST_F(PredictorTest, ShutdownWhenResolutionIsPendingTest) {
-  scoped_refptr<net::WaitingHostResolverProc> resolver_proc =
-      new net::WaitingHostResolverProc(NULL);
+  scoped_refptr<net::WaitingHostResolverProc> resolver_proc(
+      new net::WaitingHostResolverProc(NULL));
   host_resolver_->Reset(resolver_proc);
 
-  scoped_refptr<Predictor> testing_master =
+  scoped_refptr<Predictor> testing_master(
       new Predictor(host_resolver_.get(),
                     default_max_queueing_delay_,
                     PredictorInit::kMaxSpeculativeParallelResolves,
-                    false);
+                    false));
 
   GURL localhost("http://localhost:80");
   UrlList names;
   names.push_back(localhost);
 
   testing_master->ResolveList(names, UrlInfo::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(PredictorTest, SingleLookupTest) {
-  scoped_refptr<Predictor> testing_master =
+  scoped_refptr<Predictor> testing_master(
       new Predictor(host_resolver_.get(),
                     default_max_queueing_delay_,
                     PredictorInit::kMaxSpeculativeParallelResolves,
-                    false);
+                    false));
 
   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));
 
   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_dns_lookups());
 
   testing_master->Shutdown();
 }
 
 TEST_F(PredictorTest, ConcurrentLookupTest) {
   host_resolver_->rules()->AddSimulatedFailure("*.notfound");
 
-  scoped_refptr<Predictor> testing_master =
+  scoped_refptr<Predictor> testing_master(
       new Predictor(host_resolver_.get(),
                     default_max_queueing_delay_,
                     PredictorInit::kMaxSpeculativeParallelResolves,
-                    false);
+                    false));
 
   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);
@@ skipping 25 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");
 
-  scoped_refptr<Predictor> testing_master =
+  scoped_refptr<Predictor> testing_master(
       new Predictor(host_resolver_.get(),
                     default_max_queueing_delay_,
                     PredictorInit::kMaxSpeculativeParallelResolves,
-                    false);
+                    false));
 
   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 95 matching lines @@
       return true;
     }
   }
   return false;
 }
 
 //------------------------------------------------------------------------------
 
 // Make sure nil referral lists really have no entries, and no latency listed.
 TEST_F(PredictorTest, ReferrerSerializationNilTest) {
-  scoped_refptr<Predictor> predictor =
+  scoped_refptr<Predictor> predictor(
       new Predictor(host_resolver_.get(),
                     default_max_queueing_delay_,
                     PredictorInit::kMaxSpeculativeParallelResolves,
-                    false);
+                    false));
   scoped_ptr<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) {
-  scoped_refptr<Predictor> predictor =
+  scoped_refptr<Predictor> predictor(
       new Predictor(host_resolver_.get(),
                     default_max_queueing_delay_,
                     PredictorInit::kMaxSpeculativeParallelResolves,
-                    false);
+                    false));
   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<ListValue> referral_list(NewEmptySerializationList());
 
   AddToSerializedList(motivation_url, subresource_url,
       kUseRate, referral_list.get());
 
   predictor->DeserializeReferrers(*referral_list.get());
 
   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();
 }
 
 // Make sure the Trim() functionality works as expected.
 TEST_F(PredictorTest, ReferrerSerializationTrimTest) {
-  scoped_refptr<Predictor> predictor =
+  scoped_refptr<Predictor> predictor(
       new Predictor(host_resolver_.get(),
                     default_max_queueing_delay_,
                     PredictorInit::kMaxSpeculativeParallelResolves,
-                    false);
+                    false));
   GURL motivation_url("http://www.google.com:110");
 
   GURL icon_subresource_url("http://icons.google.com:111");
   const double kRateIcon = 16.0 * Predictor::kPersistWorthyExpectedValue;
   GURL img_subresource_url("http://img.google.com:118");
   const double kRateImg = 8.0 * Predictor::kPersistWorthyExpectedValue;
 
   scoped_ptr<ListValue> referral_list(NewEmptySerializationList());
   AddToSerializedList(
       motivation_url, icon_subresource_url, kRateIcon, referral_list.get());
@@ skipping 163 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());
 }
 
 }  // namespace chrome_browser_net