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

webkit/appcache/appcache_storage_impl_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 <stack>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/message_loop.h"
@@ skipping 169 matching lines @@
   };
 
   class MockQuotaManagerProxy : public quota::QuotaManagerProxy {
    public:
     MockQuotaManagerProxy()
         : QuotaManagerProxy(NULL, NULL),
           notify_storage_accessed_count_(0),
           notify_storage_modified_count_(0),
           last_delta_(0),
           mock_manager_(new MockQuotaManager) {
-      manager_ = mock_manager_;
+      manager_ = mock_manager_.get();
     }
 
     virtual void NotifyStorageAccessed(quota::QuotaClient::ID client_id,
                                        const GURL& origin,
                                        quota::StorageType type) OVERRIDE {
       EXPECT_EQ(quota::QuotaClient::kAppcache, client_id);
       EXPECT_EQ(quota::kStorageTypeTemporary, type);
       ++notify_storage_accessed_count_;
       last_origin_ = origin;
     }
@@ skipping 146 matching lines @@
     // complete asynchronously.
     PushNextTask(base::Bind(&AppCacheStorageImplTest::Verify_LoadCache_Miss,
                             base::Unretained(this)));
 
     storage()->LoadCache(111, delegate());
     EXPECT_NE(111, delegate()->loaded_cache_id_);
   }
 
   void Verify_LoadCache_Miss() {
     EXPECT_EQ(111, delegate()->loaded_cache_id_);
-    EXPECT_FALSE(delegate()->loaded_cache_);
+    EXPECT_FALSE(delegate()->loaded_cache_.get());
     EXPECT_EQ(0, mock_quota_manager_proxy_->notify_storage_accessed_count_);
     EXPECT_EQ(0, mock_quota_manager_proxy_->notify_storage_modified_count_);
     TestFinished();
   }
 
   // LoadCache_NearHit -------------------------------------------------
 
   void LoadCache_NearHit() {
     // Attempt to load a cache that is currently in use
     // and does not require loading from storage. This
@@ skipping 69 matching lines @@
     // appear to be "stored" and "not currently in use".
     MakeCacheAndGroup(kManifestUrl, 1, 1, true);
     group_ = NULL;
     cache_ = NULL;
 
     // Conduct the cache load test, completes async
     storage()->LoadCache(1, delegate());
   }
 
   void Verify_LoadCache_Far_Hit() {
-    EXPECT_TRUE(delegate()->loaded_cache_);
+    EXPECT_TRUE(delegate()->loaded_cache_.get());
     EXPECT_TRUE(delegate()->loaded_cache_->HasOneRef());
     EXPECT_EQ(1, delegate()->loaded_cache_id_);
 
     // The group should also have been loaded.
     EXPECT_TRUE(delegate()->loaded_cache_->owning_group());
     EXPECT_TRUE(delegate()->loaded_cache_->owning_group()->HasOneRef());
     EXPECT_EQ(1, delegate()->loaded_cache_->owning_group()->group_id());
 
     EXPECT_EQ(1, mock_quota_manager_proxy_->notify_storage_accessed_count_);
     EXPECT_EQ(0, mock_quota_manager_proxy_->notify_storage_modified_count_);
 
     // Drop things from the working set.
     delegate()->loaded_cache_ = NULL;
-    EXPECT_FALSE(delegate()->loaded_group_);
+    EXPECT_FALSE(delegate()->loaded_group_.get());
 
     // Conduct the group load test, also complete asynchronously.
     PushNextTask(base::Bind(&AppCacheStorageImplTest::Verify_LoadGroup_Far_Hit,
                             base::Unretained(this)));
 
     storage()->LoadOrCreateGroup(kManifestUrl, delegate());
   }
 
   void Verify_LoadGroup_Far_Hit() {
-    EXPECT_TRUE(delegate()->loaded_group_);
+    EXPECT_TRUE(delegate()->loaded_group_.get());
     EXPECT_EQ(kManifestUrl, delegate()->loaded_manifest_url_);
     EXPECT_TRUE(delegate()->loaded_group_->newest_complete_cache());
     delegate()->loaded_groups_newest_cache_ = NULL;
     EXPECT_TRUE(delegate()->loaded_group_->HasOneRef());
     EXPECT_EQ(2, mock_quota_manager_proxy_->notify_storage_accessed_count_);
     EXPECT_EQ(0, mock_quota_manager_proxy_->notify_storage_modified_count_);
     TestFinished();
   }
 
   // StoreNewGroup  --------------------------------------
