Cleanup: Remove the support for IPv4 and IPv6 addressing types in the SOCKS5 implementation.

This is no longer used by chrome, and it is unlikely that embedders would want to use this.
The default will just use the DOMAIN addressing type.

BUG=29914

Review URL: http://codereview.chromium.org/507048

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@34928 0039d316-1c4b-4281-b951-d872f2087c98

5 files changed, 70 insertions, 230 deletions

diff --git a/net/http/http_network_transaction.cc b/net/http/http_network_transaction.cc
index 28c09bc..5234f2c 100644
--- a/net/http/http_network_transaction.cc
+++ b/net/http/http_network_transaction.cc
@@ -652,7 +652,7 @@ int HttpNetworkTransaction::DoSOCKSConnect() {
   req_info.set_referrer(request_->referrer);
 
   if (proxy_info_.proxy_server().scheme() == ProxyServer::SCHEME_SOCKS5)
-    s = new SOCKS5ClientSocket(s, req_info, NULL /*use proxy-side resolving*/);
+    s = new SOCKS5ClientSocket(s, req_info);
   else
     s = new SOCKSClientSocket(s, req_info, session_->host_resolver());
   connection_.set_socket(s);
diff --git a/net/socket/socks5_client_socket.cc b/net/socket/socks5_client_socket.cc
index 8874d7a..7386caf 100644
--- a/net/socket/socks5_client_socket.cc
+++ b/net/socket/socks5_client_socket.cc
@@ -25,21 +25,17 @@ COMPILE_ASSERT(sizeof(struct in_addr) == 4, incorrect_system_size_of_IPv4);
 COMPILE_ASSERT(sizeof(struct in6_addr) == 16, incorrect_system_size_of_IPv6);
 
 SOCKS5ClientSocket::SOCKS5ClientSocket(ClientSocket* transport_socket,
-    const HostResolver::RequestInfo& req_info,
-    HostResolver* host_resolver)
+    const HostResolver::RequestInfo& req_info)
     : ALLOW_THIS_IN_INITIALIZER_LIST(
           io_callback_(this, &SOCKS5ClientSocket::OnIOComplete)),
       transport_(transport_socket),
       next_state_(STATE_NONE),
