Migrate net/socket/socket.h, net/socket/stream_socket.h to base::Bind().

jingle/notifier/base/fake_ssl_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 "jingle/notifier/base/fake_ssl_client_socket.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 29 matching lines @@
   // An error representing a server hello that has been corrupted in
   // transit.
   ERR_MALFORMED_SERVER_HELLO = -15000,
 };
 
 // Used by PassThroughMethods test.
 class MockClientSocket : public net::StreamSocket {
  public:
   virtual ~MockClientSocket() {}
 
-  MOCK_METHOD3(Read, int(net::IOBuffer*, int, net::OldCompletionCallback*));
   MOCK_METHOD3(Read, int(net::IOBuffer*, int,
                          const net::CompletionCallback&));
-  MOCK_METHOD3(Write, int(net::IOBuffer*, int, net::OldCompletionCallback*));
+  MOCK_METHOD3(Write, int(net::IOBuffer*, int,
+                          const net::CompletionCallback&));
   MOCK_METHOD1(SetReceiveBufferSize, bool(int32));
   MOCK_METHOD1(SetSendBufferSize, bool(int32));
-  MOCK_METHOD1(Connect, int(net::OldCompletionCallback*));
   MOCK_METHOD1(Connect, int(const net::CompletionCallback&));
   MOCK_METHOD0(Disconnect, void());
   MOCK_CONST_METHOD0(IsConnected, bool());
   MOCK_CONST_METHOD0(IsConnectedAndIdle, bool());
   MOCK_CONST_METHOD1(GetPeerAddress, int(net::AddressList*));
   MOCK_CONST_METHOD1(GetLocalAddress, int(net::IPEndPoint*));
   MOCK_CONST_METHOD0(NetLog, const net::BoundNetLog&());
   MOCK_METHOD0(SetSubresourceSpeculation, void());
   MOCK_METHOD0(SetOmniboxSpeculation, void());
   MOCK_CONST_METHOD0(WasEverUsed, bool());
@@ skipping 37 matching lines @@
         new net::StaticSocketDataProvider(
             reads->empty() ? NULL : &*reads->begin(), reads->size(),
             writes->empty() ? NULL : &*writes->begin(), writes->size()));
     static_socket_data_provider_->set_connect_data(mock_connect);
     mock_client_socket_factory_.AddSocketDataProvider(
         static_socket_data_provider_.get());
   }
 
   void ExpectStatus(
       bool async, int expected_status, int immediate_status,
-      TestOldCompletionCallback* test_completion_callback) {
+      net::TestCompletionCallback* test_completion_callback) {
     if (async) {
       EXPECT_EQ(net::ERR_IO_PENDING, immediate_status);
       int status = test_completion_callback->WaitForResult();
       EXPECT_EQ(expected_status, status);
     } else {
       EXPECT_EQ(expected_status, immediate_status);
     }
   }
 
   // Sets up the mock socket to generate a successful handshake
@@ skipping 20 matching lines @@
           net::MockRead(async, kReadTestData, arraysize(kReadTestData)));
       writes.push_back(
           net::MockWrite(async, kWriteTestData, arraysize(kWriteTestData)));
     }
     SetData(mock_connect, &reads, &writes);
 
     FakeSSLClientSocket fake_ssl_client_socket(MakeClientSocket());
 
     for (int i = 0; i < num_resets + 1; ++i) {
       SCOPED_TRACE(i);
-      TestOldCompletionCallback test_completion_callback;
-      int status = fake_ssl_client_socket.Connect(&test_completion_callback);
+      net::TestCompletionCallback test_completion_callback;
+      int status = fake_ssl_client_socket.Connect(
+          test_completion_callback.callback());
       if (async) {
         EXPECT_FALSE(fake_ssl_client_socket.IsConnected());
       }
       ExpectStatus(async, net::OK, status, &test_completion_callback);
       if (fake_ssl_client_socket.IsConnected()) {
         int read_len = arraysize(kReadTestData);
         int read_buf_len = 2 * read_len;
         scoped_refptr<net::IOBuffer> read_buf(
             new net::IOBuffer(read_buf_len));
         int read_status = fake_ssl_client_socket.Read(
-            read_buf, read_buf_len, &test_completion_callback);
+            read_buf, read_buf_len, test_completion_callback.callback());
         ExpectStatus(async, read_len, read_status, &test_completion_callback);
 
         scoped_refptr<net::IOBuffer> write_buf(
             new net::StringIOBuffer(kWriteTestData));
         int write_status = fake_ssl_client_socket.Write(
-            write_buf, arraysize(kWriteTestData), &test_completion_callback);
+            write_buf, arraysize(kWriteTestData),
+            test_completion_callback.callback());
         ExpectStatus(async, arraysize(kWriteTestData), write_status,
                      &test_completion_callback);
       } else {
         ADD_FAILURE();
       }
       fake_ssl_client_socket.Disconnect();
       EXPECT_FALSE(fake_ssl_client_socket.IsConnected());
     }
   }
 
@@ skipping 54 matching lines @@
 
     FakeSSLClientSocket fake_ssl_client_socket(MakeClientSocket());
 
     // The two errors below are interpreted by FakeSSLClientSocket as
     // an unexpected event.
     int expected_status =
         ((error == net::ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ) ||
          (error == ERR_MALFORMED_SERVER_HELLO)) ?
         net::ERR_UNEXPECTED : error;
 
-    TestOldCompletionCallback test_completion_callback;
-    int status = fake_ssl_client_socket.Connect(&test_completion_callback);
+    net::TestCompletionCallback test_completion_callback;
+    int status = fake_ssl_client_socket.Connect(
+        test_completion_callback.callback());
     EXPECT_FALSE(fake_ssl_client_socket.IsConnected());
     ExpectStatus(async, expected_status, status, &test_completion_callback);
     EXPECT_FALSE(fake_ssl_client_socket.IsConnected());
   }
 
   void RunUnsuccessfulHandshakeTest(
       int error, HandshakeErrorLocation location) {
     RunUnsuccessfulHandshakeTestHelper(false, error, location);
     RunUnsuccessfulHandshakeTestHelper(true, error, location);
   }
@@ skipping 77 matching lines @@
 }
 
 TEST_F(FakeSSLClientSocketTest, MalformedServerHello) {
   RunUnsuccessfulHandshakeTest(ERR_MALFORMED_SERVER_HELLO,
                                VERIFY_SERVER_HELLO_ERROR);
 }
 
 }  // namespace
 
 }  // namespace notifier