base::Bind: Convert most of webkit/appcache.

webkit/appcache/appcache_update_job_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 "testing/gtest/include/gtest/gtest.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/stl_util.h"
 #include "base/threading/thread.h"
@@ skipping 960 matching lines @@
     frontend1->AddExpectedEvent(ids1, CHECKING_EVENT);
     frontend1->AddExpectedEvent(ids1, NO_UPDATE_EVENT);
     MockFrontend::HostIds ids2(1, host2->host_id());
     frontend2->AddExpectedEvent(ids2, CHECKING_EVENT);
     frontend2->AddExpectedEvent(ids2, NO_UPDATE_EVENT);
 
     // Seed storage with expected manifest data.
     const std::string seed_data(kManifest1Contents);
     scoped_refptr<net::StringIOBuffer> io_buffer(
         new net::StringIOBuffer(seed_data));
-    write_callback_.reset(
-        new net::OldCompletionCallbackImpl<AppCacheUpdateJobTest>(this,
-            &AppCacheUpdateJobTest::StartUpdateAfterSeedingStorageData));
-    response_writer_->WriteData(io_buffer, seed_data.length(),
-                                write_callback_.get());
+    response_writer_->WriteData(
+        io_buffer, seed_data.length(),
+        base::Bind(&AppCacheUpdateJobTest::StartUpdateAfterSeedingStorageData,
+                   base::Unretained(this)));
 
     // Start update after data write completes asynchronously.
   }
 
   void StartUpdateAfterSeedingStorageData(int result) {
     ASSERT_GT(result, 0);
-    write_callback_.reset();
     response_writer_.reset();
 
     AppCacheUpdateJob* update = group_->update_job_;
     update->StartUpdate(NULL, GURL());
     EXPECT_TRUE(update->manifest_fetcher_ != NULL);
 
     WaitForUpdateToFinish();
   }
 
   void BasicCacheAttemptSuccessTest() {
@@ skipping 94 matching lines @@
     frontend2->AddExpectedEvent(ids2, DOWNLOADING_EVENT);
     frontend2->AddExpectedEvent(ids2, PROGRESS_EVENT);
     frontend2->AddExpectedEvent(ids2, PROGRESS_EVENT);
     frontend2->AddExpectedEvent(ids2, PROGRESS_EVENT);  // final
     frontend2->AddExpectedEvent(ids2, UPDATE_READY_EVENT);
 
     // Seed storage with expected manifest data different from manifest1.
     const std::string seed_data("different");
     scoped_refptr<net::StringIOBuffer> io_buffer(
         new net::StringIOBuffer(seed_data));
-    write_callback_.reset(
-        new net::OldCompletionCallbackImpl<AppCacheUpdateJobTest>(this,
-            &AppCacheUpdateJobTest::StartUpdateAfterSeedingStorageData));
-    response_writer_->WriteData(io_buffer, seed_data.length(),
-                                write_callback_.get());
+    response_writer_->WriteData(
+        io_buffer, seed_data.length(),
+        base::Bind(&AppCacheUpdateJobTest::StartUpdateAfterSeedingStorageData,
+                   base::Unretained(this)));
 
     // Start update after data write completes asynchronously.
   }
 
   void UpgradeLoadFromNewestCacheTest() {
     ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
 
     MakeService();
     group_ = new AppCacheGroup(
         service_.get(), MockHttpServer::GetMockUrl("files/manifest1"),
@@ skipping 38 matching lines @@
         "Cache-Control: max-age=8675309\0"
         "\0";
     net::HttpResponseHeaders* headers =
         new net::HttpResponseHeaders(std::string(data, arraysize(data)));
     net::HttpResponseInfo* response_info = new net::HttpResponseInfo();
     response_info->request_time = base::Time::Now();
     response_info->response_time = base::Time::Now();
     response_info->headers = headers;  // adds ref to headers
     scoped_refptr<HttpResponseInfoIOBuffer> io_buffer(
         new HttpResponseInfoIOBuffer(response_info));  // adds ref to info
-    write_callback_.reset(
-        new net::OldCompletionCallbackImpl<AppCacheUpdateJobTest>(this,
-            &AppCacheUpdateJobTest::StartUpdateAfterSeedingStorageData));
-    response_writer_->WriteInfo(io_buffer, write_callback_.get());
+    response_writer_->WriteInfo(
+        io_buffer,
+        base::Bind(&AppCacheUpdateJobTest::StartUpdateAfterSeedingStorageData,
+                   base::Unretained(this)));
 
     // Start update after data write completes asynchronously.
   }
 
   void UpgradeNoLoadFromNewestCacheTest() {
     ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
 
     MakeService();
     group_ = new AppCacheGroup(
         service_.get(), MockHttpServer::GetMockUrl("files/manifest1"),
@@ skipping 35 matching lines @@
         "Expires: Thu, 01 Dec 1994 16:00:00 GMT\0"
         "\0";
     net::HttpResponseHeaders* headers =
         new net::HttpResponseHeaders(std::string(data, arraysize(data)));
     net::HttpResponseInfo* response_info = new net::HttpResponseInfo();
     response_info->request_time = base::Time::Now();
     response_info->response_time = base::Time::Now();
     response_info->headers = headers;  // adds ref to headers
     scoped_refptr<HttpResponseInfoIOBuffer> io_buffer(
         new HttpResponseInfoIOBuffer(response_info));  // adds ref to info
-    write_callback_.reset(
-        new net::OldCompletionCallbackImpl<AppCacheUpdateJobTest>(this,
-            &AppCacheUpdateJobTest::StartUpdateAfterSeedingStorageData));
-    response_writer_->WriteInfo(io_buffer, write_callback_.get());
+    response_writer_->WriteInfo(
+        io_buffer,
+        base::Bind(&AppCacheUpdateJobTest::StartUpdateAfterSeedingStorageData,
+                   base::Unretained(this)));
 
     // Start update after data write completes asynchronously.
   }
 
   void UpgradeLoadFromNewestCacheVaryHeaderTest() {
     ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
 
     MakeService();
     group_ = new AppCacheGroup(
         service_.get(), MockHttpServer::GetMockUrl("files/manifest1"),
@@ skipping 35 matching lines @@
         "Vary: blah\0"
         "\0";
     net::HttpResponseHeaders* headers =
         new net::HttpResponseHeaders(std::string(data, arraysize(data)));
     net::HttpResponseInfo* response_info = new net::HttpResponseInfo();
     response_info->request_time = base::Time::Now();
     response_info->response_time = base::Time::Now();
     response_info->headers = headers;  // adds ref to headers
     scoped_refptr<HttpResponseInfoIOBuffer> io_buffer(
         new HttpResponseInfoIOBuffer(response_info));  // adds ref to info
-    write_callback_.reset(
-        new net::OldCompletionCallbackImpl<AppCacheUpdateJobTest>(this,
-            &AppCacheUpdateJobTest::StartUpdateAfterSeedingStorageData));
-    response_writer_->WriteInfo(io_buffer, write_callback_.get());
+    response_writer_->WriteInfo(
+        io_buffer,
+        base::Bind(&AppCacheUpdateJobTest::StartUpdateAfterSeedingStorageData,
+                   base::Unretained(this)));
 
     // Start update after data write completes asynchronously.
   }
 
   void UpgradeSuccessMergedTypesTest() {
     ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
 
     MakeService();
     group_ = new AppCacheGroup(service_.get(),
         MockHttpServer::GetMockUrl("files/manifest-merged-types"),
@@ skipping 1357 matching lines @@
     const char data[] =
         "HTTP/1.1 200 OK\0"
         "Last-Modified: Sat, 29 Oct 1994 19:43:31 GMT\0"
         "\0";
     net::HttpResponseHeaders* headers =
         new net::HttpResponseHeaders(std::string(data, arraysize(data)));
     net::HttpResponseInfo* response_info = new net::HttpResponseInfo();
     response_info->headers = headers;  // adds ref to headers
     scoped_refptr<HttpResponseInfoIOBuffer> io_buffer(
         new HttpResponseInfoIOBuffer(response_info));  // adds ref to info
-    write_callback_.reset(
-        new net::OldCompletionCallbackImpl<AppCacheUpdateJobTest>(this,
-            &AppCacheUpdateJobTest::StartUpdateAfterSeedingStorageData));
-    response_writer_->WriteInfo(io_buffer, write_callback_.get());
+    response_writer_->WriteInfo(
+        io_buffer,
+        base::Bind(&AppCacheUpdateJobTest::StartUpdateAfterSeedingStorageData,
+                   base::Unretained(this)));
 
     // Start update after data write completes asynchronously.
   }
 
   void IfNoneMatchUpgradeTest() {
     ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
 
     HttpHeadersRequestTestJob::Initialize("", "\"LadeDade\"");
     net::URLRequestJobFactory* new_factory(new net::URLRequestJobFactory);
     new_factory->SetProtocolHandler("http", new IfModifiedSinceJobFactory);
@@ skipping 35 matching lines @@
     const char data[] =
         "HTTP/1.1 200 OK\0"
         "ETag: \"LadeDade\"\0"
         "\0";
     net::HttpResponseHeaders* headers =
         new net::HttpResponseHeaders(std::string(data, arraysize(data)));
     net::HttpResponseInfo* response_info = new net::HttpResponseInfo();
     response_info->headers = headers;  // adds ref to headers
     scoped_refptr<HttpResponseInfoIOBuffer> io_buffer(
         new HttpResponseInfoIOBuffer(response_info));  // adds ref to info
-    write_callback_.reset(
-        new net::OldCompletionCallbackImpl<AppCacheUpdateJobTest>(this,
-            &AppCacheUpdateJobTest::StartUpdateAfterSeedingStorageData));
-    response_writer_->WriteInfo(io_buffer, write_callback_.get());
+    response_writer_->WriteInfo(
+        io_buffer,
+        base::Bind(&AppCacheUpdateJobTest::StartUpdateAfterSeedingStorageData,
+                   base::Unretained(this)));
 
     // Start update after data write completes asynchronously.
   }
 
   void IfNoneMatchRefetchTest() {
     ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
 
     HttpHeadersRequestTestJob::Initialize("", "\"LadeDade\"");
     net::URLRequestJobFactory* new_factory(new net::URLRequestJobFactory);
     new_factory->SetProtocolHandler("http", new IfModifiedSinceJobFactory);
@@ skipping 481 matching lines @@
   };
 
   scoped_ptr<IOThread> io_thread_;
 
   scoped_ptr<MockAppCacheService> service_;
   scoped_refptr<AppCacheGroup> group_;
   scoped_refptr<AppCache> protect_newest_cache_;
   scoped_ptr<base::WaitableEvent> event_;
 
   scoped_ptr<AppCacheResponseWriter> response_writer_;
-  scoped_ptr<net::OldCompletionCallbackImpl<AppCacheUpdateJobTest> >
-      write_callback_;
 
   // Hosts used by an async test that need to live until update job finishes.
   // Otherwise, test can put host on the stack instead of here.
   std::vector<AppCacheHost*> hosts_;
 
   // Response infos used by an async test that need to live until update job
   // finishes.
   std::vector<scoped_refptr<AppCacheResponseInfo> > response_infos_;
 
   // Flag indicating if test cares to verify the update after update finishes.
@@ skipping 276 matching lines @@
 
 TEST_F(AppCacheUpdateJobTest, CrossOriginHttpsSuccess) {
   RunTestOnIOThread(&AppCacheUpdateJobTest::CrossOriginHttpsSuccessTest);
 }
 
 TEST_F(AppCacheUpdateJobTest, CrossOriginHttpsDenied) {
   RunTestOnIOThread(&AppCacheUpdateJobTest::CrossOriginHttpsDeniedTest);
 }
 
 }  // namespace appcache