-      address_type_(kEndPointUnresolved),
       user_callback_(NULL),
       completed_handshake_(false),
       bytes_sent_(0),
       bytes_received_(0),
       read_header_size(kReadHeaderSize),
       host_request_info_(req_info) {
-  if (host_resolver)
-    host_resolver_.reset(new SingleRequestHostResolver(host_resolver));
 }
 
 SOCKS5ClientSocket::~SOCKS5ClientSocket() {
@@ -60,14 +56,8 @@ int SOCKS5ClientSocket::Connect(CompletionCallback* callback,
   load_log_ = load_log;
   LoadLog::BeginEvent(load_log, LoadLog::TYPE_SOCKS5_CONNECT);
 
-  // If a host resolver was given, try to resolve the address locally.
-  // Otherwise let the proxy server handle the resolving.
-  if (host_resolver_.get()) {
-    next_state_ = STATE_RESOLVE_HOST;
-  } else {
-    next_state_ = STATE_GREET_WRITE;
-    address_type_ = kEndPointFailedDomain;
-  }
+  next_state_ = STATE_GREET_WRITE;
+  buffer_.clear();
 
   int rv = DoLoop(OK);
   if (rv == ERR_IO_PENDING) {
@@ -151,13 +141,6 @@ int SOCKS5ClientSocket::DoLoop(int last_io_result) {
     State state = next_state_;
     next_state_ = STATE_NONE;
     switch (state) {
-      case STATE_RESOLVE_HOST:
-        DCHECK_EQ(OK, rv);
-        rv = DoResolveHost();
-        break;
-      case STATE_RESOLVE_HOST_COMPLETE:
-        rv = DoResolveHostComplete(rv);
-        break;
       case STATE_GREET_WRITE:
         DCHECK_EQ(OK, rv);
         rv = DoGreetWrite();
@@ -195,38 +178,6 @@ int SOCKS5ClientSocket::DoLoop(int last_io_result) {
   return rv;
 }
 
-int SOCKS5ClientSocket::DoResolveHost() {
-  DCHECK_EQ(kEndPointUnresolved, address_type_);
-
-  next_state_ = STATE_RESOLVE_HOST_COMPLETE;
-  return host_resolver_->Resolve(
-      host_request_info_, &addresses_, &io_callback_, load_log_);
-}
-
-int SOCKS5ClientSocket::DoResolveHostComplete(int result) {
-  DCHECK_EQ(kEndPointUnresolved, address_type_);
-
-  bool ok = (result == OK);
-  next_state_ = STATE_GREET_WRITE;
-  if (ok) {
-    DCHECK(addresses_.head());
-    struct sockaddr* host_info = addresses_.head()->ai_addr;
-    if (host_info->sa_family == AF_INET) {
-      address_type_ = kEndPointResolvedIPv4;
-    } else if (host_info->sa_family == AF_INET6) {
-      address_type_ = kEndPointResolvedIPv6;
-    }
-  } else {
-    address_type_ = kEndPointFailedDomain;
-  }
-
-  buffer_.clear();
-
-  // Even if DNS resolution fails, we send OK since the server
-  // resolves the domain.
-  return OK;
-}
-
 const char kSOCKS5GreetWriteData[] = { 0x05, 0x01, 0x00 };  // no authentication
 const char kSOCKS5GreetReadData[] = { 0x05, 0x00 };
 
@@ -292,38 +243,23 @@ int SOCKS5ClientSocket::DoGreetReadComplete(int result) {
 
 int SOCKS5ClientSocket::BuildHandshakeWriteBuffer(std::string* handshake)
     const {
-  DCHECK_NE(kEndPointUnresolved, address_type_);
   DCHECK(handshake->empty());
 
   handshake->push_back(kSOCKS5Version);
   handshake->push_back(kTunnelCommand);  // Connect command
   handshake->push_back(kNullByte);  // Reserved null
 
-  handshake->push_back(address_type_);  // The type of connection
-  if (address_type_ == kEndPointFailedDomain) {
-    if(256 <= host_request_info_.hostname().size())
-      return ERR_ADDRESS_INVALID;
-
-    // First add the size of the hostname, followed by the hostname.
-    handshake->push_back(static_cast<unsigned char>(
-        host_request_info_.hostname().size()));
-    handshake->append(host_request_info_.hostname());
+  handshake->push_back(kEndPointDomain);  // The type of the address.
 
-  } else if (address_type_ == kEndPointResolvedIPv4) {
-    struct sockaddr_in* ipv4_host =
-        reinterpret_cast<struct sockaddr_in*>(addresses_.head()->ai_addr);
-    handshake->append(reinterpret_cast<char*>(&ipv4_host->sin_addr),
-                      sizeof(ipv4_host->sin_addr));
+  // We only have 1 byte to send the length in, so if the hostname is
+  // longer than this we can't send it!
+  if(256 <= host_request_info_.hostname().size())
+    return ERR_INVALID_URL;
 
-  } else if (address_type_ == kEndPointResolvedIPv6) {
-    struct sockaddr_in6* ipv6_host =
-        reinterpret_cast<struct sockaddr_in6*>(addresses_.head()->ai_addr);
-    handshake->append(reinterpret_cast<char*>(&ipv6_host->sin6_addr),
-                      sizeof(ipv6_host->sin6_addr));
-
-  } else {
-    NOTREACHED();
-  }
+  // First add the size of the hostname, followed by the hostname.
+  handshake->push_back(static_cast<unsigned char>(
+      host_request_info_.hostname().size()));
+  handshake->append(host_request_info_.hostname());
 
   uint16 nw_port = htons(host_request_info_.port());
   handshake->append(reinterpret_cast<char*>(&nw_port), sizeof(nw_port));
@@ -350,8 +286,6 @@ int SOCKS5ClientSocket::DoHandshakeWrite() {
 }
 
 int SOCKS5ClientSocket::DoHandshakeWriteComplete(int result) {
-  DCHECK_NE(kEndPointUnresolved, address_type_);
-
   if (result < 0)
     return result;
 
@@ -372,8 +306,6 @@ int SOCKS5ClientSocket::DoHandshakeWriteComplete(int result) {
 }
 
 int SOCKS5ClientSocket::DoHandshakeRead() {
-  DCHECK_NE(kEndPointUnresolved, address_type_);
-
   next_state_ = STATE_HANDSHAKE_READ_COMPLETE;
 
   if (buffer_.empty()) {
@@ -387,8 +319,6 @@ int SOCKS5ClientSocket::DoHandshakeRead() {
 }
 
 int SOCKS5ClientSocket::DoHandshakeReadComplete(int result) {
-  DCHECK_NE(kEndPointUnresolved, address_type_);
-
   if (result < 0)
     return result;
 
@@ -415,7 +345,7 @@ int SOCKS5ClientSocket::DoHandshakeReadComplete(int result) {
     // read, we substract 1 byte from the additional request size.
     SocksEndPointAddressType address_type =
         static_cast<SocksEndPointAddressType>(buffer_[3]);
-    if (address_type == kEndPointFailedDomain)
+    if (address_type == kEndPointDomain)
       read_header_size += static_cast<uint8>(buffer_[4]);
     else if (address_type == kEndPointResolvedIPv4)
       read_header_size += sizeof(struct in_addr) - 1;
diff --git a/net/socket/socks5_client_socket.h b/net/socket/socks5_client_socket.h
index 9a05f4a..f8de9a6 100644
--- a/net/socket/socks5_client_socket.h
+++ b/net/socket/socks5_client_socket.h
@@ -32,23 +32,11 @@ class SOCKS5ClientSocket : public ClientSocket {
   // |req_info| contains the hostname and port to which the socket above will
   // communicate to via the SOCKS layer.
   //
-  // SOCKS5 supports three modes of specifying connection endpoints:
-  //  (1) as an IPv4 address.
-  //  (2) as an IPv6 address.
-  //  (3) as a hostname string.
-  //
-  // To select mode (3), pass NULL for |host_resolver|.
-  //
-  // Otherwise if a non-NULL |host_resolver| is given, Connect() will first
-  // try to resolve the hostname using |host_resolver|, and pass that
-  // resolved address to the proxy server. If the resolve failed, Connect()
-  // will fall-back to mode (3) and simply send the unresolved hosname string
-  // to the SOCKS v5 proxy server.
-  //
-  // Passing NULL for |host_resolver| is the recommended default.
+  // Although SOCKS 5 supports 3 different modes of addressing, we will
+  // always pass it a hostname. This means the DNS resolving is done
+  // proxy side.
   SOCKS5ClientSocket(ClientSocket* transport_socket,
-                     const HostResolver::RequestInfo& req_info,
-                     HostResolver* host_resolver);
+                     const HostResolver::RequestInfo& req_info);
 
   // On destruction Disconnect() is called.
   virtual ~SOCKS5ClientSocket();
@@ -73,13 +61,7 @@ class SOCKS5ClientSocket : public ClientSocket {
 #endif
 
  private:
-  FRIEND_TEST(SOCKS5ClientSocketTest, IPv6Domain);
-  FRIEND_TEST(SOCKS5ClientSocketTest, FailedDNS);
-  FRIEND_TEST(SOCKS5ClientSocketTest, CompleteHandshake);
-
   enum State {
-    STATE_RESOLVE_HOST,
-    STATE_RESOLVE_HOST_COMPLETE,
     STATE_GREET_WRITE,
     STATE_GREET_WRITE_COMPLETE,
     STATE_GREET_READ,
@@ -91,12 +73,9 @@ class SOCKS5ClientSocket : public ClientSocket {
     STATE_NONE,
   };
 
-  // State of the SOCKSv5 handshake. Before host resolution all connections
-  // are kEndPointFailedDomain. If DNS lookup fails, we move to
-  // kEndPointFailedDomain, otherwise the IPv4/IPv6 address as resolved.
+  // Addressing type that can be specified in requests or responses.
   enum SocksEndPointAddressType {
-    kEndPointUnresolved,
-    kEndPointFailedDomain = 0x03,
+    kEndPointDomain = 0x03,
     kEndPointResolvedIPv4 = 0x01,
     kEndPointResolvedIPv6 = 0x04,
   };
@@ -112,8 +91,6 @@ class SOCKS5ClientSocket : public ClientSocket {
   void OnIOComplete(int result);
 
   int DoLoop(int last_io_result);
-  int DoResolveHost();
-  int DoResolveHostComplete(int result);
   int DoHandshakeRead();
   int DoHandshakeReadComplete(int result);
   int DoHandshakeWrite();
@@ -133,7 +110,6 @@ class SOCKS5ClientSocket : public ClientSocket {
   scoped_ptr<ClientSocket> transport_;
 
   State next_state_;
-  SocksEndPointAddressType address_type_;
 
   // Stores the callback to the layer above, called on completing Connect().
   CompletionCallback* user_callback_;
@@ -157,11 +133,6 @@ class SOCKS5ClientSocket : public ClientSocket {
 
   size_t read_header_size;
 
-  // If non-NULL, we will use this host resolver to resolve DNS client-side
-  // (and fall back to proxy-side resolving if it fails).
-  // Otherwise, we will do proxy-side DNS resolving.
-  scoped_ptr<SingleRequestHostResolver> host_resolver_;
-  AddressList addresses_;
   HostResolver::RequestInfo host_request_info_;
 
   scoped_refptr<LoadLog> load_log_;
diff --git a/net/socket/socks5_client_socket_unittest.cc b/net/socket/socks5_client_socket_unittest.cc
index b03d92b..ae1b2c3 100644
--- a/net/socket/socks5_client_socket_unittest.cc
+++ b/net/socket/socks5_client_socket_unittest.cc
@@ -23,6 +23,8 @@
 
 namespace net {
 
+namespace {
+
 // Base class to test SOCKS5ClientSocket
 class SOCKS5ClientSocketTest : public PlatformTest {
  public:
@@ -31,8 +33,7 @@ class SOCKS5ClientSocketTest : public PlatformTest {
   SOCKS5ClientSocket* BuildMockSocket(MockRead reads[],
                                       MockWrite writes[],
                                       const std::string& hostname,
-                                      int port,
-                                      HostResolver* host_resolver);
+                                      int port);
 
   virtual void SetUp();
 
@@ -67,8 +68,7 @@ SOCKS5ClientSocket* SOCKS5ClientSocketTest::BuildMockSocket(
     MockRead reads[],
     MockWrite writes[],
     const std::string& hostname,
-    int port,
-    net::HostResolver* host_resolver) {
+    int port) {
   TestCompletionCallback callback;
   data_.reset(new StaticSocketDataProvider(reads, writes));
   tcp_sock_ = new MockTCPClientSocket(address_list_, data_.get());
@@ -80,23 +80,31 @@ SOCKS5ClientSocket* SOCKS5ClientSocketTest::BuildMockSocket(
   EXPECT_TRUE(tcp_sock_->IsConnected());
 
   return new SOCKS5ClientSocket(tcp_sock_,
-      HostResolver::RequestInfo(hostname, port),
-      host_resolver);
+      HostResolver::RequestInfo(hostname, port));
 }
 
 const char kSOCKS5GreetRequest[] = { 0x05, 0x01, 0x00 };
 const char kSOCKS5GreetResponse[] = { 0x05, 0x00 };
-
-const char kSOCKS5OkRequest[] =
-    { 0x05, 0x01, 0x00, 0x01, 127, 0, 0, 1, 0x00, 0x50 };
 const char kSOCKS5OkResponse[] =
     { 0x05, 0x00, 0x00, 0x01, 127, 0, 0, 1, 0x00, 0x50 };
 
+
 // Tests a complete SOCKS5 handshake and the disconnection.
 TEST_F(SOCKS5ClientSocketTest, CompleteHandshake) {
   const std::string payload_write = "random data";
   const std::string payload_read = "moar random data";
 
+  const char kSOCKS5OkRequest[] = {
+    0x05,  // Version
+    0x01,  // Command (CONNECT)
+    0x00,  // Reserved.
+    0x03,  // Address type (DOMAINNAME).
+    0x09,  // Length of domain (9)
+    // Domain string:
+    'l', 'o', 'c', 'a', 'l', 'h', 'o', 's', 't',
+    0x00, 0x50,  // 16-bit port (80)
+  };
+
   MockWrite data_writes[] = {
       MockWrite(true, kSOCKS5GreetRequest, arraysize(kSOCKS5GreetRequest)),
       MockWrite(true, kSOCKS5OkRequest, arraysize(kSOCKS5OkRequest)),
@@ -106,8 +114,7 @@ TEST_F(SOCKS5ClientSocketTest, CompleteHandshake) {
       MockRead(true, kSOCKS5OkResponse, arraysize(kSOCKS5OkResponse)),
       MockRead(true, payload_read.data(), payload_read.size()) };
 
-  user_sock_.reset(BuildMockSocket(data_reads, data_writes, "localhost", 80,
-                                   new MockHostResolver));
+  user_sock_.reset(BuildMockSocket(data_reads, data_writes, "localhost", 80));
 
   // At this state the TCP connection is completed but not the SOCKS handshake.
   EXPECT_TRUE(tcp_sock_->IsConnected());
@@ -124,8 +131,6 @@ TEST_F(SOCKS5ClientSocketTest, CompleteHandshake) {
 
   EXPECT_EQ(OK, rv);
   EXPECT_TRUE(user_sock_->IsConnected());
-  EXPECT_EQ(SOCKS5ClientSocket::kEndPointResolvedIPv4,
-            user_sock_->address_type_);
   EXPECT_TRUE(LogContains(
       *log, -1, LoadLog::TYPE_SOCKS5_CONNECT, LoadLog::PHASE_END));
 
@@ -148,44 +153,6 @@ TEST_F(SOCKS5ClientSocketTest, CompleteHandshake) {
   EXPECT_FALSE(user_sock_->IsConnected());
 }
 
-// Tries to connect to a DNS which fails domain lookup.
-TEST_F(SOCKS5ClientSocketTest, FailedDNS) {
-  const std::string hostname = "unresolved.ipv4.address";
-  const char kSOCKS5DomainRequest[] = { 0x05, 0x01, 0x00, 0x03 };
-
-  scoped_refptr<MockHostResolver> mock_resolver = new MockHostResolver;
-  mock_resolver->rules()->AddSimulatedFailure(hostname);
-
-  std::string request(kSOCKS5DomainRequest,
-                      arraysize(kSOCKS5DomainRequest));
-  request.push_back(hostname.size());
-  request.append(hostname);
-  request.append(reinterpret_cast<const char*>(&kNwPort), sizeof(kNwPort));
-
-  MockWrite data_writes[] = {
-      MockWrite(false, kSOCKS5GreetRequest, arraysize(kSOCKS5GreetRequest)),
-      MockWrite(false, request.data(), request.size()) };
-  MockRead data_reads[] = {
-      MockRead(false, kSOCKS5GreetResponse, arraysize(kSOCKS5GreetResponse)),
-      MockRead(false, kSOCKS5OkResponse, arraysize(kSOCKS5OkResponse)) };
-
-  user_sock_.reset(BuildMockSocket(data_reads, data_writes, hostname, 80,
-                                   mock_resolver));
-
-  scoped_refptr<LoadLog> log(new LoadLog(LoadLog::kUnbounded));
-  int rv = user_sock_->Connect(&callback_, log);
-  EXPECT_EQ(ERR_IO_PENDING, rv);
-  EXPECT_TRUE(LogContains(
-      *log, 0, LoadLog::TYPE_SOCKS5_CONNECT, LoadLog::PHASE_BEGIN));
-  rv = callback_.WaitForResult();
-  EXPECT_EQ(OK, rv);
-  EXPECT_TRUE(user_sock_->IsConnected());
-  EXPECT_EQ(SOCKS5ClientSocket::kEndPointFailedDomain,
-            user_sock_->address_type_);
-  EXPECT_TRUE(LogContains(
-      *log, -1, LoadLog::TYPE_SOCKS5_CONNECT, LoadLog::PHASE_END));
-}
-
 // Connect to a domain, making sure to defer the host resolving to the proxy
 // server.
 TEST_F(SOCKS5ClientSocketTest, ResolveHostsProxySide) {
@@ -212,56 +179,27 @@ TEST_F(SOCKS5ClientSocketTest, ResolveHostsProxySide) {
       MockRead(false, kSOCKS5OkResponse, arraysize(kSOCKS5OkResponse))
   };
 
-  user_sock_.reset(BuildMockSocket(data_reads, data_writes, hostname, 80,
-                                   NULL));
+  user_sock_.reset(BuildMockSocket(data_reads, data_writes, hostname, 80));
 
   int rv = user_sock_->Connect(&callback_, NULL);
   EXPECT_EQ(OK, rv);
   EXPECT_TRUE(user_sock_->IsConnected());
 }
 
-// Tries to connect to a domain that resolves to IPv6.
-TEST_F(SOCKS5ClientSocketTest, IPv6Domain) {
-  const std::string hostname = "an.ipv6.address";
-  const char kSOCKS5IPv6Request[] = { 0x05, 0x01, 0x00, 0x04 };
-  const uint8 ipv6_addr[] = { 0x20, 0x01, 0x0d, 0xb8, 0x87, 0x14, 0x3a, 0x90,
-                              0x00, 0x00, 0x00, 0x00, 0x00, 0x000, 0x00, 0x12 };
-
-  scoped_refptr<MockHostResolver> mock_resolver = new MockHostResolver;
-  mock_resolver->rules()->AddIPv6Rule(hostname, "2001:db8:8714:3a90::12");
-
-  std::string request(kSOCKS5IPv6Request,
-                      arraysize(kSOCKS5IPv6Request));
-  request.append(reinterpret_cast<const char*>(&ipv6_addr), sizeof(ipv6_addr));
-  request.append(reinterpret_cast<const char*>(&kNwPort), sizeof(kNwPort));
-
-  MockWrite data_writes[] = {
-      MockWrite(false, kSOCKS5GreetRequest, arraysize(kSOCKS5GreetRequest)),
-      MockWrite(false, request.data(), request.size()) };
-  MockRead data_reads[] = {
-      MockRead(false, kSOCKS5GreetResponse, arraysize(kSOCKS5GreetResponse)),
-      MockRead(false, kSOCKS5OkResponse, arraysize(kSOCKS5OkResponse)) };
-
-  user_sock_.reset(BuildMockSocket(data_reads, data_writes, hostname, 80,
-                                   mock_resolver));
-
-  scoped_refptr<LoadLog> log(new LoadLog(LoadLog::kUnbounded));
-  int rv = user_sock_->Connect(&callback_, log);
-  EXPECT_EQ(ERR_IO_PENDING, rv);
-  EXPECT_TRUE(LogContains(
-      *log, 0, LoadLog::TYPE_SOCKS5_CONNECT, LoadLog::PHASE_BEGIN));
-  rv = callback_.WaitForResult();
-  EXPECT_EQ(OK, rv);
-  EXPECT_TRUE(user_sock_->IsConnected());
-  EXPECT_EQ(SOCKS5ClientSocket::kEndPointResolvedIPv6,
-            user_sock_->address_type_);
-  EXPECT_TRUE(LogContains(
-      *log, -1, LoadLog::TYPE_SOCKS5_CONNECT, LoadLog::PHASE_END));
-}
-
 TEST_F(SOCKS5ClientSocketTest, PartialReadWrites) {
   const std::string hostname = "www.google.com";
 
+  const char kSOCKS5OkRequest[] = {
+    0x05,  // Version
+    0x01,  // Command (CONNECT)
+    0x00,  // Reserved.
+    0x03,  // Address type (DOMAINNAME).
+    0x0E,  // Length of domain (14)
+    // Domain string:
+    'w', 'w', 'w', '.', 'g', 'o', 'o', 'g', 'l', 'e', '.', 'c', 'o', 'm',
+    0x00, 0x50,  // 16-bit port (80)
+  };
+
   // Test for partial greet request write
   {
     const char partial1[] = { 0x05, 0x01 };
@@ -273,8 +211,7 @@ TEST_F(SOCKS5ClientSocketTest, PartialReadWrites) {
     MockRead data_reads[] = {
         MockRead(true, kSOCKS5GreetResponse, arraysize(kSOCKS5GreetResponse)),
         MockRead(true, kSOCKS5OkResponse, arraysize(kSOCKS5OkResponse)) };
-    user_sock_.reset(BuildMockSocket(data_reads, data_writes, hostname, 80,
-                                     new MockHostResolver));
+    user_sock_.reset(BuildMockSocket(data_reads, data_writes, hostname, 80));
     scoped_refptr<LoadLog> log(new LoadLog(LoadLog::kUnbounded));
     int rv = user_sock_->Connect(&callback_, log);
     EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -298,8 +235,7 @@ TEST_F(SOCKS5ClientSocketTest, PartialReadWrites) {
         MockRead(true, partial1, arraysize(partial1)),
         MockRead(true, partial2, arraysize(partial2)),
         MockRead(true, kSOCKS5OkResponse, arraysize(kSOCKS5OkResponse)) };
-    user_sock_.reset(BuildMockSocket(data_reads, data_writes, hostname, 80,
-                                     new MockHostResolver));
+    user_sock_.reset(BuildMockSocket(data_reads, data_writes, hostname, 80));
     scoped_refptr<LoadLog> log(new LoadLog(LoadLog::kUnbounded));
     int rv = user_sock_->Connect(&callback_, log);
     EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -312,19 +248,19 @@ TEST_F(SOCKS5ClientSocketTest, PartialReadWrites) {
         *log, -1, LoadLog::TYPE_SOCKS5_CONNECT, LoadLog::PHASE_END));
   }
 
-  // Test for partial handshake request write
+  // Test for partial handshake request write.
   {
-    const char partial1[] = { 0x05, 0x01, 0x00 };
-    const char partial2[] = { 0x01, 127, 0, 0, 1, 0x00, 0x50 };
+    const int kSplitPoint = 3;  // Break handshake write into two parts.
     MockWrite data_writes[] = {
         MockWrite(true, kSOCKS5GreetRequest, arraysize(kSOCKS5GreetRequest)),
-        MockWrite(true, arraysize(partial1)),
-        MockWrite(true, partial2, arraysize(partial2)) };
+        MockWrite(true, kSOCKS5OkRequest, kSplitPoint),
+        MockWrite(true, kSOCKS5OkRequest + kSplitPoint,
+                        arraysize(kSOCKS5OkRequest) - kSplitPoint)
+    };
     MockRead data_reads[] = {
         MockRead(true, kSOCKS5GreetResponse, arraysize(kSOCKS5GreetResponse)),
         MockRead(true, kSOCKS5OkResponse, arraysize(kSOCKS5OkResponse)) };
-    user_sock_.reset(BuildMockSocket(data_reads, data_writes, hostname, 80,
-                                     new MockHostResolver));
+    user_sock_.reset(BuildMockSocket(data_reads, data_writes, hostname, 80));
     scoped_refptr<LoadLog> log(new LoadLog(LoadLog::kUnbounded));
     int rv = user_sock_->Connect(&callback_, log);
     EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -339,17 +275,18 @@ TEST_F(SOCKS5ClientSocketTest, PartialReadWrites) {
 
   // Test for partial handshake response read
   {
-    const char partial1[] = { 0x05, 0x00, 0x00, 0x01, 127, 0 };
-    const char partial2[] = { 0, 1, 0x00, 0x50 };
+    const int kSplitPoint = 6;  // Break the handshake read into two parts.
     MockWrite data_writes[] = {
         MockWrite(true, kSOCKS5GreetRequest, arraysize(kSOCKS5GreetRequest)),
-        MockWrite(true, kSOCKS5OkRequest, arraysize(kSOCKS5OkRequest)) };
+        MockWrite(true, kSOCKS5OkRequest, arraysize(kSOCKS5OkRequest))
+    };
     MockRead data_reads[] = {
         MockRead(true, kSOCKS5GreetResponse, arraysize(kSOCKS5GreetResponse)),
-        MockRead(true, partial1, arraysize(partial1)),
-        MockRead(true, partial2, arraysize(partial2)) };
-    user_sock_.reset(BuildMockSocket(data_reads, data_writes, hostname, 80,
-                                     new MockHostResolver));
+        MockRead(true, kSOCKS5OkResponse, kSplitPoint),
+        MockRead(true, kSOCKS5OkResponse + kSplitPoint, arraysize(kSOCKS5OkResponse) - kSplitPoint)
+    };
+
+    user_sock_.reset(BuildMockSocket(data_reads, data_writes, hostname, 80));
     scoped_refptr<LoadLog> log(new LoadLog(LoadLog::kUnbounded));
     int rv = user_sock_->Connect(&callback_, log);
     EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -363,4 +300,6 @@ TEST_F(SOCKS5ClientSocketTest, PartialReadWrites) {
   }
 }
 
+}  // namespace
+
 }  // namespace net
diff --git a/net/socket_stream/socket_stream.cc b/net/socket_stream/socket_stream.cc
index e746022..9d60a9e 100644
--- a/net/socket_stream/socket_stream.cc
+++ b/net/socket_stream/socket_stream.cc
@@ -704,7 +704,7 @@ int SocketStream::DoSOCKSConnect() {
                                      url_.EffectiveIntPort());
 
   if (proxy_info_.proxy_server().scheme() == ProxyServer::SCHEME_SOCKS5)
-    s = new SOCKS5ClientSocket(s, req_info, NULL /*use proxy-side resolving*/);
+    s = new SOCKS5ClientSocket(s, req_info);
   else
     s = new SOCKSClientSocket(s, req_info, host_resolver_.get());
   socket_.reset(s);