base::Bind: Cleanup in test_shell.

webkit/appcache/appcache_host_unittest.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 "base/callback.h"
+#include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/memory/scoped_ptr.h"
 #include "net/url_request/url_request.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/appcache/appcache.h"
 #include "webkit/appcache/appcache_backend_impl.h"
 #include "webkit/appcache/appcache_group.h"
 #include "webkit/appcache/appcache_host.h"
 #include "webkit/appcache/mock_appcache_policy.h"
 #include "webkit/appcache/mock_appcache_service.h"
 #include "webkit/quota/quota_manager.h"
 
 namespace appcache {
 
 class AppCacheHostTest : public testing::Test {
  public:
   AppCacheHostTest() {
-    get_status_callback_.reset(
-        NewCallback(this, &AppCacheHostTest::GetStatusCallback));
-    start_update_callback_.reset(
-        NewCallback(this, &AppCacheHostTest::StartUpdateCallback));
-    swap_cache_callback_.reset(
-        NewCallback(this, &AppCacheHostTest::SwapCacheCallback));
+    get_status_callback_ =
+        base::Bind(&AppCacheHostTest::GetStatusCallback,
+                   base::Unretained(this));
+    start_update_callback_ =
+        base::Bind(&AppCacheHostTest::StartUpdateCallback,
+                   base::Unretained(this));
+    swap_cache_callback_ =
+        base::Bind(&AppCacheHostTest::SwapCacheCallback,
+                   base::Unretained(this));
   }
 
   class MockFrontend : public AppCacheFrontend {
    public:
     MockFrontend()
         : last_host_id_(-222), last_cache_id_(-222),
           last_status_(appcache::OBSOLETE),
           last_status_changed_(appcache::OBSOLETE),
           last_event_id_(appcache::OBSOLETE_EVENT),
           content_blocked_(false) {
@@ skipping 90 matching lines @@
   void SwapCacheCallback(bool result, void* param) {
     last_swap_result_ = result;
     last_callback_param_ = param;
   }
 
   // Mock classes for the 'host' to work with
   MockAppCacheService service_;
   MockFrontend mock_frontend_;
 
   // Mock callbacks we expect to receive from the 'host'
-  scoped_ptr<appcache::GetStatusCallback> get_status_callback_;
-  scoped_ptr<appcache::StartUpdateCallback> start_update_callback_;
-  scoped_ptr<appcache::SwapCacheCallback> swap_cache_callback_;
+  appcache::GetStatusCallback get_status_callback_;
+  appcache::StartUpdateCallback start_update_callback_;
+  appcache::SwapCacheCallback swap_cache_callback_;
 
   Status last_status_result_;
   bool last_swap_result_;
   bool last_start_result_;
   void* last_callback_param_;
 };
 
 TEST_F(AppCacheHostTest, Basic) {
   // Construct a host and test what state it appears to be in.
   AppCacheHost host(1, &mock_frontend_, &service_);
   EXPECT_EQ(1, host.host_id());
   EXPECT_EQ(&service_, host.service());
   EXPECT_EQ(&mock_frontend_, host.frontend());
   EXPECT_EQ(NULL, host.associated_cache());
   EXPECT_FALSE(host.is_selection_pending());
 
   // See that the callbacks are delivered immediately
   // and respond as if there is no cache selected.
   last_status_result_ = OBSOLETE;
-  host.GetStatusWithCallback(get_status_callback_.get(),
-                             reinterpret_cast<void*>(1));
+  host.GetStatusWithCallback(get_status_callback_, reinterpret_cast<void*>(1));
   EXPECT_EQ(UNCACHED, last_status_result_);
   EXPECT_EQ(reinterpret_cast<void*>(1), last_callback_param_);
 
   last_start_result_ = true;
-  host.StartUpdateWithCallback(start_update_callback_.get(),
+  host.StartUpdateWithCallback(start_update_callback_,
                                reinterpret_cast<void*>(2));
   EXPECT_FALSE(last_start_result_);
   EXPECT_EQ(reinterpret_cast<void*>(2), last_callback_param_);
 
   last_swap_result_ = true;
-  host.SwapCacheWithCallback(swap_cache_callback_.get(),
-                             reinterpret_cast<void*>(3));
+  host.SwapCacheWithCallback(swap_cache_callback_, reinterpret_cast<void*>(3));
   EXPECT_FALSE(last_swap_result_);
   EXPECT_EQ(reinterpret_cast<void*>(3), last_callback_param_);
 }
 
 TEST_F(AppCacheHostTest, SelectNoCache) {
   scoped_refptr<MockQuotaManagerProxy> mock_quota_proxy(
       new MockQuotaManagerProxy);
   service_.set_quota_manager_proxy(mock_quota_proxy);
 
   // Reset our mock frontend
@@ skipping 92 matching lines @@
   const int kMockCacheId = 333;
 
   // Put it in a state where we're waiting on a cache
   // load prior to finishing cache selection.
   host.pending_selected_cache_id_ = kMockCacheId;
   EXPECT_TRUE(host.is_selection_pending());
 
   // The callback should not occur until we finish cache selection.
   last_status_result_ = OBSOLETE;
   last_callback_param_ = reinterpret_cast<void*>(-1);
-  host.GetStatusWithCallback(get_status_callback_.get(),
-                             reinterpret_cast<void*>(1));
+  host.GetStatusWithCallback(get_status_callback_, reinterpret_cast<void*>(1));
   EXPECT_EQ(OBSOLETE, last_status_result_);
   EXPECT_EQ(reinterpret_cast<void*>(-1), last_callback_param_);
 
   // Satisfy the load with NULL, a failure.
   host.OnCacheLoaded(NULL, kMockCacheId);
 
   // Cache selection should have finished
   EXPECT_FALSE(host.is_selection_pending());
   EXPECT_EQ(1, mock_frontend_.last_host_id_);
   EXPECT_EQ(kNoCacheId, mock_frontend_.last_cache_id_);
@@ skipping 10 matching lines @@
   const GURL kMockManifestUrl("http://foo.bar/baz");
 
   // Put it in a state where we're waiting on a cache
   // load prior to finishing cache selection.
   host.pending_selected_manifest_url_ = kMockManifestUrl;
   EXPECT_TRUE(host.is_selection_pending());
 
   // The callback should not occur until we finish cache selection.
   last_status_result_ = OBSOLETE;
   last_callback_param_ = reinterpret_cast<void*>(-1);
-  host.GetStatusWithCallback(get_status_callback_.get(),
-                             reinterpret_cast<void*>(1));
+  host.GetStatusWithCallback(get_status_callback_, reinterpret_cast<void*>(1));
   EXPECT_EQ(OBSOLETE, last_status_result_);
   EXPECT_EQ(reinterpret_cast<void*>(-1), last_callback_param_);
 
   // Satisfy the load will NULL, a failure.
   host.OnGroupLoaded(NULL, kMockManifestUrl);
 
   // Cache selection should have finished
   EXPECT_FALSE(host.is_selection_pending());
   EXPECT_EQ(1, mock_frontend_.last_host_id_);
   EXPECT_EQ(kNoCacheId, mock_frontend_.last_cache_id_);
@@ skipping 182 matching lines @@
     EXPECT_EQ(&mock_frontend_, host.frontend());
     EXPECT_EQ(NULL, host.associated_cache());
     EXPECT_FALSE(host.is_selection_pending());
     EXPECT_TRUE(host.preferred_manifest_url().is_empty());
   }
   EXPECT_EQ(0, mock_quota_proxy->GetInUseCount(kDocAndOriginUrl));
   service_.set_quota_manager_proxy(NULL);
 }
 
 }  // namespace appcache