base::Bind: Convert chrome_frame/.

chrome_frame/test/url_request_test.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 <atlbase.h>
 #include <atlcom.h>
 
+#include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/win/scoped_com_initializer.h"
 #include "chrome/common/automation_messages.h"
 #include "chrome_frame/test/chrome_frame_test_utils.h"
 #include "chrome_frame/test/test_server.h"
 #include "chrome_frame/test/test_with_web_server.h"
 #include "chrome_frame/urlmon_url_request.h"
 #include "chrome_frame/urlmon_url_request_private.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gmock_mutant.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 25 matching lines @@
       const net::HostPortPair& socket_address));
   MOCK_METHOD2(OnReadComplete, void(int request_id, const std::string& data));
   MOCK_METHOD2(OnResponseEnd, void(int request_id,
                                    const net::URLRequestStatus& status));
   MOCK_METHOD4(OnCookiesRetrieved, void(bool success, const GURL& url,
       const std::string& cookie, int cookie_id));
 
   static bool ImplementsThreadSafeReferenceCounting() {
     return false;
   }
-  void AddRef() {}
-  void Release() {}
 
   void PostponeReadRequest(chrome_frame_test::TimedMsgLoop* loop,
                    UrlmonUrlRequest* request, int bytes_to_read) {
-    loop->PostDelayedTask(FROM_HERE, NewRunnableMethod(this,
-        &MockUrlDelegate::RequestRead, request, bytes_to_read), 0);
+    loop->PostTask(FROM_HERE,
+                   base::Bind(&MockUrlDelegate::RequestRead,
+                              base::Unretained(this), request, bytes_to_read));
   }
 
  private:
   void RequestRead(UrlmonUrlRequest* request, int bytes_to_read) {
     request->Read(bytes_to_read);
   }
 };
 
 // Simplest UrlmonUrlRequest. Retrieve a file from local web server.
 TEST(UrlmonUrlRequestTest, Simple1) {
@@ skipping 166 matching lines @@
 
   // Invoke read. Only now the response end ("server closed the connection")
   // is supposed to be delivered.
   EXPECT_CALL(mock, OnResponseEnd(1, testing::Property(
       &net::URLRequestStatus::is_success, true))).Times(1);
   request.Read(512);
   request.Release();
 }
 
 ACTION_P4(ManagerRead, loop, mgr, request_id, bytes_to_read) {
-  loop->PostDelayedTask(FROM_HERE, NewRunnableMethod(mgr,
-      &UrlmonUrlRequestManager::ReadUrlRequest, request_id,
-      bytes_to_read), 0);
+  loop->PostTask(FROM_HERE,
+                 base::Bind(&UrlmonUrlRequestManager::ReadUrlRequest,
+                            base::Unretained(mgr), request_id, bytes_to_read));
 }
 ACTION_P3(ManagerEndRequest, loop, mgr, request_id) {
-  loop->PostDelayedTask(FROM_HERE, NewRunnableMethod(mgr,
-      &UrlmonUrlRequestManager::EndUrlRequest, request_id,
-      net::URLRequestStatus()), 0);
+  loop->PostTask(FROM_HERE, base::Bind(&UrlmonUrlRequestManager::EndUrlRequest,
+                                       base::Unretained(mgr), request_id,
+                                       net::URLRequestStatus()));
 }
 
 // Simplest test - retrieve file from local web server.
 TEST(UrlmonUrlRequestManagerTest, Simple1) {
   MockUrlDelegate mock;
   chrome_frame_test::TimedMsgLoop loop;
 
   testing::StrictMock<MockWebServer> mock_server(1337, L"127.0.0.1",
       chrome_frame_test::GetTestDataFolder());
   mock_server.ExpectAndServeAnyRequests(CFInvocation(CFInvocation::NONE));
@@ skipping 51 matching lines @@
   EXPECT_CALL(mock, OnReadComplete(1, testing::_))
     .Times(0);
 
   EXPECT_CALL(mock, OnResponseEnd(1, testing::_))
     .Times(0);
 
   mgr->StartUrlRequest(1, r1);
   loop.RunFor(kChromeFrameLongNavigationTimeoutInSeconds);
   mgr.reset();
 }