Move more members from QuicClient to QuicClientBase and change

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 25 matching lines @@
     IPEndPoint server_address,
     const QuicServerId& server_id,
     const QuicVersionVector& supported_versions,
     std::unique_ptr<ProofVerifier> proof_verifier)
     : QuicClientBase(server_id,
                      supported_versions,
                      QuicConfig(),
                      CreateQuicConnectionHelper(),
                      CreateQuicAlarmFactory(),
                      std::move(proof_verifier)),
-      server_address_(server_address),
-      local_port_(0),
       initialized_(false),
       packet_reader_started_(false),
-      weak_factory_(this) {}
+      weak_factory_(this) {
+  set_server_address(server_address);
+}
 
 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,
                      CreateQuicConnectionHelper(),
                      CreateQuicAlarmFactory(),
                      std::move(proof_verifier)),
-      server_address_(server_address),
-      local_port_(0),
       initialized_(false),
       packet_reader_started_(false),
-      weak_factory_(this) {}
+      weak_factory_(this) {
+  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::Initialize() {
   DCHECK(!initialized_);
 
   QuicClientBase::Initialize();
 
   if (!CreateUDPSocket()) {
     return false;
   }
 
   initialized_ = true;
   return true;
 }
 
 bool QuicSimpleClient::CreateUDPSocket() {
   std::unique_ptr<UDPClientSocket> socket(
       new UDPClientSocket(DatagramSocket::DEFAULT_BIND, RandIntCallback(),
                           &net_log_, NetLog::Source()));
 
-  int address_family = server_address_.GetSockAddrFamily();
-  if (bind_to_address_.size() != 0) {
-    client_address_ = IPEndPoint(bind_to_address_, local_port_);
+  int address_family = server_address().GetSockAddrFamily();
+  if (bind_to_address().size() != 0) {
+    client_address_ = IPEndPoint(bind_to_address(), local_port());
   } else if (address_family == AF_INET) {
-    client_address_ = IPEndPoint(IPAddress::IPv4AllZeros(), local_port_);
+    client_address_ = IPEndPoint(IPAddress::IPv4AllZeros(), local_port());
   } else {
-    client_address_ = IPEndPoint(IPAddress::IPv6AllZeros(), local_port_);
+    client_address_ = IPEndPoint(IPAddress::IPv6AllZeros(), local_port());
   }
 
-  int rc = socket->Connect(server_address_);
+  int rc = socket->Connect(server_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;
   }
@@ skipping 72 matching lines @@
     // does not need to be resent.
     if (session()->error() != QUIC_CRYPTO_HANDSHAKE_STATELESS_REJECT) {
       ClearDataToResend();
     }
     // Before we destroy the last session and create a new one, gather its stats
     // and update the stats for the overall connection.
     UpdateStats();
   }
 
   CreateQuicClientSession(new QuicConnection(
-      GetNextConnectionId(), server_address_, helper(), alarm_factory(),
+      GetNextConnectionId(), server_address(), helper(), alarm_factory(),
       writer(),
       /* owns_writer= */ false, Perspective::IS_CLIENT, supported_versions()));
 
   session()->Initialize();
   session()->CryptoConnect();
   set_connected_or_attempting_connect(true);
 }
 
 void QuicSimpleClient::Disconnect() {
   DCHECK(initialized_);
@@ skipping 77 matching lines @@
   }
 
   return session()->num_active_requests() != 0;
 }
 
 bool QuicSimpleClient::MigrateSocket(const IPAddress& new_host) {
   if (!connected()) {
     return false;
   }
 
-  bind_to_address_ = new_host;
+  set_bind_to_address(new_host);
   if (!CreateUDPSocket()) {
     return false;
   }
 
   session()->connection()->SetSelfAddress(client_address_);
 
   QuicPacketWriter* writer = CreateQuicPacketWriter();
   set_writer(writer);
   session()->connection()->SetQuicPacketWriter(writer, false);
 
   return true;
 }
 
-void QuicSimpleClient::OnClose(QuicSpdyStream* stream) {
-  DCHECK(stream != nullptr);
-  QuicSpdyClientStream* client_stream =
-      static_cast<QuicSpdyClientStream*>(stream);
-  HttpResponseInfo response;
-  SpdyHeadersToHttpResponse(client_stream->response_headers(), &response);
-  if (response_listener_.get() != nullptr) {
-    response_listener_->OnCompleteResponse(stream->id(), *response.headers,
-                                           client_stream->data());
-  }
-
-  // Store response headers and body.
-  if (store_response_) {
-    latest_response_code_ = client_stream->response_code();
-    response.headers->GetNormalizedHeaders(&latest_response_headers_);
-    latest_response_body_ = client_stream->data();
-  }
-}
-
-size_t QuicSimpleClient::latest_response_code() const {
-  LOG_IF(DFATAL, !store_response_) << "Response not stored!";
-  return latest_response_code_;
-}
-
-const string& QuicSimpleClient::latest_response_headers() const {
-  LOG_IF(DFATAL, !store_response_) << "Response not stored!";
-  return latest_response_headers_;
-}
-
-const string& QuicSimpleClient::latest_response_body() const {
-  LOG_IF(DFATAL, !store_response_) << "Response not stored!";
-  return latest_response_body_;
-}
-
 QuicConnectionId QuicSimpleClient::GenerateNewConnectionId() {
   return helper()->GetRandomGenerator()->RandUint64();
 }
 
 QuicChromiumConnectionHelper* QuicSimpleClient::CreateQuicConnectionHelper() {
   return new QuicChromiumConnectionHelper(&clock_, QuicRandom::GetInstance());
 }
 
 QuicChromiumAlarmFactory* QuicSimpleClient::CreateQuicAlarmFactory() {
   return new QuicChromiumAlarmFactory(base::ThreadTaskRunnerHandle::Get().get(),
@@ skipping 16 matching lines @@
   session()->connection()->ProcessUdpPacket(local_address, peer_address,
                                             packet);
   if (!session()->connection()->connected()) {
     return false;
   }
 
   return true;
 }
 
 }  // namespace net