Convert implicit scoped_refptr constructor calls to explicit ones, part 1

net/base/cookie_monster_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 <string>
 
 #include "base/basictypes.h"
 #include "base/platform_thread.h"
@@ skipping 1834 matching lines @@
     {"https://www.google.com", "b", "2", ".google.com", "/path/from/cookie",
      expires + TimeDelta::FromSeconds(10), true, true},
     {"https://google.com", "c", "3", "", "/another/path/to/cookie",
      base::Time::Now() + base::TimeDelta::FromSeconds(100),
      true, false}
   };
   const int INPUT_DELETE = 1;
 
   // 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,
                                               p->domain, p->path, p->expires,
                                               p->secure, p->http_only));
     }
     cmout->DeleteCookie(GURL(std::string(input_info[INPUT_DELETE].gurl) +
                              input_info[INPUT_DELETE].path),
                         input_info[INPUT_DELETE].name);
   }
 
   // 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
     // will come first, and we need to swap them.
     std::swap(cookies[0], cookies[1]);
     for (int output_index = 0; output_index < 2; output_index++) {
       int input_index = output_index * 2;
       const CookiesInputInfo* input = &input_info[input_index];
       const CookieMonster::CanonicalCookie* output = &cookies[output_index];
 
       EXPECT_EQ(input->name, output->Name());
       EXPECT_EQ(input->value, output->Value());
       EXPECT_EQ(GURL(input->gurl).host(), output->Domain());
       EXPECT_EQ(input->path, output->Path());
       EXPECT_LE(current.ToInternalValue(),
                 output->CreationDate().ToInternalValue());
       EXPECT_EQ(input->secure, output->IsSecure());
       EXPECT_EQ(input->http_only, output->IsHttpOnly());
       EXPECT_TRUE(output->IsPersistent());
       EXPECT_EQ(input->expires.ToInternalValue(),
                 output->ExpiryDate().ToInternalValue());
     }
   }
 }
 
 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"),
                             "d=1; domain=b.a.google.com"));
   EXPECT_TRUE(cm->SetCookie(GURL("http://b.a.google.com/aa/bb/cc/x.html"),
                             "a=4; domain=b.a.google.com"));
   EXPECT_TRUE(cm->SetCookie(GURL("http://c.b.a.google.com/aa/bb/cc/x.html"),
                             "e=1; domain=c.b.a.google.com"));
   EXPECT_TRUE(cm->SetCookie(GURL("http://d.c.b.a.google.com/aa/bb/x.html"),
                             "b=1"));
@@ skipping 41 matching lines @@
 // This test and CookieMonstertest.TestGCTimes (in cookie_monster_perftest.cc)
 // are somewhat complementary twins.  This test is probing for whether
 // garbage collection always happens when it should (i.e. that we actually
 // get rid of cookies when we should).  The perftest is probing for
 // whether garbage collection happens when it shouldn't.  See comments
 // before that test for more details.
 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());
   }
 
   // Now we explore a series of relationships between cookie last access
   // time and size of store to make sure we only get rid of cookies when
   // we really should.
   const struct TestCase {
     int num_cookies;
@@ skipping 37 matching lines @@
     CookieMonster::EKS_KEEP_RECENT_AND_PURGE_ETLDP1,
     CookieMonster::EKS_DISCARD_RECENT_AND_PURGE_DOMAIN,
   };
 
   for (int ci = 0; ci < static_cast<int>(ARRAYSIZE_UNSAFE(test_cases)); ++ci) {
     // Test both old and new key and expiry schemes.
     for (int recent_scheme = 0;
          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()))
           << "For test case " << ci;
       // Will trigger GC
       cm->SetCookie(GURL("http://newdomain.com"), "b=2");
       EXPECT_EQ(test_case->expected_cookies_after_set[recent_scheme],
                 static_cast<int>((cm->GetAllCookies().size())))
           << "For test case (" << ci << ", " << recent_scheme << ")";
     }
   }
 }
 
 }  // namespace