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

webkit/appcache/mock_appcache_storage.cc

 // Copyright (c) 2011 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 "webkit/appcache/mock_appcache_storage.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop.h"
@@ skipping 163 matching lines @@
   std::vector<int64>::const_iterator it = response_ids.begin();
   while (it != response_ids.end()) {
     doomed_response_ids_.insert(*it);
     ++it;
   }
 }
 
 void MockAppCacheStorage::ProcessGetAllInfo(
     scoped_refptr<DelegateReference> delegate_ref) {
   if (delegate_ref->delegate)
-    delegate_ref->delegate->OnAllInfo(simulated_appcache_info_);
+    delegate_ref->delegate->OnAllInfo(simulated_appcache_info_.get());
 }
 
 void MockAppCacheStorage::ProcessLoadCache(
     int64 id, scoped_refptr<DelegateReference> delegate_ref) {
   AppCache* cache = working_set_.GetCache(id);
   if (delegate_ref->delegate)
     delegate_ref->delegate->OnCacheLoaded(cache, id);
 }
 
 void MockAppCacheStorage::ProcessLoadOrCreateGroup(
     const GURL& manifest_url, scoped_refptr<DelegateReference> delegate_ref) {
   scoped_refptr<AppCacheGroup> group(working_set_.GetGroup(manifest_url));
 
   // Newly created groups are not put in the stored_groups collection
   // until StoreGroupAndNewestCache is called.
-  if (!group)
+  if (!group.get())
     group = new AppCacheGroup(service_->storage(), manifest_url, NewGroupId());
 
   if (delegate_ref->delegate)
-    delegate_ref->delegate->OnGroupLoaded(group, manifest_url);
+    delegate_ref->delegate->OnGroupLoaded(group.get(), manifest_url);
 }
 
 void MockAppCacheStorage::ProcessStoreGroupAndNewestCache(
     scoped_refptr<AppCacheGroup> group,
     scoped_refptr<AppCache> newest_cache,
     scoped_refptr<DelegateReference> delegate_ref) {
   Delegate* delegate = delegate_ref->delegate;
   if (simulate_store_group_and_newest_cache_failure_) {
     if (delegate)
-      delegate->OnGroupAndNewestCacheStored(group, newest_cache, false, false);
+      delegate->OnGroupAndNewestCacheStored(
+          group.get(), newest_cache.get(), false, false);
     return;
   }
 
-  AddStoredGroup(group);
-  if (newest_cache != group->newest_complete_cache()) {
+  AddStoredGroup(group.get());
+  if (newest_cache.get() != group->newest_complete_cache()) {
     newest_cache->set_complete(true);
-    group->AddCache(newest_cache);
-    AddStoredCache(newest_cache);
+    group->AddCache(newest_cache.get());
+    AddStoredCache(newest_cache.get());
 
     // Copy the collection prior to removal, on final release
     // of a cache the group's collection will change.
     AppCacheGroup::Caches copy = group->old_caches();
     RemoveStoredCaches(copy);
   }
 
   if (delegate)
-    delegate->OnGroupAndNewestCacheStored(group, newest_cache, true, false);
+    delegate->OnGroupAndNewestCacheStored(
+        group.get(), newest_cache.get(), true, false);
 }
 
 namespace {
 
 struct FoundCandidate {
   GURL namespace_entry_url;
   AppCacheEntry entry;
   int64 cache_id;
   int64 group_id;
   GURL manifest_url;
@@ skipping 167 matching lines @@
   // Didn't find anything.
   delegate_ref->delegate->OnMainResponseFound(
       url, AppCacheEntry(), GURL(), AppCacheEntry(), kNoCacheId, 0, GURL());
 }
 
 void MockAppCacheStorage::ProcessMakeGroupObsolete(
     scoped_refptr<AppCacheGroup> group,
     scoped_refptr<DelegateReference> delegate_ref) {
   if (simulate_make_group_obsolete_failure_) {
     if (delegate_ref->delegate)
-      delegate_ref->delegate->OnGroupMadeObsolete(group, false);
+      delegate_ref->delegate->OnGroupMadeObsolete(group.get(), false);
     return;
   }
 
-  RemoveStoredGroup(group);
+  RemoveStoredGroup(group.get());
   if (group->newest_complete_cache())
     RemoveStoredCache(group->newest_complete_cache());
 
   // Copy the collection prior to removal, on final release
   // of a cache the group's collection will change.
   AppCacheGroup::Caches copy = group->old_caches();
   RemoveStoredCaches(copy);
 
   group->set_obsolete(true);
 
   // Also remove from the working set, caches for an 'obsolete' group
   // may linger in use, but the group itself cannot be looked up by
   // 'manifest_url' in the working set any longer.
-  working_set()->RemoveGroup(group);
+  working_set()->RemoveGroup(group.get());
 
   if (delegate_ref->delegate)
-    delegate_ref->delegate->OnGroupMadeObsolete(group, true);
+    delegate_ref->delegate->OnGroupMadeObsolete(group.get(), true);
 }
 
 void MockAppCacheStorage::ScheduleTask(const base::Closure& task) {
   pending_tasks_.push_back(task);
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&MockAppCacheStorage::RunOnePendingTask,
                  weak_factory_.GetWeakPtr()));
 }
 
@@ skipping 75 matching lines @@
 bool MockAppCacheStorage::ShouldCacheLoadAppearAsync(const AppCache* cache) {
   if (!cache)
     return true;
 
   // If the 'stored' ref is the only ref, real storage will have to load from
   // the database.
   return IsCacheStored(cache) && cache->HasOneRef();
 }
 
 }  // namespace appcache