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

net/socket/client_socket_pool_base_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/socket/client_socket_pool_base.h"
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_vector.h"
@@ skipping 45 matching lines @@
 };
 typedef ClientSocketPoolBase<TestSocketParams> TestClientSocketPoolBase;
 
 class MockClientSocket : public StreamSocket {
  public:
   MockClientSocket() : connected_(false), was_used_to_convey_data_(false),
                        num_bytes_read_(0) {}
 
   // Socket implementation.
   virtual int Read(
-      IOBuffer* /* buf */, int len, OldCompletionCallback* /* callback */) {
-    num_bytes_read_ += len;
-    return len;
-  }
-  virtual int Read(
-      IOBuffer* /* buf */, int len, const CompletionCallback& /* callback */) {
+      IOBuffer* /* buf */, int len,
+      const CompletionCallback& /* callback */) OVERRIDE {
     num_bytes_read_ += len;
     return len;
   }
 
   virtual int Write(
-      IOBuffer* /* buf */, int len, OldCompletionCallback* /* callback */) {
+      IOBuffer* /* buf */, int len,
+      const CompletionCallback& /* callback */) OVERRIDE {
     was_used_to_convey_data_ = true;
     return len;
   }
   virtual bool SetReceiveBufferSize(int32 size) { return true; }
   virtual bool SetSendBufferSize(int32 size) { return true; }
 
   // StreamSocket implementation.
-  virtual int Connect(OldCompletionCallback* callback) {
+  virtual int Connect(const CompletionCallback& callback) OVERRIDE {
     connected_ = true;
     return OK;
   }
-  virtual int Connect(const net::CompletionCallback& callback) {
-    connected_ = true;
-    return OK;
-  }
 
   virtual void Disconnect() { connected_ = false; }
   virtual bool IsConnected() const { return connected_; }
   virtual bool IsConnectedAndIdle() const { return connected_; }
 
   virtual int GetPeerAddress(AddressList* /* address */) const {
     return ERR_UNEXPECTED;
   }
 
   virtual int GetLocalAddress(IPEndPoint* /* address */) const {
@@ skipping 218 matching lines @@
         set_socket(NULL);
         return ERR_FAILED;
     }
   }
 
   void set_load_state(LoadState load_state) { load_state_ = load_state; }
 
   int DoConnect(bool succeed, bool was_async, bool recoverable) {
     int result = OK;
     if (succeed) {
-      socket()->Connect(NULL);
+      socket()->Connect(CompletionCallback());
     } else if (recoverable) {
       result = ERR_PROXY_AUTH_REQUESTED;
     } else {
       result = ERR_CONNECTION_FAILED;
       set_socket(NULL);
     }
 
     if (was_async)
       NotifyDelegateOfCompletion(result);
     return result;
@@ skipping 35 matching lines @@
 
   virtual ~TestConnectJobFactory() {}
 
   void set_job_type(TestConnectJob::JobType job_type) { job_type_ = job_type; }
 
   void set_timeout_duration(base::TimeDelta timeout_duration) {
     timeout_duration_ = timeout_duration;
   }
 
   // ConnectJobFactory implementation.
+
   virtual ConnectJob* NewConnectJob(
       const std::string& group_name,
       const TestClientSocketPoolBase::Request& request,
       ConnectJob::Delegate* delegate) const {
     return new TestConnectJob(job_type_,
                               group_name,
                               request,
                               timeout_duration_,
                               delegate,
                               client_socket_factory_,
@@ skipping 273 matching lines @@
   EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
   EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
 
   std::map<int, StreamSocket*> sockets_;
   for (size_t i = 0; i < test_base_.requests_size(); i++) {
     TestSocketRequest* req = test_base_.request(i);
     StreamSocket* s = req->handle()->socket();
     MockClientSocket* sock = static_cast<MockClientSocket*>(s);
     CHECK(sock);
     sockets_[i] = sock;
-    sock->Read(NULL, 1024 - i, NULL);
+    sock->Read(NULL, 1024 - i, CompletionCallback());
   }
 
   ReleaseAllConnections(ClientSocketPoolTest::KEEP_ALIVE);
 
   EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
   TestSocketRequest* req = test_base_.request(test_base_.requests_size() - 1);
 
   // First socket is warmest.
   EXPECT_EQ(sockets_[0], req->handle()->socket());
 
@@ skipping 15 matching lines @@
   EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
   EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
 
   std::map<int, StreamSocket*> sockets_;
   for (size_t i = 0; i < test_base_.requests_size(); i++) {
     TestSocketRequest* req = test_base_.request(i);
     StreamSocket* s = req->handle()->socket();
     MockClientSocket* sock = static_cast<MockClientSocket*>(s);
     CHECK(sock);
     sockets_[i] = sock;
-    sock->Read(NULL, 1024 - i, NULL);
+    sock->Read(NULL, 1024 - i, CompletionCallback());
   }
 
   ReleaseAllConnections(ClientSocketPoolTest::KEEP_ALIVE);
 
   EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
   TestSocketRequest* req = test_base_.request(test_base_.requests_size() - 1);
 
   // Last socket is most recently accessed.
   EXPECT_EQ(sockets_[3], req->handle()->socket());
   ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE);
@@ skipping 1303 matching lines @@
   EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle2));
 
   // Cancel one of the requests.  Wait for the other, which will get the first
   // job.  Release the socket.  Run the loop again to make sure the second
   // socket is sitting idle and the first one is released (since ReleaseSocket()
   // just posts a DoReleaseSocket() task).
 
   handle.Reset();
   EXPECT_EQ(OK, callback2.WaitForResult());
   // Use the socket.
-  EXPECT_EQ(1, handle2.socket()->Write(NULL, 1, NULL));
+  EXPECT_EQ(1, handle2.socket()->Write(NULL, 1, CompletionCallback()));
   handle2.Reset();
 
   // The idle socket timeout value was set to 10 milliseconds. Wait 100
   // milliseconds so the sockets timeout.
   base::PlatformThread::Sleep(100);
   MessageLoop::current()->RunAllPending();
 
   ASSERT_EQ(2, pool_->IdleSocketCount());
 
   // Request a new socket. This should cleanup the unused and timed out ones.
@@ skipping 53 matching lines @@
   EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle2));
 
   // Cancel one of the requests.  Wait for the other, which will get the first
   // job.  Release the socket.  Run the loop again to make sure the second
   // socket is sitting idle and the first one is released (since ReleaseSocket()
   // just posts a DoReleaseSocket() task).
 
   handle.Reset();
   EXPECT_EQ(OK, callback2.WaitForResult());
   // Use the socket.
