base::Bind: Convert net/proxy.

net/proxy/dhcp_proxy_script_fetcher_win_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 "net/proxy/dhcp_proxy_script_fetcher_win.h"
 
 #include <vector>
 
 #include "base/message_loop.h"
 #include "base/perftimer.h"
@@ skipping 31 matching lines @@
   }
 }
 
 // Helper for RealFetch* tests below.
 class RealFetchTester {
  public:
   RealFetchTester()
       : context_((new TestURLRequestContext())),
         fetcher_(new DhcpProxyScriptFetcherWin(context_.get())),
         finished_(false),
-        ALLOW_THIS_IN_INITIALIZER_LIST(
-            completion_callback_(this, &RealFetchTester::OnCompletion)),
         on_completion_is_error_(false) {
     // Make sure the test ends.
     timeout_.Start(FROM_HERE,
         base::TimeDelta::FromSeconds(5), this, &RealFetchTester::OnTimeout);
   }
 
   void RunTest() {
-    int result = fetcher_->Fetch(&pac_text_, &completion_callback_);
+    int result = fetcher_->Fetch(
+        &pac_text_,
+        base::Bind(&RealFetchTester::OnCompletion, base::Unretained(this)));
     if (result != ERR_IO_PENDING)
       finished_ = true;
   }
 
   void RunTestWithCancel() {
     RunTest();
     fetcher_->Cancel();
   }
 
   void RunTestWithDeferredCancel() {
@@ skipping 37 matching lines @@
   // do something a bit more clever to track worker threads even when the
   // DhcpProxyScriptFetcherWin state machine has finished.
   void FinishTestAllowCleanup() {
     base::PlatformThread::Sleep(30);
   }
 
   scoped_refptr<URLRequestContext> context_;
   scoped_ptr<DhcpProxyScriptFetcherWin> fetcher_;
   bool finished_;
   string16 pac_text_;
-  OldCompletionCallbackImpl<RealFetchTester> completion_callback_;
   base::OneShotTimer<RealFetchTester> timeout_;
   base::OneShotTimer<RealFetchTester> cancel_timer_;
   bool on_completion_is_error_;
 };
 
 TEST(DhcpProxyScriptFetcherWin, RealFetch) {
   // This tests a call to Fetch() with no stubbing out of dependencies.
   //
   // We don't make assumptions about the environment this unit test is
   // running in, so it just exercises the code to make sure there
@@ skipping 79 matching lines @@
 // situations, with actual network access fully stubbed out.
 
 class DummyDhcpProxyScriptAdapterFetcher
     : public DhcpProxyScriptAdapterFetcher {
  public:
   DummyDhcpProxyScriptAdapterFetcher()
       : DhcpProxyScriptAdapterFetcher(new TestURLRequestContext()),
         did_finish_(false),
         result_(OK),
         pac_script_(L"bingo"),
-        fetch_delay_ms_(1),
-        client_callback_(NULL) {
+        fetch_delay_ms_(1) {
   }
 
   void Fetch(const std::string& adapter_name,
-             OldCompletionCallback* callback) OVERRIDE {
-    client_callback_ = callback;
+             const CompletionCallback& callback) OVERRIDE {
+    callback_ = callback;
     timer_.Start(FROM_HERE, base::TimeDelta::FromMilliseconds(fetch_delay_ms_),
                  this, &DummyDhcpProxyScriptAdapterFetcher::OnTimer);
   }
 
   void Cancel() OVERRIDE {
     timer_.Stop();
   }
 
   bool DidFinish() const OVERRIDE {
     return did_finish_;
   }
 
   int GetResult() const OVERRIDE {
     return result_;
   }
 
   string16 GetPacScript() const OVERRIDE {
     return pac_script_;
   }
 
   void OnTimer() {
-    client_callback_->Run(result_);
+    callback_.Run(result_);
   }
 
   void Configure(
       bool did_finish, int result, string16 pac_script, int fetch_delay_ms) {
     did_finish_ = did_finish;
     result_ = result;
     pac_script_ = pac_script;
     fetch_delay_ms_ = fetch_delay_ms;
   }
 
  private:
   bool did_finish_;
   int result_;
   string16 pac_script_;
   int fetch_delay_ms_;
-  OldCompletionCallback* client_callback_;
+  CompletionCallback callback_;
   base::OneShotTimer<DummyDhcpProxyScriptAdapterFetcher> timer_;
 };
 
 class MockDhcpProxyScriptFetcherWin : public DhcpProxyScriptFetcherWin {
  public:
   class MockAdapterQuery : public AdapterQuery {
    public:
     MockAdapterQuery() {
     }
 
@@ skipping 91 matching lines @@
 
   int max_wait_ms_;
   int num_fetchers_created_;
   base::WaitableEvent worker_finished_event_;
 };
 
 class FetcherClient {
 public:
   FetcherClient()
       : finished_(false),
-        result_(ERR_UNEXPECTED),
-        ALLOW_THIS_IN_INITIALIZER_LIST(
-            completion_callback_(this, &FetcherClient::OnCompletion)) {
+        result_(ERR_UNEXPECTED) {
   }
 
   void RunTest() {
-    int result = fetcher_.Fetch(&pac_text_, &completion_callback_);
+    int result = fetcher_.Fetch(
+        &pac_text_,
+        base::Bind(&FetcherClient::OnCompletion, base::Unretained(this)));
     ASSERT_EQ(ERR_IO_PENDING, result);
   }
 
   void RunMessageLoopUntilComplete() {
     while (!finished_) {
       MessageLoop::current()->RunAllPending();
     }
     MessageLoop::current()->RunAllPending();
   }
 
@@ skipping 14 matching lines @@
     finished_ = false;
     result_ = ERR_UNEXPECTED;
     pac_text_ = L"";
     fetcher_.ResetTestState();
   }
 
   MockDhcpProxyScriptFetcherWin fetcher_;
   bool finished_;
   int result_;
   string16 pac_text_;
-  OldCompletionCallbackImpl<FetcherClient> completion_callback_;
 };
 
 // We separate out each test's logic so that we can easily implement
 // the ReuseFetcher test at the bottom.
 void TestNormalCaseURLConfiguredOneAdapter(FetcherClient* client) {
   scoped_ptr<DummyDhcpProxyScriptAdapterFetcher> adapter_fetcher(
       new DummyDhcpProxyScriptAdapterFetcher());
   adapter_fetcher->Configure(true, OK, L"bingo", 1);
   client->fetcher_.PushBackAdapter("a", adapter_fetcher.release());
   client->RunTest();
@@ skipping 193 matching lines @@
   }
 
   // Re-do the first test to make sure the last test that was run did
   // not leave things in a bad state.
   (*test_functions.begin())(&client);
 }
 
 }  // namespace
 
 }  // namespace net