Convert implicit scoped_refptr constructor calls to explicit ones, part 1

This CL was created automatically by this clang rewriter: http://codereview.appspot.com/2776043/ . I manually fixed a few rough spots of the rewriter output (doh1-3) and fixed all presubmit errors.

BUG=28083
TEST=None

Review URL: http://codereview.chromium.org/4192012

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@64573 0039d316-1c4b-4281-b951-d872f2087c98

9 files changed, 104 insertions, 104 deletions

diff --git a/net/base/cookie_monster_perftest.cc b/net/base/cookie_monster_perftest.cc
index c006128..8c64d9a 100644
--- a/net/base/cookie_monster_perftest.cc
+++ b/net/base/cookie_monster_perftest.cc
@@ -283,10 +283,10 @@ TEST(CookieMonsterTest, TestGCTimes) {
   };
   for (int ci = 0; ci < static_cast<int>(ARRAYSIZE_UNSAFE(test_cases)); ++ci) {
     const TestCase& test_case(test_cases[ci]);
-    scoped_refptr<CookieMonster> cm =
+    scoped_refptr<CookieMonster> cm(
         CreateMonsterFromStoreForGC(
             test_case.num_cookies, test_case.num_old_cookies,
-            CookieMonster::kSafeFromGlobalPurgeDays * 2);
+            CookieMonster::kSafeFromGlobalPurgeDays * 2));
 
     GURL gurl("http://google.com");
     std::string cookie_line("z=3");