@@ skipping 10 matching lines @@
     cache_ = new AppCache(storage(), storage()->NewCacheId());
     cache_->AddEntry(kEntryUrl, AppCacheEntry(AppCacheEntry::EXPLICIT, 1,
                                               kDefaultEntrySize));
     // 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.
 
     // Have the quota manager retrun asynchronously for this test.
     mock_quota_manager_proxy_->mock_manager_->async_ = true;
 
     // Conduct the store test.
-    storage()->StoreGroupAndNewestCache(group_, cache_, delegate());
+    storage()->StoreGroupAndNewestCache(group_.get(), cache_.get(), delegate());
     EXPECT_FALSE(delegate()->stored_group_success_);
   }
 
   void Verify_StoreNewGroup() {
     EXPECT_TRUE(delegate()->stored_group_success_);
     EXPECT_EQ(group_.get(), delegate()->stored_group_.get());
     EXPECT_EQ(cache_.get(), group_->newest_complete_cache());
     EXPECT_TRUE(cache_->is_complete());
 
     // Should have been stored in the database.
@@ skipping 22 matching lines @@
     // that appear to be "stored"
     MakeCacheAndGroup(kManifestUrl, 1, 1, true);
     EXPECT_EQ(kDefaultEntrySize, storage()->usage_map_[kOrigin]);
 
     // And a newest unstored complete cache.
     cache2_ = new AppCache(storage(), 2);
     cache2_->AddEntry(kEntryUrl, AppCacheEntry(AppCacheEntry::MASTER, 1,
                                                kDefaultEntrySize + 100));
 
     // Conduct the test.
-    storage()->StoreGroupAndNewestCache(group_, cache2_, delegate());
+    storage()->StoreGroupAndNewestCache(
+        group_.get(), cache2_.get(), delegate());
     EXPECT_FALSE(delegate()->stored_group_success_);
   }
 
   void Verify_StoreExistingGroup() {
     EXPECT_TRUE(delegate()->stored_group_success_);
     EXPECT_EQ(group_.get(), delegate()->stored_group_.get());
     EXPECT_EQ(cache2_.get(), group_->newest_complete_cache());
     EXPECT_TRUE(cache2_->is_complete());
 
     // The new cache should have been stored in the database.
@@ skipping 30 matching lines @@
     base::Time now = base::Time::Now();
     cache_->AddEntry(kEntryUrl, AppCacheEntry(AppCacheEntry::MASTER, 1, 100));
     cache_->set_update_time(now);
 
     PushNextTask(base::Bind(
         &AppCacheStorageImplTest::Verify_StoreExistingGroupExistingCache,
         base::Unretained(this), now));
 
     // Conduct the test.
     EXPECT_EQ(cache_, group_->newest_complete_cache());
-    storage()->StoreGroupAndNewestCache(group_, cache_, delegate());
+    storage()->StoreGroupAndNewestCache(group_.get(), cache_.get(), delegate());
     EXPECT_FALSE(delegate()->stored_group_success_);
   }
 
   void Verify_StoreExistingGroupExistingCache(
       base::Time expected_update_time) {
     EXPECT_TRUE(delegate()->stored_group_success_);
     EXPECT_EQ(cache_, group_->newest_complete_cache());
 
     AppCacheDatabase::CacheRecord cache_record;
     EXPECT_TRUE(database()->FindCache(1, &cache_record));
@@ skipping 35 matching lines @@
     const int64 kTooBig = 10 * 1024 * 1024;  // 10M
     group_ = new AppCacheGroup(
         storage(), kManifestUrl, storage()->NewGroupId());
     cache_ = new AppCache(storage(), storage()->NewCacheId());
     cache_->AddEntry(kManifestUrl,
                      AppCacheEntry(AppCacheEntry::MANIFEST, 1, kTooBig));
     // 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.
-    storage()->StoreGroupAndNewestCache(group_, cache_, delegate());
+    storage()->StoreGroupAndNewestCache(group_.get(), cache_.get(), delegate());
     EXPECT_FALSE(delegate()->stored_group_success_);  // Expected to be async.
   }
 
   void Verify_FailStoreGroup() {
     EXPECT_FALSE(delegate()->stored_group_success_);
     EXPECT_TRUE(delegate()->would_exceed_quota_);
 
     // Should not have been stored in the database.
     AppCacheDatabase::GroupRecord group_record;
     AppCacheDatabase::CacheRecord cache_record;
@@ skipping 32 matching lines @@
     fallback_namespace_record.namespace_.namespace_url = kFallbackNamespace;
     fallback_namespace_record.origin = kManifestUrl.GetOrigin();
     EXPECT_TRUE(database()->InsertNamespace(&fallback_namespace_record));
 
     AppCacheDatabase::OnlineWhiteListRecord online_whitelist_record;
     online_whitelist_record.cache_id = 1;
     online_whitelist_record.namespace_url = kOnlineNamespace;
     EXPECT_TRUE(database()->InsertOnlineWhiteList(&online_whitelist_record));
 
     // Conduct the test.
-    storage()->MakeGroupObsolete(group_, delegate());
+    storage()->MakeGroupObsolete(group_.get(), delegate());
     EXPECT_FALSE(group_->is_obsolete());
   }
 
   void Verify_MakeGroupObsolete() {
     EXPECT_TRUE(delegate()->obsoleted_success_);
     EXPECT_EQ(group_.get(), delegate()->obsoleted_group_.get());
     EXPECT_TRUE(group_->is_obsolete());
     EXPECT_TRUE(storage()->usage_map_.empty());
 
     // The cache and group have been deleted from the database.
@@ skipping 196 matching lines @@
     cache_->AddEntry(kEntryUrl2, AppCacheEntry(AppCacheEntry::FALLBACK, 2));
     cache_->fallback_namespaces_.push_back(
         Namespace(FALLBACK_NAMESPACE, kFallbackNamespace2, kEntryUrl2, false));
     cache_->fallback_namespaces_.push_back(
         Namespace(FALLBACK_NAMESPACE, kFallbackNamespace, kEntryUrl, false));
     AppCacheDatabase::CacheRecord cache_record;
     std::vector<AppCacheDatabase::EntryRecord> entries;
     std::vector<AppCacheDatabase::NamespaceRecord> intercepts;
     std::vector<AppCacheDatabase::NamespaceRecord> fallbacks;
     std::vector<AppCacheDatabase::OnlineWhiteListRecord> whitelists;
-    cache_->ToDatabaseRecords(group_,
-        &cache_record, &entries, &intercepts, &fallbacks, &whitelists);
+    cache_->ToDatabaseRecords(group_.get(),
+                              &cache_record,
+                              &entries,
+                              &intercepts,
+                              &fallbacks,
+                              &whitelists);
 
     std::vector<AppCacheDatabase::EntryRecord>::const_iterator iter =
         entries.begin();
     while (iter != entries.end()) {
       // MakeCacheAndGroup has inserted the default entry record already.
       if (iter->url != kDefaultEntryUrl)
         EXPECT_TRUE(database()->InsertEntry(&(*iter)));
       ++iter;
     }
 
@@ skipping 48 matching lines @@
         Namespace(INTERCEPT_NAMESPACE, kInterceptNamespace2,
                   kEntryUrl2, false));
     cache_->intercept_namespaces_.push_back(
         Namespace(INTERCEPT_NAMESPACE, kInterceptNamespace,
                   kEntryUrl, false));
     AppCacheDatabase::CacheRecord cache_record;
     std::vector<AppCacheDatabase::EntryRecord> entries;
     std::vector<AppCacheDatabase::NamespaceRecord> intercepts;
     std::vector<AppCacheDatabase::NamespaceRecord> fallbacks;
     std::vector<AppCacheDatabase::OnlineWhiteListRecord> whitelists;
