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

webkit/appcache/appcache_host.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/appcache_host.h"
 
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "net/url_request/url_request.h"
@@ skipping 40 matching lines @@
       pending_selected_cache_id_(kNoCacheId),
       frontend_(frontend), service_(service),
       pending_callback_param_(NULL),
       main_resource_was_namespace_entry_(false),
       main_resource_blocked_(false),
       associated_cache_info_pending_(false) {
 }
 
 AppCacheHost::~AppCacheHost() {
   FOR_EACH_OBSERVER(Observer, observers_, OnDestructionImminent(this));
-  if (associated_cache_)
+  if (associated_cache_.get())
     associated_cache_->UnassociateHost(this);
-  if (group_being_updated_)
+  if (group_being_updated_.get())
     group_being_updated_->RemoveUpdateObserver(this);
   service_->storage()->CancelDelegateCallbacks(this);
   if (service()->quota_manager_proxy() && !origin_in_use_.is_empty())
     service()->quota_manager_proxy()->NotifyOriginNoLongerInUse(origin_in_use_);
 }
 
 void AppCacheHost::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
@@ skipping 127 matching lines @@
     return;
 
   DoPendingStartUpdate();
 }
 
 void AppCacheHost::DoPendingStartUpdate() {
   DCHECK_EQ(false, pending_start_update_callback_.is_null());
 
   // 6.9.8 Application cache API
   bool success = false;
-  if (associated_cache_ && associated_cache_->owning_group()) {
+  if (associated_cache_.get() && associated_cache_->owning_group()) {
     AppCacheGroup* group = associated_cache_->owning_group();
     if (!group->is_obsolete() && !group->is_being_deleted()) {
       success = true;
       group->StartUpdate();
     }
   }
 
   pending_start_update_callback_.Run(success, pending_callback_param_);
   pending_start_update_callback_.Reset();
   pending_callback_param_ = NULL;
@@ skipping 11 matching lines @@
     return;
 
   DoPendingSwapCache();
 }
 
 void AppCacheHost::DoPendingSwapCache() {
   DCHECK_EQ(false, pending_swap_cache_callback_.is_null());
 
   // 6.9.8 Application cache API
   bool success = false;
-  if (associated_cache_ && associated_cache_->owning_group()) {
+  if (associated_cache_.get() && associated_cache_->owning_group()) {
     if (associated_cache_->owning_group()->is_obsolete()) {
       success = true;
       AssociateNoCache(GURL());
-    } else if (swappable_cache_) {
+    } else if (swappable_cache_.get()) {
       DCHECK(swappable_cache_.get() ==
              swappable_cache_->owning_group()->newest_complete_cache());
       success = true;
-      AssociateCompleteCache(swappable_cache_);
+      AssociateCompleteCache(swappable_cache_.get());
     }
   }
 
   pending_swap_cache_callback_.Run(success, pending_callback_param_);
   pending_swap_cache_callback_.Reset();
   pending_callback_param_ = NULL;
 }
 
 void AppCacheHost::SetSpawningHostId(
     int spawning_process_id, int spawning_host_id) {
@@ skipping 52 matching lines @@
   // during the application cache update process.
   if (!cache->owning_group())
     return DOWNLOADING;
 
   if (cache->owning_group()->is_obsolete())
     return OBSOLETE;
   if (cache->owning_group()->update_status() == AppCacheGroup::CHECKING)
     return CHECKING;
   if (cache->owning_group()->update_status() == AppCacheGroup::DOWNLOADING)
     return DOWNLOADING;
-  if (swappable_cache_)
+  if (swappable_cache_.get())
     return UPDATE_READY;
   return IDLE;
 }
 
 void AppCacheHost::LoadOrCreateGroup(const GURL& manifest_url) {
   DCHECK(manifest_url.is_valid());
   pending_selected_manifest_url_ = manifest_url;
   service_->storage()->LoadOrCreateGroup(manifest_url, this);
 }
 
@@ skipping 76 matching lines @@
     DoPendingGetStatus();
   else if (!pending_start_update_callback_.is_null())
     DoPendingStartUpdate();
   else if (!pending_swap_cache_callback_.is_null())
     DoPendingSwapCache();
 
   FOR_EACH_OBSERVER(Observer, observers_, OnCacheSelectionComplete(this));
 }
 
 void AppCacheHost::ObserveGroupBeingUpdated(AppCacheGroup* group) {
-  DCHECK(!group_being_updated_);
+  DCHECK(!group_being_updated_.get());
   group_being_updated_ = group;
   newest_cache_of_group_being_updated_ = group->newest_complete_cache();
   group->AddUpdateObserver(this);
 }
 
 void AppCacheHost::OnUpdateComplete(AppCacheGroup* group) {
   DCHECK_EQ(group, group_being_updated_);
   group->RemoveUpdateObserver(this);
 
   // Add a reference to the newest complete cache.
@@ skipping 10 matching lines @@
     associated_cache_info_pending_ = false;
     frontend_->OnCacheSelected(host_id_, info);
   }
 }
 
 void AppCacheHost::SetSwappableCache(AppCacheGroup* group) {
   if (!group) {
     swappable_cache_ = NULL;
   } else {
     AppCache* new_cache = group->newest_complete_cache();
-    if (new_cache != associated_cache_)
+    if (new_cache != associated_cache_.get())
       swappable_cache_ = new_cache;
     else
       swappable_cache_ = NULL;
   }
 }
 
 void AppCacheHost::LoadMainResourceCache(int64 cache_id) {
   DCHECK(cache_id != kNoCacheId);
   if (pending_main_resource_cache_id_ == cache_id ||
-      (main_resource_cache_ && main_resource_cache_->cache_id() == cache_id)) {
+      (main_resource_cache_.get() &&
+       main_resource_cache_->cache_id() == cache_id)) {
     return;
   }
   pending_main_resource_cache_id_ = cache_id;
   service_->storage()->LoadCache(cache_id, this);
 }
 
 void AppCacheHost::NotifyMainResourceIsNamespaceEntry(
     const GURL& namespace_entry_url) {
   main_resource_was_namespace_entry_ = true;
   namespace_entry_url_ = namespace_entry_url;
@@ skipping 16 matching lines @@
   AssociateCacheHelper(cache, manifest_url);
 }
 
 void AppCacheHost::AssociateCompleteCache(AppCache* cache) {
   DCHECK(cache && cache->is_complete());
   AssociateCacheHelper(cache, cache->owning_group()->manifest_url());
 }
 
 void AppCacheHost::AssociateCacheHelper(AppCache* cache,
                                         const GURL& manifest_url) {
-  if (associated_cache_) {
+  if (associated_cache_.get()) {
     associated_cache_->UnassociateHost(this);
   }
 
   associated_cache_ = cache;
   SetSwappableCache(cache ? cache->owning_group() : NULL);
   associated_cache_info_pending_ = cache && !cache->is_complete();
   AppCacheInfo info;
   if (cache)
     cache->AssociateHost(this);
 
   FillCacheInfo(cache, manifest_url, GetStatus(), &info);
   frontend_->OnCacheSelected(host_id_, info);
 }
 
 }  // namespace appcache