Convert implicit scoped_refptr constructor calls to explicit ones, part 1

webkit/appcache/mock_appcache_storage_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 "base/message_loop.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/appcache/appcache.h"
 #include "webkit/appcache/appcache_group.h"
 #include "webkit/appcache/appcache_response.h"
 #include "webkit/appcache/appcache_storage.h"
@@ skipping 74 matching lines @@
 
 TEST_F(MockAppCacheStorageTest, LoadCache_NearHit) {
   // Attempt to load a cache that is currently in use
   // and does not require loading from disk. This
   // load should complete syncly.
   MockAppCacheService service;
 
   // Setup some preconditions. Make an 'unstored' cache for
   // us to load. The ctor should put it in the working set.
   int64 cache_id = service.storage()->NewCacheId();
-  scoped_refptr<AppCache> cache = new AppCache(&service, cache_id);
+  scoped_refptr<AppCache> cache(new AppCache(&service, cache_id));
 
   // Conduct the test.
   MockStorageDelegate delegate;
   service.storage()->LoadCache(cache_id, &delegate);
   EXPECT_EQ(cache_id, delegate.loaded_cache_id_);
   EXPECT_EQ(cache.get(), delegate.loaded_cache_.get());
 }
 
 TEST_F(MockAppCacheStorageTest, CreateGroup) {
   // Attempt to load/create a group that doesn't exist.
@@ skipping 44 matching lines @@
   // Attempt to load a cache that is not currently in use
   // and does require loading from disk. This
   // load should complete asyncly.
   MockAppCacheService service;
   MockAppCacheStorage* storage =
       reinterpret_cast<MockAppCacheStorage*>(service.storage());
 
   // Setup some preconditions. Create a group and newest cache that
   // appears to be "stored" and "not currently in use".
   GURL manifest_url("http://blah/");
-  scoped_refptr<AppCacheGroup> group =
-      new AppCacheGroup(&service, manifest_url, 111);
+  scoped_refptr<AppCacheGroup> group(
+      new AppCacheGroup(&service, manifest_url, 111));
   int64 cache_id = storage->NewCacheId();
-  scoped_refptr<AppCache> cache = new AppCache(&service, cache_id);
+  scoped_refptr<AppCache> cache(new AppCache(&service, cache_id));
   cache->set_complete(true);
   group->AddCache(cache);
   storage->AddStoredGroup(group);
   storage->AddStoredCache(cache);
 
   // Drop the references from above so the only refs to these
   // objects are from within the storage class. This is to make
   // these objects appear as "not currently in use".
   AppCache* cache_ptr = cache.get();
   AppCacheGroup* group_ptr = group.get();
@@ skipping 27 matching lines @@
 
 TEST_F(MockAppCacheStorageTest, StoreNewGroup) {
   // Store a group and its newest cache. Should complete asyncly.
   MockAppCacheService service;
   MockAppCacheStorage* storage =
       reinterpret_cast<MockAppCacheStorage*>(service.storage());
 
   // Setup some preconditions. Create a group and newest cache that
   // appears to be "unstored".
   GURL manifest_url("http://blah/");
-  scoped_refptr<AppCacheGroup> group =
-      new AppCacheGroup(&service, manifest_url, 111);
+  scoped_refptr<AppCacheGroup> group(
+      new AppCacheGroup(&service, manifest_url, 111));
   int64 cache_id = storage->NewCacheId();
-  scoped_refptr<AppCache> cache = new AppCache(&service, cache_id);
+  scoped_refptr<AppCache> cache(new AppCache(&service, cache_id));
   // Hold a ref to the cache simulate the UpdateJob holding that ref,
   // and hold a ref to the group to simulate the CacheHost holding that ref.
 
   // Conduct the store test.
   MockStorageDelegate delegate;
   EXPECT_TRUE(storage->stored_caches_.empty());
   EXPECT_TRUE(storage->stored_groups_.empty());
   storage->StoreGroupAndNewestCache(group, cache, &delegate);
   EXPECT_FALSE(delegate.stored_group_success_);
   EXPECT_TRUE(storage->stored_caches_.empty());
   EXPECT_TRUE(storage->stored_groups_.empty());
   MessageLoop::current()->RunAllPending();  // Do async task execution.
   EXPECT_TRUE(delegate.stored_group_success_);
   EXPECT_FALSE(storage->stored_caches_.empty());
   EXPECT_FALSE(storage->stored_groups_.empty());
   EXPECT_EQ(cache, group->newest_complete_cache());
   EXPECT_TRUE(cache->is_complete());
 }
 
 TEST_F(MockAppCacheStorageTest, StoreExistingGroup) {
   // Store a group and its newest cache. Should complete asyncly.
   MockAppCacheService service;
   MockAppCacheStorage* storage =
       reinterpret_cast<MockAppCacheStorage*>(service.storage());
 
   // Setup some preconditions. Create a group and old complete cache
   // that appear to be "stored", and a newest unstored complete cache.
   GURL manifest_url("http://blah/");
-  scoped_refptr<AppCacheGroup> group =
-      new AppCacheGroup(&service, manifest_url, 111);
+  scoped_refptr<AppCacheGroup> group(
+      new AppCacheGroup(&service, manifest_url, 111));
   int64 old_cache_id = storage->NewCacheId();
-  scoped_refptr<AppCache> old_cache = new AppCache(&service, old_cache_id);
+  scoped_refptr<AppCache> old_cache(new AppCache(&service, old_cache_id));
   old_cache->set_complete(true);
   group->AddCache(old_cache);
   storage->AddStoredGroup(group);
   storage->AddStoredCache(old_cache);
   int64 new_cache_id = storage->NewCacheId();
-  scoped_refptr<AppCache> new_cache = new AppCache(&service, new_cache_id);
+  scoped_refptr<AppCache> new_cache(new AppCache(&service, new_cache_id));
   // Hold our refs to simulate the UpdateJob holding these refs.
 
   // Conduct the test.
   MockStorageDelegate delegate;
   EXPECT_EQ(size_t(1), storage->stored_caches_.size());
   EXPECT_EQ(size_t(1), storage->stored_groups_.size());
   EXPECT_TRUE(storage->IsCacheStored(old_cache));
   EXPECT_FALSE(storage->IsCacheStored(new_cache));
   storage->StoreGroupAndNewestCache(group, new_cache, &delegate);
   EXPECT_FALSE(delegate.stored_group_success_);
@@ skipping 13 matching lines @@
 
 TEST_F(MockAppCacheStorageTest, StoreExistingGroupExistingCache) {
   // Store a group with updates to its existing newest complete cache.
   MockAppCacheService service;
   MockAppCacheStorage* storage =
       reinterpret_cast<MockAppCacheStorage*>(service.storage());
 
   // Setup some preconditions. Create a group and a complete cache that
   // appear to be "stored".
   GURL manifest_url("http://blah");
-  scoped_refptr<AppCacheGroup> group =
-      new AppCacheGroup(&service, manifest_url, 111);
+  scoped_refptr<AppCacheGroup> group(
+      new AppCacheGroup(&service, manifest_url, 111));
   int64 cache_id = storage->NewCacheId();
-  scoped_refptr<AppCache> cache = new AppCache(&service, cache_id);
+  scoped_refptr<AppCache> cache(new AppCache(&service, cache_id));
   cache->set_complete(true);
   group->AddCache(cache);
   storage->AddStoredGroup(group);
   storage->AddStoredCache(cache);
   // Hold our refs to simulate the UpdateJob holding these refs.
 
   // Change the group's newest cache.
   EXPECT_EQ(cache, group->newest_complete_cache());
   GURL entry_url("http://blah/blah");
   cache->AddEntry(entry_url, AppCacheEntry(AppCacheEntry::MASTER));
@@ skipping 18 matching lines @@
 
 TEST_F(MockAppCacheStorageTest, MakeGroupObsolete) {
   // Make a group obsolete, should complete asyncly.
   MockAppCacheService service;
   MockAppCacheStorage* storage =
       reinterpret_cast<MockAppCacheStorage*>(service.storage());
 
   // Setup some preconditions. Create a group and newest cache that
   // appears to be "stored" and "currently in use".
   GURL manifest_url("http://blah/");
-  scoped_refptr<AppCacheGroup> group =
-      new AppCacheGroup(&service, manifest_url, 111);
+  scoped_refptr<AppCacheGroup> group(
+      new AppCacheGroup(&service, manifest_url, 111));
   int64 cache_id = storage->NewCacheId();
-  scoped_refptr<AppCache> cache = new AppCache(&service, cache_id);
+  scoped_refptr<AppCache> cache(new AppCache(&service, cache_id));
   cache->set_complete(true);
   group->AddCache(cache);
   storage->AddStoredGroup(group);
   storage->AddStoredCache(cache);
   // Hold our refs to simulate the UpdateJob holding these refs.
 
   // Conduct the test.
   MockStorageDelegate delegate;
   EXPECT_FALSE(group->is_obsolete());
   EXPECT_EQ(size_t(1), storage->stored_caches_.size());
@@ skipping 21 matching lines @@
 
 TEST_F(MockAppCacheStorageTest, MarkEntryAsForeign) {
   // Should complete syncly.
   MockAppCacheService service;
   MockAppCacheStorage* storage =
       reinterpret_cast<MockAppCacheStorage*>(service.storage());
 
   // Setup some preconditions. Create a cache with an entry.
   GURL entry_url("http://blah/entry");
   int64 cache_id = storage->NewCacheId();
-  scoped_refptr<AppCache> cache = new AppCache(&service, cache_id);
+  scoped_refptr<AppCache> cache(new AppCache(&service, cache_id));
   cache->AddEntry(entry_url, AppCacheEntry(AppCacheEntry::EXPLICIT));
 
   // Conduct the test.
   MockStorageDelegate delegate;
   EXPECT_FALSE(cache->GetEntry(entry_url)->IsForeign());
   storage->MarkEntryAsForeign(entry_url, cache_id);
   EXPECT_TRUE(cache->GetEntry(entry_url)->IsForeign());
   EXPECT_TRUE(cache->GetEntry(entry_url)->IsExplicit());
 }
 
@@ skipping 23 matching lines @@
   // Should complete asyncly.
   MockAppCacheService service;
   MockAppCacheStorage* storage =
       reinterpret_cast<MockAppCacheStorage*>(service.storage());
 
   // Setup some preconditions. Create a complete cache with an entry.
   const int64 kCacheId = storage->NewCacheId();
   const GURL kEntryUrl("http://blah/entry");
   const GURL kManifestUrl("http://blah/manifest");
   const int64 kResponseId = 1;
-  scoped_refptr<AppCache> cache = new AppCache(&service, kCacheId);
+  scoped_refptr<AppCache> cache(new AppCache(&service, kCacheId));
   cache->AddEntry(
       kEntryUrl, AppCacheEntry(AppCacheEntry::EXPLICIT, kResponseId));
   cache->set_complete(true);
-  scoped_refptr<AppCacheGroup> group =
-      new AppCacheGroup(&service, kManifestUrl, 111);
+  scoped_refptr<AppCacheGroup> group(
+      new AppCacheGroup(&service, kManifestUrl, 111));
   group->AddCache(cache);
   storage->AddStoredGroup(group);
   storage->AddStoredCache(cache);
 
   // Conduct the test.
   MockStorageDelegate delegate;
   EXPECT_NE(kEntryUrl, delegate.found_url_);
   storage->FindResponseForMainRequest(kEntryUrl, &delegate);
   EXPECT_NE(kEntryUrl, delegate.found_url_);
   MessageLoop::current()->RunAllPending();  // Do async task execution.
@@ skipping 21 matching lines @@
   const GURL kManifestUrl("http://blah/manifest");
   const int64 kResponseId1 = 1;
   const int64 kResponseId2 = 2;
 
   Manifest manifest;
   manifest.fallback_namespaces.push_back(
       FallbackNamespace(kFallbackNamespaceUrl1, kFallbackEntryUrl1));
   manifest.fallback_namespaces.push_back(
       FallbackNamespace(kFallbackNamespaceUrl2, kFallbackEntryUrl2));
 
-  scoped_refptr<AppCache> cache = new AppCache(&service, kCacheId);
+  scoped_refptr<AppCache> cache(new AppCache(&service, kCacheId));
   cache->InitializeWithManifest(&manifest);
   cache->AddEntry(
       kFallbackEntryUrl1, AppCacheEntry(AppCacheEntry::FALLBACK, kResponseId1));
   cache->AddEntry(
       kFallbackEntryUrl2, AppCacheEntry(AppCacheEntry::FALLBACK, kResponseId2));
   cache->set_complete(true);
 
-  scoped_refptr<AppCacheGroup> group =
-      new AppCacheGroup(&service, kManifestUrl, 111);
+  scoped_refptr<AppCacheGroup> group(
+      new AppCacheGroup(&service, kManifestUrl, 111));
   group->AddCache(cache);
   storage->AddStoredGroup(group);
   storage->AddStoredCache(cache);
 
   // The test url is in both fallback namespace urls, but should match
   // the longer of the two.
   const GURL kTestUrl("http://blah/fallback_namespace/longer/test");
 
   // Conduct the test.
   MockStorageDelegate delegate;
@@ skipping 20 matching lines @@
 
   const GURL kEntryUrl("http://blah/entry");
   const int64 kCacheId1 = storage->NewCacheId();
   const int64 kCacheId2 = storage->NewCacheId();
   const GURL kManifestUrl1("http://blah/manifest1");
   const GURL kManifestUrl2("http://blah/manifest2");
   const int64 kResponseId1 = 1;
   const int64 kResponseId2 = 2;
 
   // The first cache.
-  scoped_refptr<AppCache> cache = new AppCache(&service, kCacheId1);
+  scoped_refptr<AppCache> cache(new AppCache(&service, kCacheId1));
   cache->AddEntry(
       kEntryUrl, AppCacheEntry(AppCacheEntry::EXPLICIT, kResponseId1));
   cache->set_complete(true);
-  scoped_refptr<AppCacheGroup> group =
-      new AppCacheGroup(&service, kManifestUrl1, 111);
+  scoped_refptr<AppCacheGroup> group(
+      new AppCacheGroup(&service, kManifestUrl1, 111));
   group->AddCache(cache);
   storage->AddStoredGroup(group);
   storage->AddStoredCache(cache);
   // Drop our references to cache1 so it appears as "not in use".
   cache = NULL;
   group = NULL;
 
   // The second cache.
   cache = new AppCache(&service, kCacheId2);
   cache->AddEntry(
@@ skipping 30 matching lines @@
 
   const int64 kCacheId = storage->NewCacheId();
   const GURL kEntryUrl("http://blah/entry");
   const GURL kManifestUrl("http://blah/manifest");
   const GURL kOnlineNamespaceUrl("http://blah/online_namespace");
   const int64 kResponseId = 1;
 
   Manifest manifest;
   manifest.online_whitelist_namespaces.push_back(kOnlineNamespaceUrl);
 
-  scoped_refptr<AppCache> cache = new AppCache(&service, kCacheId);
+  scoped_refptr<AppCache> cache(new AppCache(&service, kCacheId));
   cache->InitializeWithManifest(&manifest);
   cache->AddEntry(
       kEntryUrl,
       AppCacheEntry(AppCacheEntry::EXPLICIT | AppCacheEntry::FOREIGN,
                     kResponseId));
   cache->set_complete(true);
-  scoped_refptr<AppCacheGroup> group =
-      new AppCacheGroup(&service, kManifestUrl, 111);
+  scoped_refptr<AppCacheGroup> group(
+      new AppCacheGroup(&service, kManifestUrl, 111));
   group->AddCache(cache);
   storage->AddStoredGroup(group);
   storage->AddStoredCache(cache);
 
   MockStorageDelegate delegate;
 
   // We should not find anything for the foreign entry.
   EXPECT_NE(kEntryUrl, delegate.found_url_);
   storage->FindResponseForMainRequest(kEntryUrl, &delegate);
   EXPECT_NE(kEntryUrl, delegate.found_url_);
@@ skipping 15 matching lines @@
   EXPECT_TRUE(delegate.found_manifest_url_.is_empty());
   EXPECT_EQ(kNoCacheId, delegate.found_cache_id_);
   EXPECT_EQ(kNoResponseId, delegate.found_entry_.response_id());
   EXPECT_EQ(kNoResponseId, delegate.found_fallback_entry_.response_id());
   EXPECT_EQ(0, delegate.found_entry_.types());
   EXPECT_EQ(0, delegate.found_fallback_entry_.types());
 }
 
 }  // namespace appcache