Update webkit/ to use scoped_refptr<T>::get() rather than implicit "operator T*"

webkit/appcache/mock_appcache_storage_unittest.cc

 // Copyright (c) 2012 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 71 matching lines @@
 
 TEST_F(MockAppCacheStorageTest, LoadCache_Miss) {
   // Attempt to load a cache that doesn't exist. Should
   // complete asyncly.
   MockAppCacheService service;
   MockStorageDelegate delegate;
   service.storage()->LoadCache(111, &delegate);
   EXPECT_NE(111, delegate.loaded_cache_id_);
   base::MessageLoop::current()->RunUntilIdle();  // Do async task execution.
   EXPECT_EQ(111, delegate.loaded_cache_id_);
-  EXPECT_FALSE(delegate.loaded_cache_);
+  EXPECT_FALSE(delegate.loaded_cache_.get());
 }
 
 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.
@@ skipping 61 matching lines @@
       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.storage(), manifest_url, 111));
   int64 cache_id = storage->NewCacheId();
   scoped_refptr<AppCache> cache(new AppCache(service.storage(), cache_id));
   cache->set_complete(true);
-  group->AddCache(cache);
-  storage->AddStoredGroup(group);
-  storage->AddStoredCache(cache);
+  group->AddCache(cache.get());
+  storage->AddStoredGroup(group.get());
+  storage->AddStoredCache(cache.get());
 
   // 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();
   cache = NULL;
   group = NULL;
 
   // Setup a delegate to receive completion callbacks.
@@ skipping 34 matching lines @@
       new AppCacheGroup(service.storage(), manifest_url, 111));
   int64 cache_id = storage->NewCacheId();
   scoped_refptr<AppCache> cache(new AppCache(service.storage(), 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);
+  storage->StoreGroupAndNewestCache(group.get(), cache.get(), &delegate);
   EXPECT_FALSE(delegate.stored_group_success_);
   EXPECT_TRUE(storage->stored_caches_.empty());
   EXPECT_TRUE(storage->stored_groups_.empty());
   base::MessageLoop::current()->RunUntilIdle();  // 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.storage(), manifest_url, 111));
   int64 old_cache_id = storage->NewCacheId();
   scoped_refptr<AppCache> old_cache(
       new AppCache(service.storage(), old_cache_id));
   old_cache->set_complete(true);
-  group->AddCache(old_cache);
-  storage->AddStoredGroup(group);
-  storage->AddStoredCache(old_cache);
+  group->AddCache(old_cache.get());
+  storage->AddStoredGroup(group.get());
+  storage->AddStoredCache(old_cache.get());
   int64 new_cache_id = storage->NewCacheId();
   scoped_refptr<AppCache> new_cache(
       new AppCache(service.storage(), 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_TRUE(storage->IsCacheStored(old_cache.get()));
+  EXPECT_FALSE(storage->IsCacheStored(new_cache.get()));
+  storage->StoreGroupAndNewestCache(group.get(), new_cache.get(), &delegate);
   EXPECT_FALSE(delegate.stored_group_success_);
   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));
+  EXPECT_TRUE(storage->IsCacheStored(old_cache.get()));
+  EXPECT_FALSE(storage->IsCacheStored(new_cache.get()));
   base::MessageLoop::current()->RunUntilIdle();  // Do async task execution.
   EXPECT_TRUE(delegate.stored_group_success_);
   EXPECT_EQ(size_t(1), storage->stored_caches_.size());
   EXPECT_EQ(size_t(1), storage->stored_groups_.size());
-  EXPECT_FALSE(storage->IsCacheStored(old_cache));
-  EXPECT_TRUE(storage->IsCacheStored(new_cache));
+  EXPECT_FALSE(storage->IsCacheStored(old_cache.get()));
+  EXPECT_TRUE(storage->IsCacheStored(new_cache.get()));
   EXPECT_EQ(new_cache.get(), group->newest_complete_cache());
   EXPECT_TRUE(new_cache->is_complete());
 }
 
 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.storage(), manifest_url, 111));
   int64 cache_id = storage->NewCacheId();
   scoped_refptr<AppCache> cache(new AppCache(service.storage(), cache_id));
   cache->set_complete(true);