-    cache_->ToDatabaseRecords(group_,
-        &cache_record, &entries, &intercepts, &fallbacks, &whitelists);
+    cache_->ToDatabaseRecords(group_.get(),
+                              &cache_record,
+                              &entries,
+                              &intercepts,
+                              &fallbacks,
+                              &whitelists);
 
     std::vector<AppCacheDatabase::EntryRecord>::const_iterator iter =
         entries.begin();
     while (iter != entries.end()) {
       // MakeCacheAndGroup has inserted  the default entry record already
       if (iter->url != kDefaultEntryUrl)
         EXPECT_TRUE(database()->InsertEntry(&(*iter)));
       ++iter;
     }
 
@@ skipping 41 matching lines @@
     MakeCacheAndGroup(kManifestUrl, 2, 1, true);
     cache_->AddEntry(kEntryUrl, AppCacheEntry(AppCacheEntry::INTERCEPT, 1));
     cache_->intercept_namespaces_.push_back(
         Namespace(INTERCEPT_NAMESPACE, kInterceptPatternNamespace,
                   kEntryUrl, true));
     AppCacheDatabase::CacheRecord cache_record;
     std::vector<AppCacheDatabase::EntryRecord> entries;
     std::vector<AppCacheDatabase::NamespaceRecord> intercepts;
     std::vector<AppCacheDatabase::NamespaceRecord> fallbacks;
     std::vector<AppCacheDatabase::OnlineWhiteListRecord> whitelists;
