Clean up quic_simple_client_bin.cc to sync with quic_client_bin.cc

net/tools/quic/quic_simple_client.cc

 // Copyright (c) 2012 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/tools/quic/quic_simple_client.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/run_loop.h"
@@ skipping 16 matching lines @@
 #include "net/socket/udp_client_socket.h"
 #include "net/spdy/spdy_header_block.h"
 #include "net/spdy/spdy_http_utils.h"
 
 using std::string;
 using base::StringPiece;
 
 namespace net {
 
 QuicSimpleClient::QuicSimpleClient(
-    IPEndPoint server_address,
+    QuicSocketAddress server_address,
     const QuicServerId& server_id,
     const QuicVersionVector& supported_versions,
     std::unique_ptr<ProofVerifier> proof_verifier)
-    : QuicSimpleClient(server_address,
-                       server_id,
-                       supported_versions,
-                       QuicConfig(),
-                       std::move(proof_verifier)) {}
-
-QuicSimpleClient::QuicSimpleClient(
-    IPEndPoint server_address,
-    const QuicServerId& server_id,
-    const QuicVersionVector& supported_versions,
-    const QuicConfig& config,
-    std::unique_ptr<ProofVerifier> proof_verifier)
     : QuicClientBase(server_id,
                      supported_versions,
-                     config,
+                     QuicConfig(),
                      CreateQuicConnectionHelper(),
                      CreateQuicAlarmFactory(),
                      std::move(proof_verifier)),
       initialized_(false),
       packet_reader_started_(false),
       weak_factory_(this) {
-  set_server_address(QuicSocketAddress(QuicSocketAddressImpl(server_address)));
+  set_server_address(server_address);
 }
 
 QuicSimpleClient::~QuicSimpleClient() {
   if (connected()) {
     session()->connection()->CloseConnection(
         QUIC_PEER_GOING_AWAY, "Shutting down",
         ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
   }
 }
 
 bool QuicSimpleClient::CreateUDPSocketAndBind(QuicSocketAddress server_address,
                                               QuicIpAddress bind_to_address,
                                               int bind_to_port) {
   std::unique_ptr<UDPClientSocket> socket(
       new UDPClientSocket(DatagramSocket::DEFAULT_BIND, RandIntCallback(),
                           &net_log_, NetLogSource()));
 
-  int address_family =
-      server_address.impl().socket_address().GetSockAddrFamily();
-  if (bind_to_address.impl().ip_address().size() != 0) {
-    client_address_ =
-        IPEndPoint(bind_to_address.impl().ip_address(), bind_to_port);
-  } else if (address_family == AF_INET) {
-    client_address_ = IPEndPoint(IPAddress::IPv4AllZeros(), bind_to_port);
+  if (bind_to_address.IsInitialized()) {
+    client_address_ = QuicSocketAddress(bind_to_address, local_port());
+  } else if (server_address.host().address_family() == IpAddressFamily::IP_V4) {
+    client_address_ = QuicSocketAddress(QuicIpAddress::Any4(), bind_to_port);
   } else {
-    client_address_ = IPEndPoint(IPAddress::IPv6AllZeros(), bind_to_port);
+    client_address_ = QuicSocketAddress(QuicIpAddress::Any6(), bind_to_port);
   }
 
   int rc = socket->Connect(server_address.impl().socket_address());
   if (rc != OK) {
     LOG(ERROR) << "Connect failed: " << ErrorToShortString(rc);
     return false;
   }
 
   rc = socket->SetReceiveBufferSize(kDefaultSocketReceiveBuffer);
   if (rc != OK) {
     LOG(ERROR) << "SetReceiveBufferSize() failed: " << ErrorToShortString(rc);
     return false;
   }
 
   rc = socket->SetSendBufferSize(kDefaultSocketReceiveBuffer);
   if (rc != OK) {
     LOG(ERROR) << "SetSendBufferSize() failed: " << ErrorToShortString(rc);
     return false;
   }
 
-  rc = socket->GetLocalAddress(&client_address_);
+  IPEndPoint address;
+  rc = socket->GetLocalAddress(&address);
   if (rc != OK) {
     LOG(ERROR) << "GetLocalAddress failed: " << ErrorToShortString(rc);
     return false;
   }
+  client_address_ = QuicSocketAddress(QuicSocketAddressImpl(address));
 
   socket_.swap(socket);
   packet_reader_.reset(new QuicChromiumPacketReader(
       socket_.get(), &clock_, this, kQuicYieldAfterPacketsRead,
       QuicTime::Delta::FromMilliseconds(kQuicYieldAfterDurationMilliseconds),
       NetLogWithSource()));
 
   if (socket != nullptr) {
     socket->Close();
   }
@@ skipping 33 matching lines @@
   return new QuicChromiumPacketWriter(socket_.get());
 }
 
 void QuicSimpleClient::OnReadError(int result,
                                    const DatagramClientSocket* socket) {
   LOG(ERROR) << "QuicSimpleClient read failed: " << ErrorToShortString(result);
   Disconnect();
 }
 
 QuicSocketAddress QuicSimpleClient::GetLatestClientAddress() const {
-  return QuicSocketAddress(QuicSocketAddressImpl(client_address_));
+  return client_address_;
 }
 
 bool QuicSimpleClient::OnPacket(const QuicReceivedPacket& packet,
                                 IPEndPoint local_address,
                                 IPEndPoint peer_address) {
   session()->connection()->ProcessUdpPacket(
       QuicSocketAddress(QuicSocketAddressImpl(local_address)),
       QuicSocketAddress(QuicSocketAddressImpl(peer_address)), packet);
   if (!session()->connection()->connected()) {
     return false;
   }
 
   return true;
 }
 
 }  // namespace net