-  EXPECT_EQ(1, handle2.socket()->Write(NULL, 1, NULL));
+  EXPECT_EQ(1, handle2.socket()->Write(NULL, 1, CompletionCallback()));
   handle2.Reset();
 
   // We post all of our delayed tasks with a 2ms delay. I.e. they don't
   // actually become pending until 2ms after they have been created. In order
   // to flush all tasks, we need to wait so that we know there are no
   // soon-to-be-pending tasks waiting.
   base::PlatformThread::Sleep(10);
   MessageLoop::current()->RunAllPending();
 
   ASSERT_EQ(2, pool_->IdleSocketCount());
@@ skipping 740 matching lines @@
                                          kDefaultPriority,
                                          &callback3,
                                          pool_.get(),
                                          BoundNetLog()));
 
   EXPECT_EQ(OK, callback1.WaitForResult());
   EXPECT_EQ(OK, callback2.WaitForResult());
   EXPECT_EQ(OK, callback3.WaitForResult());
 
   // Use the socket.
-  EXPECT_EQ(1, handle1.socket()->Write(NULL, 1, NULL));
-  EXPECT_EQ(1, handle3.socket()->Write(NULL, 1, NULL));
+  EXPECT_EQ(1, handle1.socket()->Write(NULL, 1, CompletionCallback()));
+  EXPECT_EQ(1, handle3.socket()->Write(NULL, 1, CompletionCallback()));
 
   handle1.Reset();
   handle2.Reset();
   handle3.Reset();
 
   EXPECT_EQ(OK, handle1.Init("a",
                              params_,
                              kDefaultPriority,
                              &callback1,
                              pool_.get(),
@@ skipping 617 matching lines @@
                             params_,
                             kDefaultPriority,
                             &callback,
                             pool_.get(),
                             BoundNetLog()));
 }
 
 }  // namespace
 
 }  // namespace net