-  group->AddCache(cache);
-  storage->AddStoredGroup(group);
-  storage->AddStoredCache(cache);
+  group->AddCache(cache.get());
+  storage->AddStoredGroup(group.get());
+  storage->AddStoredCache(cache.get());
   // 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));
 
   // 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(cache));
-  storage->StoreGroupAndNewestCache(group, cache, &delegate);
+  EXPECT_TRUE(storage->IsCacheStored(cache.get()));
+  storage->StoreGroupAndNewestCache(group.get(), cache.get(), &delegate);
   EXPECT_FALSE(delegate.stored_group_success_);
   EXPECT_EQ(size_t(1), storage->stored_caches_.size());
   EXPECT_EQ(size_t(1), storage->stored_groups_.size());
   base::MessageLoop::current()->RunUntilIdle();  // Do async task execution.
   EXPECT_TRUE(delegate.stored_group_success_);
   EXPECT_EQ(size_t(1), storage->stored_caches_.size());
   EXPECT_EQ(size_t(1), storage->stored_groups_.size());
-  EXPECT_TRUE(storage->IsCacheStored(cache));
+  EXPECT_TRUE(storage->IsCacheStored(cache.get()));
   EXPECT_EQ(cache, group->newest_complete_cache());
   EXPECT_TRUE(cache->GetEntry(entry_url));
 }
 
 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.storage(), manifest_url, 111));
   int64 cache_id = storage->NewCacheId();
   scoped_refptr<AppCache> cache(new AppCache(service.storage(), cache_id));
   cache->set_complete(true);
-  group->AddCache(cache);
-  storage->AddStoredGroup(group);
-  storage->AddStoredCache(cache);
+  group->AddCache(cache.get());
+  storage->AddStoredGroup(group.get());
+  storage->AddStoredCache(cache.get());
   // 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());
   EXPECT_EQ(size_t(1), storage->stored_groups_.size());
   EXPECT_FALSE(cache->HasOneRef());
   EXPECT_FALSE(group->HasOneRef());
-  storage->MakeGroupObsolete(group, &delegate);
+  storage->MakeGroupObsolete(group.get(), &delegate);
   EXPECT_FALSE(group->is_obsolete());
   EXPECT_EQ(size_t(1), storage->stored_caches_.size());
   EXPECT_EQ(size_t(1), storage->stored_groups_.size());
   EXPECT_FALSE(cache->HasOneRef());
   EXPECT_FALSE(group->HasOneRef());
   base::MessageLoop::current()->RunUntilIdle();  // Do async task execution.
   EXPECT_TRUE(delegate.obsoleted_success_);
   EXPECT_EQ(group.get(), delegate.obsoleted_group_.get());
   EXPECT_TRUE(group->is_obsolete());
   EXPECT_TRUE(storage->stored_caches_.empty());
@@ skipping 58 matching lines @@
   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.storage(), kCacheId));
   cache->AddEntry(
       kEntryUrl, AppCacheEntry(AppCacheEntry::EXPLICIT, kResponseId));
   cache->set_complete(true);
   scoped_refptr<AppCacheGroup> group(
       new AppCacheGroup(service.storage(), kManifestUrl, 111));
-  group->AddCache(cache);
-  storage->AddStoredGroup(group);
-  storage->AddStoredCache(cache);
+  group->AddCache(cache.get());
+  storage->AddStoredGroup(group.get());
+  storage->AddStoredCache(cache.get());
 
   // Conduct the test.
   MockStorageDelegate delegate;
   EXPECT_NE(kEntryUrl, delegate.found_url_);
   storage->FindResponseForMainRequest(kEntryUrl, GURL(), &delegate);
   EXPECT_NE(kEntryUrl, delegate.found_url_);
   base::MessageLoop::current()->RunUntilIdle();  // Do async task execution.
   EXPECT_EQ(kEntryUrl, delegate.found_url_);
   EXPECT_EQ(kManifestUrl, delegate.found_manifest_url_);
   EXPECT_EQ(kCacheId, delegate.found_cache_id_);
@@ skipping 30 matching lines @@
   scoped_refptr<AppCache> cache(new AppCache(service.storage(), 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.storage(), kManifestUrl, 111));
