base::Bind: Convert most of net/http.

net/spdy/spdy_proxy_client_socket_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/spdy/spdy_proxy_client_socket.h"
 
+#include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/utf_string_conversions.h"
 #include "net/base/address_list.h"
 #include "net/base/net_log.h"
 #include "net/base/net_log_unittest.h"
 #include "net/base/mock_host_resolver.h"
 #include "net/base/test_completion_callback.h"
 #include "net/base/winsock_init.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_response_headers.h"
 #include "net/socket/client_socket_factory.h"
@@ skipping 76 matching lines @@
                                      "/");
   }
 
   void Run(int steps) {
     data_->StopAfter(steps);
     data_->Run();
   }
 
   scoped_ptr<SpdyProxyClientSocket> sock_;
   TestCompletionCallback read_callback_;
-  TestOldCompletionCallback read_callback_old_;
   TestCompletionCallback write_callback_;
   scoped_refptr<DeterministicSocketData> data_;
 
  private:
   scoped_refptr<HttpNetworkSession> session_;
   scoped_refptr<IOBuffer> read_buf_;
   SpdySessionDependencies session_deps_;
   MockConnect connect_data_;
   scoped_refptr<SpdySession> spdy_session_;
   scoped_refptr<SpdyStream> spdy_stream_;
@@ skipping 71 matching lines @@
             connection->Init(endpoint_host_port_pair_.ToString(),
                              transport_params_, LOWEST, CompletionCallback(),
                              session_->GetTransportSocketPool(),
                              BoundNetLog()));
   spdy_session_->InitializeWithSocket(connection.release(), false, OK);
 
   // Create the SPDY Stream
   ASSERT_EQ(
       OK,
       spdy_session_->CreateStream(url_, LOWEST, &spdy_stream_, BoundNetLog(),
-                                  NULL));
+                                  CompletionCallback()));
 
   // Create the SpdyProxyClientSocket
   sock_.reset(
       new SpdyProxyClientSocket(spdy_stream_, user_agent_,
                                 endpoint_host_port_pair_, url_,
                                 proxy_host_port_, session_->http_auth_cache(),
                                 session_->http_auth_handler_factory()));
 }
 
 scoped_refptr<IOBufferWithSize> SpdyProxyClientSocketTest::CreateBuffer(
@@ skipping 651 matching lines @@
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   AssertConnectFails(ERR_HTTPS_PROXY_TUNNEL_RESPONSE);
 
   Run(2);  // SpdySession consumes the next two reads and sends then to
            // sock_ to be buffered.
   EXPECT_EQ(ERR_SOCKET_NOT_CONNECTED,
             sock_->Read(NULL, 1, CompletionCallback()));
   scoped_refptr<IOBuffer> buf(new IOBuffer(kLen1 + kLen2));
   scoped_ptr<HttpStream> stream(sock_->CreateConnectResponseStream());
-  stream->ReadResponseBody(buf, kLen1 + kLen2, &read_callback_old_);
+  stream->ReadResponseBody(buf, kLen1 + kLen2, read_callback_.callback());
 }
 
 // ----------- Reads and Writes
 
 TEST_F(SpdyProxyClientSocketTest, AsyncReadAroundWrite) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   scoped_ptr<spdy::SpdyFrame> msg2(ConstructBodyFrame(kMsg2, kLen2));
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, false),
     CreateMockWrite(*msg2, 3, false),
@@ skipping 345 matching lines @@
 
   Run(2);
 
   EXPECT_TRUE(sock_.get());
   EXPECT_TRUE(read_callback_.have_result());
   EXPECT_TRUE(write_callback_.have_result());
 }
 
 // CompletionCallback that causes the SpdyProxyClientSocket to be
 // deleted when Run is invoked.
-class DeleteSockCallback : public TestOldCompletionCallback {
+class DeleteSockCallback : public TestCompletionCallbackBase {
  public:
   explicit DeleteSockCallback(scoped_ptr<SpdyProxyClientSocket>* sock)
-    : sock_(sock) {
+    : sock_(sock),
+      ALLOW_THIS_IN_INITIALIZER_LIST(callback_(
+          base::Bind(&DeleteSockCallback::OnComplete,
+                     base::Unretained(this)))) {
   }
 
   virtual ~DeleteSockCallback() {
   }
 
-  virtual void RunWithParams(const Tuple1<int>& params) OVERRIDE {
+  const CompletionCallback& callback() const { return callback_; }
+
+ private:
+  void OnComplete(int result) {
     sock_->reset(NULL);
-    TestOldCompletionCallback::RunWithParams(params);
+    SetResult(result);
   }
 
- private:
   scoped_ptr<SpdyProxyClientSocket>* sock_;
+  CompletionCallback callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(DeleteSockCallback);
 };
 
 // If the socket is Reset when both a read and write are pending, and the
 // read callback causes the socket to be deleted, the write callback should
 // not be called.
 TEST_F(SpdyProxyClientSocketTest, RstWithReadAndWritePendingDelete) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, false),
     MockWrite(true, ERR_IO_PENDING, 2),
   };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame());
   scoped_ptr<spdy::SpdyFrame> rst(ConstructSpdyRstStream(1, spdy::CANCEL));
   MockRead reads[] = {
     CreateMockRead(*resp, 1, true),
     CreateMockRead(*rst, 3, true),
   };
 
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   AssertConnectSucceeds();
 
   EXPECT_TRUE(sock_->IsConnected());
 
   DeleteSockCallback read_callback(&sock_);
 
   scoped_refptr<IOBuffer> read_buf(new IOBuffer(kLen1));
   ASSERT_EQ(ERR_IO_PENDING,
-            sock_->Read(read_buf, kLen1,
-                        base::Bind(&DeleteSockCallback::Run<int>,
-                                   base::Unretained(&read_callback))));
+            sock_->Read(read_buf, kLen1, read_callback.callback()));
 
   scoped_refptr<IOBufferWithSize> write_buf(CreateBuffer(kMsg1, kLen1));
   EXPECT_EQ(ERR_IO_PENDING, sock_->Write(write_buf, write_buf->size(),
                                          write_callback_.callback()));
 
   Run(2);
 
   EXPECT_FALSE(sock_.get());
   EXPECT_TRUE(read_callback.have_result());
   EXPECT_FALSE(write_callback_.have_result());
 }
 
 }  // namespace net