base::Bind: Cleanup in test_shell.

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 "webkit/appcache/appcache.h"
@@ skipping 23 matching lines @@
 }  // Anonymous namespace
 
 AppCacheHost::AppCacheHost(int host_id, AppCacheFrontend* frontend,
                            AppCacheService* service)
     : host_id_(host_id),
       spawning_host_id_(kNoHostId), spawning_process_id_(0),
       parent_host_id_(kNoHostId), parent_process_id_(0),
       pending_main_resource_cache_id_(kNoCacheId),
       pending_selected_cache_id_(kNoCacheId),
       frontend_(frontend), service_(service),
-      pending_get_status_callback_(NULL), pending_start_update_callback_(NULL),
-      pending_swap_cache_callback_(NULL), pending_callback_param_(NULL),
+      pending_callback_param_(NULL),
       main_resource_was_fallback_(false), main_resource_blocked_(false),
       associated_cache_info_pending_(false) {
 }
 
 AppCacheHost::~AppCacheHost() {
   FOR_EACH_OBSERVER(Observer, observers_, OnDestructionImminent(this));
   if (associated_cache_.get())
     associated_cache_->UnassociateHost(this);
   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);
 }
 
 void AppCacheHost::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void AppCacheHost::SelectCache(const GURL& document_url,
                                const int64 cache_document_was_loaded_from,
                                const GURL& manifest_url) {
-  DCHECK(!pending_start_update_callback_ &&
-         !pending_swap_cache_callback_ &&
-         !pending_get_status_callback_ &&
+  DCHECK(pending_start_update_callback_.is_null() &&
+         pending_swap_cache_callback_.is_null() &&
+         pending_get_status_callback_.is_null() &&
          !is_selection_pending());
 
   origin_in_use_ = document_url.GetOrigin();
   if (service()->quota_manager_proxy() && !origin_in_use_.is_empty())
     service()->quota_manager_proxy()->NotifyOriginInUse(origin_in_use_);
 
   if (main_resource_blocked_)
     frontend_->OnContentBlocked(host_id_,
                                 blocked_manifest_url_);
 
@@ skipping 33 matching lines @@
     return;
   }
 
   // TODO(michaeln): If there was a manifest URL, the user agent may report
   // to the user that it was ignored, to aid in application development.
   FinishCacheSelection(NULL, NULL);
 }
 
 void AppCacheHost::SelectCacheForWorker(int parent_process_id,
                                         int parent_host_id) {
-  DCHECK(!pending_start_update_callback_ &&
-         !pending_swap_cache_callback_ &&
-         !pending_get_status_callback_ &&
+  DCHECK(pending_start_update_callback_.is_null() &&
+         pending_swap_cache_callback_.is_null() &&
+         pending_get_status_callback_.is_null() &&
          !is_selection_pending());
 
   parent_process_id_ = parent_process_id;
   parent_host_id_ = parent_host_id;
   FinishCacheSelection(NULL, NULL);
 }
 
 void AppCacheHost::SelectCacheForSharedWorker(int64 appcache_id) {
-  DCHECK(!pending_start_update_callback_ &&
-         !pending_swap_cache_callback_ &&
-         !pending_get_status_callback_ &&
+  DCHECK(pending_start_update_callback_.is_null() &&
+         pending_swap_cache_callback_.is_null() &&
+         pending_get_status_callback_.is_null() &&
          !is_selection_pending());
 
   if (appcache_id != kNoCacheId) {
     LoadSelectedCache(appcache_id);
     return;
   }
   FinishCacheSelection(NULL, NULL);
 }
 
 // TODO(michaeln): change method name to MarkEntryAsForeign for consistency
 void AppCacheHost::MarkAsForeignEntry(const GURL& document_url,
                                       int64 cache_document_was_loaded_from) {
   // The document url is not the resource url in the fallback case.
   service_->storage()->MarkEntryAsForeign(
       main_resource_was_fallback_ ? fallback_url_ : document_url,
       cache_document_was_loaded_from);
   SelectCache(document_url, kNoCacheId, GURL());
 }
 
-void AppCacheHost::GetStatusWithCallback(GetStatusCallback* callback,
+void AppCacheHost::GetStatusWithCallback(const GetStatusCallback& callback,
                                          void* callback_param) {
-  DCHECK(!pending_start_update_callback_ &&
-         !pending_swap_cache_callback_ &&
-         !pending_get_status_callback_);
+  DCHECK(pending_start_update_callback_.is_null() &&
+         pending_swap_cache_callback_.is_null() &&
+         pending_get_status_callback_.is_null());
 
   pending_get_status_callback_ = callback;
   pending_callback_param_ = callback_param;
   if (is_selection_pending())
     return;
 
   DoPendingGetStatus();
 }
 
 void AppCacheHost::DoPendingGetStatus() {
-  DCHECK(pending_get_status_callback_);
+  DCHECK_EQ(false, pending_get_status_callback_.is_null());
 
-  pending_get_status_callback_->Run(
-      GetStatus(), pending_callback_param_);
-
-  pending_get_status_callback_ = NULL;
+  pending_get_status_callback_.Run(GetStatus(), pending_callback_param_);
+  pending_get_status_callback_.Reset();
   pending_callback_param_ = NULL;
 }
 
-void AppCacheHost::StartUpdateWithCallback(StartUpdateCallback* callback,
+void AppCacheHost::StartUpdateWithCallback(const StartUpdateCallback& callback,
                                            void* callback_param) {
-  DCHECK(!pending_start_update_callback_ &&
-         !pending_swap_cache_callback_ &&
-         !pending_get_status_callback_);
+  DCHECK(pending_start_update_callback_.is_null() &&
+         pending_swap_cache_callback_.is_null() &&
+         pending_get_status_callback_.is_null());
 
   pending_start_update_callback_ = callback;
   pending_callback_param_ = callback_param;
   if (is_selection_pending())
     return;
 
   DoPendingStartUpdate();
 }
 
 void AppCacheHost::DoPendingStartUpdate() {
-  DCHECK(pending_start_update_callback_);
+  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()) {
     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_ = NULL;
+  pending_start_update_callback_.Run(success, pending_callback_param_);
+  pending_start_update_callback_.Reset();
   pending_callback_param_ = NULL;
 }
 
-void AppCacheHost::SwapCacheWithCallback(SwapCacheCallback* callback,
+void AppCacheHost::SwapCacheWithCallback(const SwapCacheCallback& callback,
                                          void* callback_param) {
-  DCHECK(!pending_start_update_callback_ &&
-         !pending_swap_cache_callback_ &&
-         !pending_get_status_callback_);
+  DCHECK(pending_start_update_callback_.is_null() &&
+         pending_swap_cache_callback_.is_null() &&
+         pending_get_status_callback_.is_null());
 
   pending_swap_cache_callback_ = callback;
   pending_callback_param_ = callback_param;
   if (is_selection_pending())
     return;
 
   DoPendingSwapCache();
 }
 
 void AppCacheHost::DoPendingSwapCache() {
-  DCHECK(pending_swap_cache_callback_);
+  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_->owning_group()->is_obsolete()) {
       success = true;
       AssociateCache(NULL);
     } else if (swappable_cache_) {
       DCHECK(swappable_cache_.get() ==
              swappable_cache_->owning_group()->newest_complete_cache());
       success = true;
       AssociateCache(swappable_cache_);
     }
   }
 
-  pending_swap_cache_callback_->Run(
-      success, pending_callback_param_);
-
-  pending_swap_cache_callback_ = NULL;
+  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) {
   spawning_process_id_ = spawning_process_id;
   spawning_host_id_ = spawning_host_id;
 }
 
 const AppCacheHost* AppCacheHost::GetSpawningHost() const {
@@ skipping 132 matching lines @@
     AssociateCache(NULL);  // The UpdateJob may produce one for us later.
     group->StartUpdateWithNewMasterEntry(this, new_master_entry_url_);
     ObserveGroupBeingUpdated(group);
   } else {
     // Otherwise, the Document is not associated with any application cache.
     new_master_entry_url_ = GURL();
     AssociateCache(NULL);
   }
 
   // Respond to pending callbacks now that we have a selection.
-  if (pending_get_status_callback_)
+  if (!pending_get_status_callback_.is_null())
     DoPendingGetStatus();
-  else if (pending_start_update_callback_)
+  else if (!pending_start_update_callback_.is_null())
     DoPendingStartUpdate();
-  else if (pending_swap_cache_callback_)
+  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_);
   group_being_updated_ = group;
   newest_cache_of_group_being_updated_ = group->newest_complete_cache();
   group->AddUpdateObserver(this);
@@ skipping 60 matching lines @@
   associated_cache_info_pending_ = cache && !cache->is_complete();
   AppCacheInfo info;
   if (cache) {
     cache->AssociateHost(this);
     FillCacheInfo(cache, GetStatus(), &info);
   }
   frontend_->OnCacheSelected(host_id_, info);
 }
 
 }  // namespace appcache