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

webkit/appcache/appcache_request_handler_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 <stack>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 37 matching lines @@
     virtual void OnProgressEventRaised(const std::vector<int>& host_ids,
                                        const GURL& url,
                                        int num_total, int num_complete) {}
 
     virtual void OnLogMessage(int host_id, appcache::LogLevel log_level,
                               const std::string& message) {}
 
     virtual void OnContentBlocked(int host_id, const GURL& manifest_url) {}
   };
 
-  // Helper class run a test on our io_thread. The io_thread
-  // is spun up once and reused for all tests.
+  // Helper class to run a test on our io_thread. The io_thread is spun up once
+  // and reused for all tests.
   template <class Method>
-  class WrapperTask : public Task {
+  class MethodWrapper
+      : public base::RefCountedThreadSafe<MethodWrapper<Method> > {
    public:
-    WrapperTask(AppCacheRequestHandlerTest* test, Method method)
+    MethodWrapper(AppCacheRequestHandlerTest* test, Method method)
         : test_(test), method_(method) {
     }
 
-    virtual void Run() {
+    void Run() {
       test_->SetUpTest();
       (test_->*method_)();
     }
 
    private:
     AppCacheRequestHandlerTest* test_;
     Method method_;
+
+    DISALLOW_COPY_AND_ASSIGN(MethodWrapper);
   };
 
   // Subclasses to simulate particular responses so test cases can
   // exercise fallback code paths.
 
   class MockURLRequestDelegate : public net::URLRequest::Delegate {
     virtual void OnResponseStarted(net::URLRequest* request) {}
     virtual void OnReadCompleted(net::URLRequest* request, int bytes_read) {}
   };
 
@@ skipping 76 matching lines @@
   // Test harness --------------------------------------------------
 
   AppCacheRequestHandlerTest()
       : host_(NULL), orig_http_factory_(NULL) {
   }
 
   template <class Method>
   void RunTestOnIOThread(Method method) {
     test_finished_event_ .reset(new base::WaitableEvent(false, false));
     io_thread_->message_loop()->PostTask(
-        FROM_HERE, new WrapperTask<Method>(this, method));
+        FROM_HERE, base::Bind(&MethodWrapper<Method>::Run,

[awong, 2011/12/20 23:51:47]

I think this can just be base::Bind(method, base::Unretained(this))

and then you can just drop the whole MethodWrapper bit.

[James Hawkins, 2011/12/21 00:43:08]

The wrapper calls test->SetUpTest() before calling |method()|.

[awong, 2011/12/21 00:50:32]

Gotcha.  Then can we change MethodWrapper to just a template function?

+                              new MethodWrapper<Method>(this, method)));
     test_finished_event_->Wait();
   }
 
   void SetUpTest() {
     DCHECK(MessageLoop::current() == io_thread_->message_loop());
     orig_http_factory_ = net::URLRequest::Deprecated::RegisterProtocolFactory(
         "http", MockHttpJobFactory);
     mock_service_.reset(new MockAppCacheService);
     mock_policy_.reset(new MockAppCachePolicy);
     mock_service_->set_appcache_policy(mock_policy_.get());
@@ skipping 716 matching lines @@
 
 TEST_F(AppCacheRequestHandlerTest, WorkerRequest) {
   RunTestOnIOThread(&AppCacheRequestHandlerTest::WorkerRequest);
 }
 
 TEST_F(AppCacheRequestHandlerTest, MainResource_Blocked) {
   RunTestOnIOThread(&AppCacheRequestHandlerTest::MainResource_Blocked);
 }
 
 }  // namespace appcache