-  group->AddCache(cache);
-  storage->AddStoredGroup(group);
-  storage->AddStoredCache(cache);
+  group->AddCache(cache.get());
+  storage->AddStoredGroup(group.get());
+  storage->AddStoredCache(cache.get());
 
   // 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;
   EXPECT_NE(kTestUrl, delegate.found_url_);
   storage->FindResponseForMainRequest(kTestUrl, GURL(), &delegate);
   EXPECT_NE(kTestUrl, delegate.found_url_);
@@ skipping 24 matching lines @@
   const int64 kResponseId1 = 1;
   const int64 kResponseId2 = 2;
 
   // The first cache.
   scoped_refptr<AppCache> cache(new AppCache(service.storage(), kCacheId1));
   cache->AddEntry(
       kEntryUrl, AppCacheEntry(AppCacheEntry::EXPLICIT, kResponseId1));
   cache->set_complete(true);
   scoped_refptr<AppCacheGroup> group(
       new AppCacheGroup(service.storage(), kManifestUrl1, 111));
-  group->AddCache(cache);
-  storage->AddStoredGroup(group);
-  storage->AddStoredCache(cache);
+  group->AddCache(cache.get());
+  storage->AddStoredGroup(group.get());
+  storage->AddStoredCache(cache.get());
   // Drop our references to cache1 so it appears as "not in use".
   cache = NULL;
   group = NULL;
 
   // The second cache.
   cache = new AppCache(service.storage(), kCacheId2);
   cache->AddEntry(
       kEntryUrl, AppCacheEntry(AppCacheEntry::EXPLICIT, kResponseId2));
   cache->set_complete(true);
   group = new AppCacheGroup(service.storage(), kManifestUrl2, 222);
-  group->AddCache(cache);
-  storage->AddStoredGroup(group);
-  storage->AddStoredCache(cache);
+  group->AddCache(cache.get());
+  storage->AddStoredGroup(group.get());
+  storage->AddStoredCache(cache.get());
 
   // Conduct the test, we should find the response from the second cache
   // since it's "in use".
   MockStorageDelegate delegate;
   EXPECT_NE(kEntryUrl, delegate.found_url_);
   storage->FindResponseForMainRequest(kEntryUrl, GURL(), &delegate);
   EXPECT_NE(kEntryUrl, delegate.found_url_);
   base::MessageLoop::current()->RunUntilIdle();  // Do async task execution.
   EXPECT_EQ(kEntryUrl, delegate.found_url_);
   EXPECT_EQ(kManifestUrl2, delegate.found_manifest_url_);
@@ skipping 24 matching lines @@
                 GURL(), false));
   scoped_refptr<AppCache> cache(new AppCache(service.storage(), kCacheId));
   cache->InitializeWithManifest(&manifest);
   cache->AddEntry(
       kEntryUrl,
       AppCacheEntry(AppCacheEntry::EXPLICIT | AppCacheEntry::FOREIGN,
                     kResponseId));
   cache->set_complete(true);
   scoped_refptr<AppCacheGroup> group(
       new AppCacheGroup(service.storage(), kManifestUrl, 111));
-  group->AddCache(cache);
-  storage->AddStoredGroup(group);
-  storage->AddStoredCache(cache);
+  group->AddCache(cache.get());
+  storage->AddStoredGroup(group.get());
+  storage->AddStoredCache(cache.get());
 
   MockStorageDelegate delegate;
 
   // We should not find anything for the foreign entry.
   EXPECT_NE(kEntryUrl, delegate.found_url_);
   storage->FindResponseForMainRequest(kEntryUrl, GURL(), &delegate);
   EXPECT_NE(kEntryUrl, delegate.found_url_);
   base::MessageLoop::current()->RunUntilIdle();  // Do async task execution.
   EXPECT_EQ(kEntryUrl, delegate.found_url_);
   EXPECT_TRUE(delegate.found_manifest_url_.is_empty());
@@ skipping 13 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_TRUE(delegate.found_fallback_url_.is_empty());
   EXPECT_EQ(0, delegate.found_entry_.types());
   EXPECT_EQ(0, delegate.found_fallback_entry_.types());
 }
 
 }  // namespace appcache