Convert implicit scoped_refptr constructor calls to explicit ones, part 1

webkit/appcache/appcache_group_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 <string>
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/appcache/appcache.h"
 #include "webkit/appcache/appcache_group.h"
 #include "webkit/appcache/appcache_host.h"
@@ skipping 81 matching lines @@
   }
 
   bool update_completed_;
 };
 
 class AppCacheGroupTest : public testing::Test {
 };
 
 TEST(AppCacheGroupTest, AddRemoveCache) {
   MockAppCacheService service;
-  scoped_refptr<AppCacheGroup> group =
-      new AppCacheGroup(&service, GURL("http://foo.com"), 111);
+  scoped_refptr<AppCacheGroup> group(
+      new AppCacheGroup(&service, GURL("http://foo.com"), 111));
 
   base::Time now = base::Time::Now();
 
-  scoped_refptr<AppCache> cache1 = new AppCache(&service, 111);
+  scoped_refptr<AppCache> cache1(new AppCache(&service, 111));
   cache1->set_complete(true);
   cache1->set_update_time(now);
   group->AddCache(cache1);
   EXPECT_EQ(cache1, group->newest_complete_cache());
 
   // Adding older cache does not change newest complete cache.
-  scoped_refptr<AppCache> cache2 = new AppCache(&service, 222);
+  scoped_refptr<AppCache> cache2(new AppCache(&service, 222));
   cache2->set_complete(true);
   cache2->set_update_time(now - base::TimeDelta::FromDays(1));
   group->AddCache(cache2);
   EXPECT_EQ(cache1, group->newest_complete_cache());
 
   // Adding newer cache does change newest complete cache.
-  scoped_refptr<AppCache> cache3 = new AppCache(&service, 333);
+  scoped_refptr<AppCache> cache3(new AppCache(&service, 333));
   cache3->set_complete(true);
   cache3->set_update_time(now + base::TimeDelta::FromDays(1));
   group->AddCache(cache3);
   EXPECT_EQ(cache3, group->newest_complete_cache());
 
   // Adding cache with same update time uses one with larger ID.
-  scoped_refptr<AppCache> cache4 = new AppCache(&service, 444);
+  scoped_refptr<AppCache> cache4(new AppCache(&service, 444));
   cache4->set_complete(true);
   cache4->set_update_time(now + base::TimeDelta::FromDays(1));  // same as 3
   group->AddCache(cache4);
   EXPECT_EQ(cache4, group->newest_complete_cache());
 
-  scoped_refptr<AppCache> cache5 = new AppCache(&service, 55);  // smaller id
+  scoped_refptr<AppCache> cache5(new AppCache(&service, 55));  // smaller id
   cache5->set_complete(true);
   cache5->set_update_time(now + base::TimeDelta::FromDays(1));  // same as 4
   group->AddCache(cache5);
   EXPECT_EQ(cache4, group->newest_complete_cache());  // no change
 
   // Old caches can always be removed.
   group->RemoveCache(cache1);
   EXPECT_FALSE(cache1->owning_group());
   EXPECT_EQ(cache4, group->newest_complete_cache());  // newest unchanged
 
@@ skipping 57 matching lines @@
   // Unassociate all hosts from older cache.
   host1.AssociateCache(NULL);
   host2.AssociateCache(NULL);
   EXPECT_EQ(frontend.last_host_id_, host2.host_id());
   EXPECT_EQ(frontend.last_cache_id_, appcache::kNoCacheId);
   EXPECT_EQ(frontend.last_status_, appcache::UNCACHED);
 }
 
 TEST(AppCacheGroupTest, StartUpdate) {
   MockAppCacheService service;
-  scoped_refptr<AppCacheGroup> group =
-      new AppCacheGroup(&service, GURL("http://foo.com"), 111);
+  scoped_refptr<AppCacheGroup> group(
+      new AppCacheGroup(&service, GURL("http://foo.com"), 111));
 
   // Set state to checking to prevent update job from executing fetches.
   group->update_status_ = AppCacheGroup::CHECKING;
   group->StartUpdate();
   AppCacheUpdateJob* update = group->update_job_;
   EXPECT_TRUE(update != NULL);
 
   // Start another update, check that same update job is in use.
   group->StartUpdateWithHost(NULL);
   EXPECT_EQ(update, group->update_job_);
 
   // Deleting the update should restore the group to IDLE.
   delete update;
   EXPECT_TRUE(group->update_job_ == NULL);
   EXPECT_EQ(AppCacheGroup::IDLE, group->update_status());
 }
 
 TEST(AppCacheGroupTest, CancelUpdate) {
   MockAppCacheService service;
-  scoped_refptr<AppCacheGroup> group =
-      new AppCacheGroup(&service, GURL("http://foo.com"), 111);
+  scoped_refptr<AppCacheGroup> group(
+      new AppCacheGroup(&service, GURL("http://foo.com"), 111));
 
   // Set state to checking to prevent update job from executing fetches.
   group->update_status_ = AppCacheGroup::CHECKING;
   group->StartUpdate();
   AppCacheUpdateJob* update = group->update_job_;
   EXPECT_TRUE(update != NULL);
 
   // Deleting the group should cancel the update.
   TestUpdateObserver observer;
   group->AddUpdateObserver(&observer);
   group = NULL;  // causes group to be deleted
   EXPECT_TRUE(observer.update_completed_);
   EXPECT_FALSE(observer.group_has_cache_);
 }
 
 TEST(AppCacheGroupTest, QueueUpdate) {
   MockAppCacheService service;
-  scoped_refptr<AppCacheGroup> group =
-      new AppCacheGroup(&service, GURL("http://foo.com"), 111);
+  scoped_refptr<AppCacheGroup> group(
+      new AppCacheGroup(&service, GURL("http://foo.com"), 111));
 
   // Set state to checking to prevent update job from executing fetches.
   group->update_status_ = AppCacheGroup::CHECKING;
   group->StartUpdate();
   EXPECT_TRUE(group->update_job_);
 
   // Pretend group's update job is terminating so that next update is queued.
   group->update_job_->internal_state_ = AppCacheUpdateJob::REFETCH_MANIFEST;
   EXPECT_TRUE(group->update_job_->IsTerminating());
 
@@ skipping 25 matching lines @@
   EXPECT_TRUE(group->FindObserver(&host, group->observers_));
 
   // Delete update to cause it to complete. Verify host is notified.
   delete group->update_job_;
   EXPECT_EQ(AppCacheGroup::IDLE, group->update_status_);
   EXPECT_FALSE(group->restart_update_task_);
   EXPECT_TRUE(host.update_completed_);
 }
 
 }  // namespace appcache