base::Bind: Cleanup in test_shell.

webkit/appcache/appcache_host.h

 // 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.
 
 #ifndef WEBKIT_APPCACHE_APPCACHE_HOST_H_
 #define WEBKIT_APPCACHE_APPCACHE_HOST_H_
 
 #include "base/callback.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/observer_list.h"
 #include "googleurl/src/gurl.h"
 #include "webkit/appcache/appcache_group.h"
 #include "webkit/appcache/appcache_interfaces.h"
 #include "webkit/appcache/appcache_export.h"
 #include "webkit/appcache/appcache_service.h"
 #include "webkit/appcache/appcache_storage.h"
 #include "webkit/glue/resource_type.h"
 
 namespace net {
 class URLRequest;
 }  // namespace net
 
 namespace appcache {
 
 class AppCache;
 class AppCacheFrontend;
 class AppCacheRequestHandler;
 
-typedef Callback2<Status, void*>::Type GetStatusCallback;
-typedef Callback2<bool, void*>::Type StartUpdateCallback;
-typedef Callback2<bool, void*>::Type SwapCacheCallback;
+typedef base::Callback<void(Status, void*)> GetStatusCallback;
+typedef base::Callback<void(bool, void*)> StartUpdateCallback;
+typedef base::Callback<void(bool, void*)> SwapCacheCallback;
 
 // Server-side representation of an application cache host.
 class APPCACHE_EXPORT AppCacheHost : public AppCacheStorage::Delegate,
                                      public AppCacheGroup::UpdateObserver {
  public:
 
   class APPCACHE_EXPORT Observer {
    public:
     // Called just after the cache selection algorithm completes.
     virtual void OnCacheSelectionComplete(AppCacheHost* host) = 0;
@@ skipping 15 matching lines @@
 
   // Support for cache selection and scriptable method calls.
   void SelectCache(const GURL& document_url,
                    const int64 cache_document_was_loaded_from,
                    const GURL& manifest_url);
   void SelectCacheForWorker(int parent_process_id,
                             int parent_host_id);
   void SelectCacheForSharedWorker(int64 appcache_id);
   void MarkAsForeignEntry(const GURL& document_url,
                           int64 cache_document_was_loaded_from);
-  void GetStatusWithCallback(GetStatusCallback* callback,
+  void GetStatusWithCallback(const GetStatusCallback& callback,
                              void* callback_param);
-  void StartUpdateWithCallback(StartUpdateCallback* callback,
+  void StartUpdateWithCallback(const StartUpdateCallback& callback,
                                void* callback_param);
-  void SwapCacheWithCallback(SwapCacheCallback* callback,
+  void SwapCacheWithCallback(const SwapCacheCallback& callback,
                              void* callback_param);
 
   // Called prior to the main resource load. When the system contains multiple
   // candidates for a main resource load, the appcache preferred by the host
   // that created this host is used to break ties.
   void SetSpawningHostId(int spawning_process_id, int spawning_host_id);
 
   // May return NULL if the spawning host context has been closed, or if a
   // spawning host context was never identified.
   const AppCacheHost* GetSpawningHost() const;
@@ skipping 129 matching lines @@
 
   // A new master entry to be added to the cache, may be empty.
   GURL new_master_entry_url_;
 
   // The frontend proxy to deliver notifications to the child process.
   AppCacheFrontend* frontend_;
 
   // Our central service object.
   AppCacheService* service_;
 
-  // Since these are synchronous scriptable api calls in the client,
-  // there can only be one type of callback pending.
-  // Also, we have to wait until we have a cache selection prior
-  // to responding to these calls, as cache selection involves
-  // async loading of a cache or a group from storage.
-  GetStatusCallback* pending_get_status_callback_;
-  StartUpdateCallback* pending_start_update_callback_;
-  SwapCacheCallback* pending_swap_cache_callback_;
+  // Since these are synchronous scriptable API calls in the client, there can
+  // only be one type of callback pending. Also, we have to wait until we have a
+  // cache selection prior to responding to these calls, as cache selection
+  // involves async loading of a cache or a group from storage.
+  GetStatusCallback pending_get_status_callback_;
+  StartUpdateCallback pending_start_update_callback_;
+  SwapCacheCallback pending_swap_cache_callback_;
   void* pending_callback_param_;
 
   // True if a fallback resource was delivered as the main resource.
   bool main_resource_was_fallback_;
   GURL fallback_url_;
 
   // True if requests for this host were blocked by a policy.
   bool main_resource_blocked_;
   GURL blocked_manifest_url_;
 
@@ skipping 24 matching lines @@
   FRIEND_TEST_ALL_PREFIXES(AppCacheHostTest, SelectCacheAllowed);
   FRIEND_TEST_ALL_PREFIXES(AppCacheHostTest, SelectCacheBlocked);
   FRIEND_TEST_ALL_PREFIXES(AppCacheGroupTest, QueueUpdate);
 
   DISALLOW_COPY_AND_ASSIGN(AppCacheHost);
 };
 
 }  // namespace appcache
 
 #endif  // WEBKIT_APPCACHE_APPCACHE_HOST_H_