-    cache_->ToDatabaseRecords(group_,
-        &cache_record, &entries, &intercepts, &fallbacks, &whitelists);
+    cache_->ToDatabaseRecords(group_.get(),
+                              &cache_record,
+                              &entries,
+                              &intercepts,
+                              &fallbacks,
+                              &whitelists);
 
     std::vector<AppCacheDatabase::EntryRecord>::const_iterator iter =
         entries.begin();
     while (iter != entries.end()) {
       // MakeCacheAndGroup has inserted  the default entry record already
       if (iter->url != kDefaultEntryUrl)
         EXPECT_TRUE(database()->InsertEntry(&(*iter)));
       ++iter;
     }
 
@@ skipping 60 matching lines @@
     MakeCacheAndGroup(kManifestUrl, 2, 1, true);
     cache_->AddEntry(kEntryUrl, AppCacheEntry(AppCacheEntry::FALLBACK, 1));
     cache_->fallback_namespaces_.push_back(
         Namespace(FALLBACK_NAMESPACE, kFallbackPatternNamespace,
                   kEntryUrl, true));
     AppCacheDatabase::CacheRecord cache_record;
     std::vector<AppCacheDatabase::EntryRecord> entries;
     std::vector<AppCacheDatabase::NamespaceRecord> intercepts;
     std::vector<AppCacheDatabase::NamespaceRecord> fallbacks;
     std::vector<AppCacheDatabase::OnlineWhiteListRecord> whitelists;
-    cache_->ToDatabaseRecords(group_,
-        &cache_record, &entries, &intercepts, &fallbacks, &whitelists);
+    cache_->ToDatabaseRecords(group_.get(),
+                              &cache_record,
+                              &entries,
+                              &intercepts,
+                              &fallbacks,
+                              &whitelists);
 
     std::vector<AppCacheDatabase::EntryRecord>::const_iterator iter =
         entries.begin();
     while (iter != entries.end()) {
       // MakeCacheAndGroup has inserted the default entry record already.
       if (iter->url != kDefaultEntryUrl)
         EXPECT_TRUE(database()->InsertEntry(&(*iter)));
       ++iter;
     }
 
@@ skipping 309 matching lines @@
   void MakeCacheAndGroup(
       const GURL& manifest_url, int64 group_id, int64 cache_id,
       bool add_to_database) {
     AppCacheEntry default_entry(
         AppCacheEntry::EXPLICIT, cache_id + kDefaultEntryIdOffset,
         kDefaultEntrySize);
     group_ = new AppCacheGroup(storage(), manifest_url, group_id);
     cache_ = new AppCache(storage(), cache_id);
     cache_->AddEntry(kDefaultEntryUrl, default_entry);
     cache_->set_complete(true);
-    group_->AddCache(cache_);
+    group_->AddCache(cache_.get());
     if (add_to_database) {
       AppCacheDatabase::GroupRecord group_record;
       group_record.group_id = group_id;
       group_record.manifest_url = manifest_url;
       group_record.origin = manifest_url.GetOrigin();
       EXPECT_TRUE(database()->InsertGroup(&group_record));
       AppCacheDatabase::CacheRecord cache_record;
       cache_record.cache_id = cache_id;
       cache_record.group_id = group_id;
       cache_record.online_wildcard = false;
@@ skipping 140 matching lines @@
 }
 
 TEST_F(AppCacheStorageImplTest, FindFallbackPatternMatchInDatabase) {
   RunTestOnIOThread(
       &AppCacheStorageImplTest::FindFallbackPatternMatchInDatabase);
 }
 
 // That's all folks!
 
 }  // namespace appcache