diff --git a/net/base/cookie_monster_unittest.cc b/net/base/cookie_monster_unittest.cc
index f4cca57..751b255 100644
--- a/net/base/cookie_monster_unittest.cc
+++ b/net/base/cookie_monster_unittest.cc
@@ -1852,7 +1852,7 @@ TEST(CookieMonsterTest, BackingStoreCommunication) {
 
   // Create new cookies and flush them to the store.
   {
-    scoped_refptr<net::CookieMonster> cmout = new CookieMonster(store, NULL);
+    scoped_refptr<net::CookieMonster> cmout(new CookieMonster(store, NULL));
     for (const CookiesInputInfo* p = input_info;
          p < &input_info[ARRAYSIZE_UNSAFE(input_info)]; p++) {
       EXPECT_TRUE(cmout->SetCookieWithDetails(GURL(p->gurl), p->name, p->value,
@@ -1866,7 +1866,7 @@ TEST(CookieMonsterTest, BackingStoreCommunication) {
 
   // Create a new cookie monster and make sure that everything is correct
   {
-    scoped_refptr<net::CookieMonster> cmin = new CookieMonster(store, NULL);
+    scoped_refptr<net::CookieMonster> cmin(new CookieMonster(store, NULL));
     CookieMonster::CookieList cookies(cmin->GetAllCookies());
     ASSERT_EQ(2u, cookies.size());
     // Ordering is path length, then creation time.  So second cookie
@@ -1895,7 +1895,7 @@ TEST(CookieMonsterTest, BackingStoreCommunication) {
 TEST(CookieMonsterTest, CookieOrdering) {
   // Put a random set of cookies into a monster and make sure
   // they're returned in the right order.
-  scoped_refptr<net::CookieMonster> cm = new CookieMonster(NULL, NULL);
+  scoped_refptr<net::CookieMonster> cm(new CookieMonster(NULL, NULL));
   EXPECT_TRUE(cm->SetCookie(GURL("http://d.c.b.a.google.com/aa/x.html"),
                             "c=1"));
   EXPECT_TRUE(cm->SetCookie(GURL("http://b.a.google.com/aa/bb/cc/x.html"),
@@ -1957,8 +1957,8 @@ TEST(CookieMonsterTest, GarbageCollectionTriggers) {
   // First we check to make sure that a whole lot of recent cookies
   // doesn't get rid of anything after garbage collection is checked for.
   {
-    scoped_refptr<net::CookieMonster> cm =
-        CreateMonsterForGC(CookieMonster::kMaxCookies * 2);
+    scoped_refptr<net::CookieMonster> cm(
+        CreateMonsterForGC(CookieMonster::kMaxCookies * 2));
     EXPECT_EQ(CookieMonster::kMaxCookies * 2, cm->GetAllCookies().size());
     cm->SetCookie(GURL("http://newdomain.com"), "b=2");
     EXPECT_EQ(CookieMonster::kMaxCookies * 2 + 1, cm->GetAllCookies().size());
@@ -2016,10 +2016,10 @@ TEST(CookieMonsterTest, GarbageCollectionTriggers) {
          recent_scheme < static_cast<int>(ARRAYSIZE_UNSAFE(schemes));
          recent_scheme++) {
       const TestCase *test_case = &test_cases[ci];
-      scoped_refptr<net::CookieMonster> cm =
+      scoped_refptr<net::CookieMonster> cm(
           CreateMonsterFromStoreForGC(
               test_case->num_cookies, test_case->num_old_cookies,
-              CookieMonster::kSafeFromGlobalPurgeDays * 2);
+              CookieMonster::kSafeFromGlobalPurgeDays * 2));
       cm->SetExpiryAndKeyScheme(schemes[recent_scheme]);
       EXPECT_EQ(test_case->expected_initial_cookies,
                 static_cast<int>(cm->GetAllCookies().size()))
diff --git a/net/base/directory_lister_unittest.cc b/net/base/directory_lister_unittest.cc
index f75d8d8..5607bc5 100644
--- a/net/base/directory_lister_unittest.cc
+++ b/net/base/directory_lister_unittest.cc
@@ -77,8 +77,8 @@ TEST(DirectoryListerTest, BigDirTest) {
   ASSERT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &path));
 
   ListerDelegate delegate(false);
-  scoped_refptr<net::DirectoryLister> lister =
-      new net::DirectoryLister(path, &delegate);
+  scoped_refptr<net::DirectoryLister> lister(
+      new net::DirectoryLister(path, &delegate));
 
   lister->Start();
 
@@ -92,11 +92,11 @@ TEST(DirectoryListerTest, BigDirRecursiveTest) {
   ASSERT_TRUE(PathService::Get(base::DIR_EXE, &path));
 
   ListerDelegate delegate(true);
-  scoped_refptr<net::DirectoryLister> lister =
+  scoped_refptr<net::DirectoryLister> lister(
       new net::DirectoryLister(path,
                                true,
                                net::DirectoryLister::FULL_PATH,
-                               &delegate);
+                               &delegate));
 
   lister->Start();
 
@@ -110,8 +110,8 @@ TEST(DirectoryListerTest, CancelTest) {
   ASSERT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &path));
 
   ListerDelegate delegate(false);
-  scoped_refptr<net::DirectoryLister> lister =
-      new net::DirectoryLister(path, &delegate);
+  scoped_refptr<net::DirectoryLister> lister(
+      new net::DirectoryLister(path, &delegate));
 
   lister->Start();
   lister->Cancel();
diff --git a/net/base/host_resolver_impl.cc b/net/base/host_resolver_impl.cc
index 3805979..ea1788e 100644
--- a/net/base/host_resolver_impl.cc
+++ b/net/base/host_resolver_impl.cc
@@ -1371,7 +1371,7 @@ void HostResolverImpl::ProcessQueuedRequests() {
   if (!top_req)
     return;
 
-  scoped_refptr<Job> job = CreateAndStartJob(top_req);
+  scoped_refptr<Job> job(CreateAndStartJob(top_req));
 
   // Search for any other pending request which can piggy-back off this job.
   for (size_t pool_i = 0; pool_i < POOL_COUNT; ++pool_i) {
@@ -1401,8 +1401,8 @@ HostResolverImpl::Job* HostResolverImpl::CreateAndStartJob(Request* req) {
   req->request_net_log().AddEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_CREATE_JOB,
                                   NULL);
 
-  scoped_refptr<Job> job = new Job(next_job_id_++, this, key,
-                                   req->request_net_log(), net_log_);
+  scoped_refptr<Job> job(new Job(next_job_id_++, this, key,
+                                   req->request_net_log(), net_log_));
   job->AddRequest(req);
   AddOutstandingJob(job);
   job->Start();
diff --git a/net/base/host_resolver_impl_unittest.cc b/net/base/host_resolver_impl_unittest.cc
index 07e00bf..f3bdb74 100644
--- a/net/base/host_resolver_impl_unittest.cc
+++ b/net/base/host_resolver_impl_unittest.cc
@@ -259,8 +259,8 @@ TEST_F(HostResolverImplTest, SynchronousLookup) {
   AddressList addrlist;
   const int kPortnum = 80;
 
-  scoped_refptr<RuleBasedHostResolverProc> resolver_proc =
-      new RuleBasedHostResolverProc(NULL);
+  scoped_refptr<RuleBasedHostResolverProc> resolver_proc(
+      new RuleBasedHostResolverProc(NULL));
   resolver_proc->AddRule("just.testing", "192.168.1.42");
 
   scoped_ptr<HostResolver> host_resolver(
@@ -291,8 +291,8 @@ TEST_F(HostResolverImplTest, AsynchronousLookup) {
   AddressList addrlist;
   const int kPortnum = 80;
 
-  scoped_refptr<RuleBasedHostResolverProc> resolver_proc =
-      new RuleBasedHostResolverProc(NULL);
+  scoped_refptr<RuleBasedHostResolverProc> resolver_proc(
+      new RuleBasedHostResolverProc(NULL));
   resolver_proc->AddRule("just.testing", "192.168.1.42");
 
   scoped_ptr<HostResolver> host_resolver(
@@ -328,8 +328,8 @@ TEST_F(HostResolverImplTest, AsynchronousLookup) {
 }
 
 TEST_F(HostResolverImplTest, CanceledAsynchronousLookup) {
-  scoped_refptr<WaitingHostResolverProc> resolver_proc =
-      new WaitingHostResolverProc(NULL);
+  scoped_refptr<WaitingHostResolverProc> resolver_proc(
+      new WaitingHostResolverProc(NULL));
 
   CapturingNetLog net_log(CapturingNetLog::kUnbounded);
   CapturingBoundNetLog log(CapturingNetLog::kUnbounded);
@@ -390,8 +390,8 @@ TEST_F(HostResolverImplTest, CanceledAsynchronousLookup) {
 TEST_F(HostResolverImplTest, NumericIPv4Address) {
   // Stevens says dotted quads with AI_UNSPEC resolve to a single sockaddr_in.
 
-  scoped_refptr<RuleBasedHostResolverProc> resolver_proc =
-      new RuleBasedHostResolverProc(NULL);
+  scoped_refptr<RuleBasedHostResolverProc> resolver_proc(
+      new RuleBasedHostResolverProc(NULL));
   resolver_proc->AllowDirectLookup("*");
 
   scoped_ptr<HostResolver> host_resolver(
@@ -413,8 +413,8 @@ TEST_F(HostResolverImplTest, NumericIPv4Address) {
 }
 
 TEST_F(HostResolverImplTest, NumericIPv6Address) {
-  scoped_refptr<RuleBasedHostResolverProc> resolver_proc =
-      new RuleBasedHostResolverProc(NULL);
+  scoped_refptr<RuleBasedHostResolverProc> resolver_proc(
+      new RuleBasedHostResolverProc(NULL));
   resolver_proc->AllowDirectLookup("*");
 
   // Resolve a plain IPv6 address.  Don't worry about [brackets], because
@@ -445,8 +445,8 @@ TEST_F(HostResolverImplTest, NumericIPv6Address) {
 }
 
 TEST_F(HostResolverImplTest, EmptyHost) {
-  scoped_refptr<RuleBasedHostResolverProc> resolver_proc =
-      new RuleBasedHostResolverProc(NULL);
+  scoped_refptr<RuleBasedHostResolverProc> resolver_proc(
+      new RuleBasedHostResolverProc(NULL));
   resolver_proc->AllowDirectLookup("*");
 
   scoped_ptr<HostResolver> host_resolver(
@@ -459,8 +459,8 @@ TEST_F(HostResolverImplTest, EmptyHost) {
 }
 
 TEST_F(HostResolverImplTest, LongHost) {
-  scoped_refptr<RuleBasedHostResolverProc> resolver_proc =
-      new RuleBasedHostResolverProc(NULL);
+  scoped_refptr<RuleBasedHostResolverProc> resolver_proc(
+      new RuleBasedHostResolverProc(NULL));
   resolver_proc->AllowDirectLookup("*");
 
   scoped_ptr<HostResolver> host_resolver(
@@ -523,8 +523,8 @@ class DeDupeRequestsVerifier : public ResolveRequest::Delegate {
 TEST_F(HostResolverImplTest, DeDupeRequests) {
   // Use a capturing resolver_proc, since the verifier needs to know what calls
   // reached Resolve().  Also, the capturing resolver_proc is initially blocked.
-  scoped_refptr<CapturingHostResolverProc> resolver_proc =
-      new CapturingHostResolverProc(NULL);
+  scoped_refptr<CapturingHostResolverProc> resolver_proc(
+      new CapturingHostResolverProc(NULL));
 
   scoped_ptr<HostResolver> host_resolver(
       CreateHostResolverImpl(resolver_proc));
@@ -574,8 +574,8 @@ TEST_F(HostResolverImplTest, CancelMultipleRequests) {
   // Use a capturing resolver_proc, since the verifier needs to know what calls
   // reached Resolver().  Also, the capturing resolver_proc is initially
   // blocked.
-  scoped_refptr<CapturingHostResolverProc> resolver_proc =
-      new CapturingHostResolverProc(NULL);
+  scoped_refptr<CapturingHostResolverProc> resolver_proc(
+      new CapturingHostResolverProc(NULL));
 
   scoped_ptr<HostResolver> host_resolver(
       CreateHostResolverImpl(resolver_proc));
@@ -661,8 +661,8 @@ TEST_F(HostResolverImplTest, CancelWithinCallback) {
   // Use a capturing resolver_proc, since the verifier needs to know what calls
   // reached Resolver().  Also, the capturing resolver_proc is initially
   // blocked.
-  scoped_refptr<CapturingHostResolverProc> resolver_proc =
-      new CapturingHostResolverProc(NULL);
+  scoped_refptr<CapturingHostResolverProc> resolver_proc(
+      new CapturingHostResolverProc(NULL));
 
   scoped_ptr<HostResolver> host_resolver(
       CreateHostResolverImpl(resolver_proc));
@@ -718,8 +718,8 @@ TEST_F(HostResolverImplTest, DeleteWithinCallback) {
   // Use a capturing resolver_proc, since the verifier needs to know what calls
   // reached Resolver().  Also, the capturing resolver_proc is initially
   // blocked.
-  scoped_refptr<CapturingHostResolverProc> resolver_proc =
-      new CapturingHostResolverProc(NULL);
+  scoped_refptr<CapturingHostResolverProc> resolver_proc(
+      new CapturingHostResolverProc(NULL));
 
   // The class will receive callbacks for when each resolve completes. It
   // checks that the right things happened. Note that the verifier holds the
@@ -773,8 +773,8 @@ TEST_F(HostResolverImplTest, StartWithinCallback) {
   // Use a capturing resolver_proc, since the verifier needs to know what calls
   // reached Resolver().  Also, the capturing resolver_proc is initially
   // blocked.
-  scoped_refptr<CapturingHostResolverProc> resolver_proc =
-      new CapturingHostResolverProc(NULL);
+  scoped_refptr<CapturingHostResolverProc> resolver_proc(
+      new CapturingHostResolverProc(NULL));
 
   // Turn off caching for this host resolver.
   scoped_ptr<HostResolver> host_resolver(
@@ -1105,8 +1105,8 @@ TEST_F(HostResolverImplTest, FlushCacheOnIPAddressChange) {
 
 // Test that IP address changes send ERR_ABORTED to pending requests.
 TEST_F(HostResolverImplTest, AbortOnIPAddressChanged) {
-  scoped_refptr<WaitingHostResolverProc> resolver_proc =
-      new WaitingHostResolverProc(NULL);
+  scoped_refptr<WaitingHostResolverProc> resolver_proc(
+      new WaitingHostResolverProc(NULL));
   HostCache* cache = CreateDefaultCache();
   scoped_ptr<HostResolver> host_resolver(
       new HostResolverImpl(resolver_proc, cache, kMaxJobs, NULL));
@@ -1130,8 +1130,8 @@ TEST_F(HostResolverImplTest, AbortOnIPAddressChanged) {
 
 // Obey pool constraints after IP address has changed.
 TEST_F(HostResolverImplTest, ObeyPoolConstraintsAfterIPAddressChange) {
-  scoped_refptr<WaitingHostResolverProc> resolver_proc =
-      new WaitingHostResolverProc(NULL);
+  scoped_refptr<WaitingHostResolverProc> resolver_proc(
+      new WaitingHostResolverProc(NULL));
   scoped_ptr<MockHostResolver> host_resolver(new MockHostResolver());
   host_resolver->Reset(resolver_proc);
 
@@ -1202,8 +1202,8 @@ class ResolveWithinCallback : public CallbackRunner< Tuple1<int> > {
 };
 
 TEST_F(HostResolverImplTest, OnlyAbortExistingRequestsOnIPAddressChange) {
-  scoped_refptr<WaitingHostResolverProc> resolver_proc =
-      new WaitingHostResolverProc(NULL);
+  scoped_refptr<WaitingHostResolverProc> resolver_proc(
+      new WaitingHostResolverProc(NULL));
   scoped_ptr<MockHostResolver> host_resolver(new MockHostResolver());
   host_resolver->Reset(resolver_proc);
 
@@ -1227,8 +1227,8 @@ TEST_F(HostResolverImplTest, OnlyAbortExistingRequestsOnIPAddressChange) {
 // Tests that when the maximum threads is set to 1, requests are dequeued
 // in order of priority.
 TEST_F(HostResolverImplTest, HigherPriorityRequestsStartedFirst) {
-  scoped_refptr<CapturingHostResolverProc> resolver_proc =
-      new CapturingHostResolverProc(NULL);
+  scoped_refptr<CapturingHostResolverProc> resolver_proc(
+      new CapturingHostResolverProc(NULL));
 
   // This HostResolverImpl will only allow 1 outstanding resolve at a time.
   size_t kMaxJobs = 1u;
@@ -1312,8 +1312,8 @@ TEST_F(HostResolverImplTest, HigherPriorityRequestsStartedFirst) {
 
 // Try cancelling a request which has not been attached to a job yet.
 TEST_F(HostResolverImplTest, CancelPendingRequest) {
-  scoped_refptr<CapturingHostResolverProc> resolver_proc =
-      new CapturingHostResolverProc(NULL);
+  scoped_refptr<CapturingHostResolverProc> resolver_proc(
+      new CapturingHostResolverProc(NULL));
 
   // This HostResolverImpl will only allow 1 outstanding resolve at a time.
   const size_t kMaxJobs = 1u;
@@ -1375,8 +1375,8 @@ TEST_F(HostResolverImplTest, CancelPendingRequest) {
 
 // Test that when too many requests are enqueued, old ones start to be aborted.
 TEST_F(HostResolverImplTest, QueueOverflow) {
-  scoped_refptr<CapturingHostResolverProc> resolver_proc =
-      new CapturingHostResolverProc(NULL);
+  scoped_refptr<CapturingHostResolverProc> resolver_proc(
+      new CapturingHostResolverProc(NULL));
 
   // This HostResolverImpl will only allow 1 outstanding resolve at a time.
   const size_t kMaxOutstandingJobs = 1u;
@@ -1453,8 +1453,8 @@ TEST_F(HostResolverImplTest, QueueOverflow) {
 // Tests that after changing the default AddressFamily to IPV4, requests
 // with UNSPECIFIED address family map to IPV4.
 TEST_F(HostResolverImplTest, SetDefaultAddressFamily_IPv4) {
-  scoped_refptr<CapturingHostResolverProc> resolver_proc =
-      new CapturingHostResolverProc(new EchoingHostResolverProc);
+  scoped_refptr<CapturingHostResolverProc> resolver_proc(
+      new CapturingHostResolverProc(new EchoingHostResolverProc));
 
   // This HostResolverImpl will only allow 1 outstanding resolve at a time.
   const size_t kMaxOutstandingJobs = 1u;
@@ -1521,8 +1521,8 @@ TEST_F(HostResolverImplTest, SetDefaultAddressFamily_IPv4) {
 // of requests 0 and 1 is flipped, and the default is set to IPv6 in place of
 // IPv4.
 TEST_F(HostResolverImplTest, SetDefaultAddressFamily_IPv6) {
-  scoped_refptr<CapturingHostResolverProc> resolver_proc =
-      new CapturingHostResolverProc(new EchoingHostResolverProc);
+  scoped_refptr<CapturingHostResolverProc> resolver_proc(
+      new CapturingHostResolverProc(new EchoingHostResolverProc));
 
   // This HostResolverImpl will only allow 1 outstanding resolve at a time.
   const size_t kMaxOutstandingJobs = 1u;
@@ -1588,8 +1588,8 @@ TEST_F(HostResolverImplTest, SetDefaultAddressFamily_IPv6) {
 // This tests that the default address family is respected for synchronous
 // resolutions.
 TEST_F(HostResolverImplTest, SetDefaultAddressFamily_Synchronous) {
-  scoped_refptr<CapturingHostResolverProc> resolver_proc =
-      new CapturingHostResolverProc(new EchoingHostResolverProc);
+  scoped_refptr<CapturingHostResolverProc> resolver_proc(
+      new CapturingHostResolverProc(new EchoingHostResolverProc));
 
   const size_t kMaxOutstandingJobs = 10u;
   scoped_ptr<HostResolverImpl> host_resolver(new HostResolverImpl(
diff --git a/net/base/listen_socket.cc b/net/base/listen_socket.cc
index 0cb529d..c964ec9 100644
--- a/net/base/listen_socket.cc
+++ b/net/base/listen_socket.cc
@@ -121,8 +121,8 @@ SOCKET ListenSocket::Accept(SOCKET s) {
 void ListenSocket::Accept() {
   SOCKET conn = Accept(socket_);
   if (conn != kInvalidSocket) {
-    scoped_refptr<ListenSocket> sock =
-        new ListenSocket(conn, socket_delegate_);
+    scoped_refptr<ListenSocket> sock(
+        new ListenSocket(conn, socket_delegate_));
     // it's up to the delegate to AddRef if it wants to keep it around
 #if defined(OS_POSIX)
     sock->WatchSocket(WAITING_READ);
diff --git a/net/base/mock_host_resolver.cc b/net/base/mock_host_resolver.cc
index 9c82f93..9ee5c53 100644
--- a/net/base/mock_host_resolver.cc
+++ b/net/base/mock_host_resolver.cc
@@ -80,8 +80,8 @@ void MockHostResolverBase::Reset(HostResolverProc* interceptor) {
   synchronous_mode_ = false;
 
   // At the root of the chain, map everything to localhost.
-  scoped_refptr<RuleBasedHostResolverProc> catchall =
-      new RuleBasedHostResolverProc(NULL);
+  scoped_refptr<RuleBasedHostResolverProc> catchall(
+      new RuleBasedHostResolverProc(NULL));
   catchall->AddRule("*", "127.0.0.1");
 
   // Next add a rules-based layer the use controls.
diff --git a/net/base/x509_certificate_mac.cc b/net/base/x509_certificate_mac.cc
index 05fbe63..361e37c 100644
--- a/net/base/x509_certificate_mac.cc
+++ b/net/base/x509_certificate_mac.cc
@@ -872,10 +872,10 @@ bool X509Certificate::IsIssuedBy(
   for (int i = 0; i < n; ++i) {
     SecCertificateRef cert_handle = reinterpret_cast<SecCertificateRef>(
         const_cast<void*>(CFArrayGetValueAtIndex(cert_chain, i)));
-    scoped_refptr<X509Certificate> cert = X509Certificate::CreateFromHandle(
+    scoped_refptr<X509Certificate> cert(X509Certificate::CreateFromHandle(
         cert_handle,
         X509Certificate::SOURCE_LONE_CERT_IMPORT,
-        X509Certificate::OSCertHandles());
+        X509Certificate::OSCertHandles()));
     for (unsigned j = 0; j < valid_issuers.size(); j++) {
       if (cert->issuer().Matches(valid_issuers[j]))
         return true;
diff --git a/net/base/x509_certificate_unittest.cc b/net/base/x509_certificate_unittest.cc
index 9bb81cb..31173e4 100644
--- a/net/base/x509_certificate_unittest.cc
+++ b/net/base/x509_certificate_unittest.cc
@@ -252,9 +252,9 @@ void CheckGoogleCert(const scoped_refptr<X509Certificate>& google_cert,
 }
 
 TEST(X509CertificateTest, GoogleCertParsing) {
-  scoped_refptr<X509Certificate> google_cert =
+  scoped_refptr<X509Certificate> google_cert(
       X509Certificate::CreateFromBytes(
-          reinterpret_cast<const char*>(google_der), sizeof(google_der));
+          reinterpret_cast<const char*>(google_der), sizeof(google_der)));
 
   CheckGoogleCert(google_cert, google_fingerprint,
                   1238192407,   // Mar 27 22:20:07 2009 GMT
@@ -262,8 +262,8 @@ TEST(X509CertificateTest, GoogleCertParsing) {
 }
 
 TEST(X509CertificateTest, WebkitCertParsing) {
-  scoped_refptr<X509Certificate> webkit_cert = X509Certificate::CreateFromBytes(
-      reinterpret_cast<const char*>(webkit_der), sizeof(webkit_der));
+  scoped_refptr<X509Certificate> webkit_cert(X509Certificate::CreateFromBytes(
+      reinterpret_cast<const char*>(webkit_der), sizeof(webkit_der)));
 
   ASSERT_NE(static_cast<X509Certificate*>(NULL), webkit_cert);
 
@@ -318,8 +318,8 @@ TEST(X509CertificateTest, WebkitCertParsing) {
 }
 
 TEST(X509CertificateTest, ThawteCertParsing) {
-  scoped_refptr<X509Certificate> thawte_cert = X509Certificate::CreateFromBytes(
-      reinterpret_cast<const char*>(thawte_der), sizeof(thawte_der));
+  scoped_refptr<X509Certificate> thawte_cert(X509Certificate::CreateFromBytes(
+      reinterpret_cast<const char*>(thawte_der), sizeof(thawte_der)));
 
   ASSERT_NE(static_cast<X509Certificate*>(NULL), thawte_cert);
 
@@ -379,10 +379,10 @@ TEST(X509CertificateTest, ThawteCertParsing) {
 }
 
 TEST(X509CertificateTest, PaypalNullCertParsing) {
-  scoped_refptr<X509Certificate> paypal_null_cert =
+  scoped_refptr<X509Certificate> paypal_null_cert(
       X509Certificate::CreateFromBytes(
           reinterpret_cast<const char*>(paypal_null_der),
-          sizeof(paypal_null_der));
+          sizeof(paypal_null_der)));
 
   ASSERT_NE(static_cast<X509Certificate*>(NULL), paypal_null_cert);
 
@@ -409,8 +409,8 @@ TEST(X509CertificateTest, PaypalNullCertParsing) {
 // This certificate will expire on 2011-09-08.
 TEST(X509CertificateTest, UnoSoftCertParsing) {
   FilePath certs_dir = GetTestCertsDirectory();
-  scoped_refptr<X509Certificate> unosoft_hu_cert =
-      ImportCertFromFile(certs_dir, "unosoft_hu_cert.der");
+  scoped_refptr<X509Certificate> unosoft_hu_cert(
+      ImportCertFromFile(certs_dir, "unosoft_hu_cert.der"));
 
   ASSERT_NE(static_cast<X509Certificate*>(NULL), unosoft_hu_cert);
 
@@ -481,18 +481,18 @@ TEST(X509CertificateTest, Cache) {
   // certificate cache.
   google_cert_handle = X509Certificate::CreateOSCertHandleFromBytes(
       reinterpret_cast<const char*>(google_der), sizeof(google_der));
-  scoped_refptr<X509Certificate> cert1 = X509Certificate::CreateFromHandle(
+  scoped_refptr<X509Certificate> cert1(X509Certificate::CreateFromHandle(
       google_cert_handle, X509Certificate::SOURCE_LONE_CERT_IMPORT,
-      X509Certificate::OSCertHandles());
+      X509Certificate::OSCertHandles()));
   X509Certificate::FreeOSCertHandle(google_cert_handle);
 
   // Add a certificate from the same source (SOURCE_LONE_CERT_IMPORT).  This
   // should return the cached certificate (cert1).
   google_cert_handle = X509Certificate::CreateOSCertHandleFromBytes(
       reinterpret_cast<const char*>(google_der), sizeof(google_der));
-  scoped_refptr<X509Certificate> cert2 = X509Certificate::CreateFromHandle(
+  scoped_refptr<X509Certificate> cert2(X509Certificate::CreateFromHandle(
       google_cert_handle, X509Certificate::SOURCE_LONE_CERT_IMPORT,
-      X509Certificate::OSCertHandles());
+      X509Certificate::OSCertHandles()));
   X509Certificate::FreeOSCertHandle(google_cert_handle);
 
   EXPECT_EQ(cert1, cert2);
@@ -501,9 +501,9 @@ TEST(X509CertificateTest, Cache) {
   // cached certificate (cert1) and return a new certificate.
   google_cert_handle = X509Certificate::CreateOSCertHandleFromBytes(
       reinterpret_cast<const char*>(google_der), sizeof(google_der));
-  scoped_refptr<X509Certificate> cert3 = X509Certificate::CreateFromHandle(
+  scoped_refptr<X509Certificate> cert3(X509Certificate::CreateFromHandle(
       google_cert_handle, X509Certificate::SOURCE_FROM_NETWORK,
-      X509Certificate::OSCertHandles());
+      X509Certificate::OSCertHandles()));
   X509Certificate::FreeOSCertHandle(google_cert_handle);
 
   EXPECT_NE(cert1, cert3);
@@ -512,43 +512,43 @@ TEST(X509CertificateTest, Cache) {
   // certificate (cert3).
   google_cert_handle = X509Certificate::CreateOSCertHandleFromBytes(
       reinterpret_cast<const char*>(google_der), sizeof(google_der));
-  scoped_refptr<X509Certificate> cert4 = X509Certificate::CreateFromHandle(
+  scoped_refptr<X509Certificate> cert4(X509Certificate::CreateFromHandle(
       google_cert_handle, X509Certificate::SOURCE_FROM_NETWORK,
-      X509Certificate::OSCertHandles());
+      X509Certificate::OSCertHandles()));
   X509Certificate::FreeOSCertHandle(google_cert_handle);
 
   EXPECT_EQ(cert3, cert4);
 
   google_cert_handle = X509Certificate::CreateOSCertHandleFromBytes(
       reinterpret_cast<const char*>(google_der), sizeof(google_der));
-  scoped_refptr<X509Certificate> cert5 = X509Certificate::CreateFromHandle(
+  scoped_refptr<X509Certificate> cert5(X509Certificate::CreateFromHandle(
       google_cert_handle, X509Certificate::SOURCE_FROM_NETWORK,
-      X509Certificate::OSCertHandles());
+      X509Certificate::OSCertHandles()));
   X509Certificate::FreeOSCertHandle(google_cert_handle);
 
   EXPECT_EQ(cert3, cert5);
 }
 
 TEST(X509CertificateTest, Pickle) {
-  scoped_refptr<X509Certificate> cert1 = X509Certificate::CreateFromBytes(
-      reinterpret_cast<const char*>(google_der), sizeof(google_der));
+  scoped_refptr<X509Certificate> cert1(X509Certificate::CreateFromBytes(
+      reinterpret_cast<const char*>(google_der), sizeof(google_der)));
 
   Pickle pickle;
   cert1->Persist(&pickle);
 
   void* iter = NULL;
-  scoped_refptr<X509Certificate> cert2 =
-      X509Certificate::CreateFromPickle(pickle, &iter);
+  scoped_refptr<X509Certificate> cert2(
+      X509Certificate::CreateFromPickle(pickle, &iter));
 
   EXPECT_EQ(cert1, cert2);
 }
 
 TEST(X509CertificateTest, Policy) {
-  scoped_refptr<X509Certificate> google_cert = X509Certificate::CreateFromBytes(
-      reinterpret_cast<const char*>(google_der), sizeof(google_der));
+  scoped_refptr<X509Certificate> google_cert(X509Certificate::CreateFromBytes(
+      reinterpret_cast<const char*>(google_der), sizeof(google_der)));
 
-  scoped_refptr<X509Certificate> webkit_cert = X509Certificate::CreateFromBytes(
-      reinterpret_cast<const char*>(webkit_der), sizeof(webkit_der));
+  scoped_refptr<X509Certificate> webkit_cert(X509Certificate::CreateFromBytes(
+      reinterpret_cast<const char*>(webkit_der), sizeof(webkit_der)));
 
   CertPolicy policy;
 
@@ -581,18 +581,18 @@ TEST(X509CertificateTest, Policy) {
 
 #if defined(OS_MACOSX) || defined(OS_WIN)
 TEST(X509CertificateTest, IntermediateCertificates) {
-  scoped_refptr<X509Certificate> webkit_cert =
+  scoped_refptr<X509Certificate> webkit_cert(
       X509Certificate::CreateFromBytes(
-          reinterpret_cast<const char*>(webkit_der), sizeof(webkit_der));
+          reinterpret_cast<const char*>(webkit_der), sizeof(webkit_der)));
 
-  scoped_refptr<X509Certificate> thawte_cert =
+  scoped_refptr<X509Certificate> thawte_cert(
       X509Certificate::CreateFromBytes(
-          reinterpret_cast<const char*>(thawte_der), sizeof(thawte_der));
+          reinterpret_cast<const char*>(thawte_der), sizeof(thawte_der)));
 
-  scoped_refptr<X509Certificate> paypal_cert =
+  scoped_refptr<X509Certificate> paypal_cert(
       X509Certificate::CreateFromBytes(
           reinterpret_cast<const char*>(paypal_null_der),
-          sizeof(paypal_null_der));
+          sizeof(paypal_null_der)));
 
   X509Certificate::OSCertHandle google_handle;
   // Create object with no intermediates:
@@ -645,8 +645,8 @@ TEST(X509CertificateTest, IsIssuedBy) {
   FilePath certs_dir = GetTestCertsDirectory();
 
   // Test a client certificate from MIT.
-  scoped_refptr<X509Certificate> mit_davidben_cert =
-      ImportCertFromFile(certs_dir, "mit.davidben.der");
+  scoped_refptr<X509Certificate> mit_davidben_cert(
+      ImportCertFromFile(certs_dir, "mit.davidben.der"));
   ASSERT_NE(static_cast<X509Certificate*>(NULL), mit_davidben_cert);
 
   CertPrincipal mit_issuer;
@@ -662,8 +662,8 @@ TEST(X509CertificateTest, IsIssuedBy) {
   EXPECT_TRUE(mit_davidben_cert->IsIssuedBy(mit_issuers));
 
   // Test a client certificate from FOAF.ME.
-  scoped_refptr<X509Certificate> foaf_me_chromium_test_cert =
-      ImportCertFromFile(certs_dir, "foaf.me.chromium-test-cert.der");
+  scoped_refptr<X509Certificate> foaf_me_chromium_test_cert(
+      ImportCertFromFile(certs_dir, "foaf.me.chromium-test-cert.der"));
   ASSERT_NE(static_cast<X509Certificate*>(NULL), foaf_me_chromium_test_cert);
 
   CertPrincipal foaf_issuer;