base::Bind: Convert proxy_resolving_client_socket.[cc,h] and deps.

net/socket/socket_test_util.h

 // 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.
 
 #ifndef NET_SOCKET_SOCKET_TEST_UTIL_H_
 #define NET_SOCKET_SOCKET_TEST_UTIL_H_
 #pragma once
 
 #include <cstring>
 #include <deque>
@@ skipping 814 matching lines @@
   int pending_buf_len_;
   CompletionCallback pending_callback_;
 
   BoundNetLog net_log_;
 
   base::WeakPtrFactory<MockUDPClientSocket> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(MockUDPClientSocket);
 };
 
-class TestSocketRequest : public CallbackRunner< Tuple1<int> > {
+class TestSocketRequest : public TestCompletionCallbackBase {
  public:
-  TestSocketRequest(
-      std::vector<TestSocketRequest*>* request_order,
-      size_t* completion_count);
+  TestSocketRequest(std::vector<TestSocketRequest*>* request_order,
+                    size_t* completion_count);
   virtual ~TestSocketRequest();
 
   ClientSocketHandle* handle() { return &handle_; }
 
-  int WaitForResult();
-  virtual void RunWithParams(const Tuple1<int>& params) OVERRIDE;
+  const net::CompletionCallback& callback() const { return callback_; }
 
  private:
+  void OnComplete(int result);
+
   ClientSocketHandle handle_;
   std::vector<TestSocketRequest*>* request_order_;
   size_t* completion_count_;
-  TestOldCompletionCallback callback_;
+  CompletionCallback callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestSocketRequest);
 };
 
 class ClientSocketPoolTest {
  public:
   enum KeepAlive {
     KEEP_ALIVE,
 
     // A socket will be disconnected in addition to handle being reset.
     NO_KEEP_ALIVE,
   };
 
   static const int kIndexOutOfBounds;
   static const int kRequestNotFound;
 
   ClientSocketPoolTest();
   ~ClientSocketPoolTest();
 
   template <typename PoolType, typename SocketParams>
   int StartRequestUsingPool(PoolType* socket_pool,
                             const std::string& group_name,
                             RequestPriority priority,
                             const scoped_refptr<SocketParams>& socket_params) {
     DCHECK(socket_pool);
     TestSocketRequest* request = new TestSocketRequest(&request_order_,
                                                        &completion_count_);
     requests_.push_back(request);
     int rv = request->handle()->Init(
-        group_name, socket_params, priority, request,
+        group_name, socket_params, priority, request->callback(),
         socket_pool, BoundNetLog());
     if (rv != ERR_IO_PENDING)
       request_order_.push_back(request);
     return rv;
   }
 
   // Provided there were n requests started, takes |index| in range 1..n
   // and returns order in which that request completed, in range 1..n,
   // or kIndexOutOfBounds if |index| is out of bounds, or kRequestNotFound
   // if that request did not complete (for example was canceled).
@@ skipping 156 matching lines @@
 
 extern const char kSOCKS5OkRequest[];
 extern const int kSOCKS5OkRequestLength;
 
 extern const char kSOCKS5OkResponse[];
 extern const int kSOCKS5OkResponseLength;
 
 }  // namespace net
 
 #endif  // NET_SOCKET_SOCKET_TEST_UTIL_H_