Move more members from QuicClient to QuicClientBase and change

net/tools/quic/quic_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_client.h"
 
 #include <errno.h>
 #include <netinet/in.h>
 #include <string.h>
 #include <sys/epoll.h>
@@ skipping 51 matching lines @@
                        const QuicConfig& config,
                        EpollServer* epoll_server,
                        std::unique_ptr<ProofVerifier> proof_verifier)
     : QuicClientBase(
           server_id,
           supported_versions,
           config,
           new QuicEpollConnectionHelper(epoll_server, QuicAllocator::SIMPLE),
           new QuicEpollAlarmFactory(epoll_server),
           std::move(proof_verifier)),
-      server_address_(server_address),
-      local_port_(0),
       epoll_server_(epoll_server),
       initialized_(false),
       packets_dropped_(0),
       overflow_supported_(false),
-      store_response_(false),
-      latest_response_code_(-1),
-      packet_reader_(new QuicPacketReader()) {}
+      packet_reader_(new QuicPacketReader()) {
+  set_server_address(server_address);
+}
 
 QuicClient::~QuicClient() {
   if (connected()) {
     session()->connection()->CloseConnection(
         QUIC_PEER_GOING_AWAY, "Client being torn down",
         ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
   }
 
   CleanUpAllUDPSockets();
 }
@@ skipping 25 matching lines @@
     return false;
   }
 
   epoll_server_->RegisterFD(GetLatestFD(), this, kEpollFlags);
   initialized_ = true;
   return true;
 }
 
 bool QuicClient::CreateUDPSocketAndBind() {
   int fd =
-      QuicSocketUtils::CreateUDPSocket(server_address_, &overflow_supported_);
+      QuicSocketUtils::CreateUDPSocket(server_address(), &overflow_supported_);
   if (fd < 0) {
     return false;
   }
 
   IPEndPoint client_address;
-  if (bind_to_address_.size() != 0) {
-    client_address = IPEndPoint(bind_to_address_, local_port_);
-  } else if (server_address_.GetSockAddrFamily() == AF_INET) {
-    client_address = IPEndPoint(IPAddress::IPv4AllZeros(), local_port_);
+  if (bind_to_address().size() != 0) {
+    client_address = IPEndPoint(bind_to_address(), local_port());
+  } else if (server_address().GetSockAddrFamily() == AF_INET) {
+    client_address = IPEndPoint(IPAddress::IPv4AllZeros(), local_port());
   } else {
     IPAddress any6 = IPAddress::IPv6AllZeros();
-    client_address = IPEndPoint(any6, local_port_);
+    client_address = IPEndPoint(any6, local_port());
   }
 
   sockaddr_storage raw_addr;
   socklen_t raw_addr_len = sizeof(raw_addr);
   CHECK(client_address.ToSockAddr(reinterpret_cast<sockaddr*>(&raw_addr),
                                   &raw_addr_len));
   int rc =
       bind(fd, reinterpret_cast<const sockaddr*>(&raw_addr), sizeof(raw_addr));
   if (rc < 0) {
     LOG(ERROR) << "Bind failed: " << strerror(errno);
@@ skipping 52 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(), writer,
+      GetNextConnectionId(), server_address(), helper(), alarm_factory(),
+      writer,
       /* owns_writer= */ false, Perspective::IS_CLIENT, supported_versions()));
 
   // Reset |writer()| after |session()| so that the old writer outlives the old
   // session.
   set_writer(writer);
   session()->Initialize();
   session()->CryptoConnect();
   set_connected_or_attempting_connect(true);
 }
 
@@ skipping 72 matching lines @@
     if (!SpdyUtils::PopulateHeaderBlockFromUrl(url_list[i], &headers)) {
       QUIC_BUG << "Unable to create request";
       continue;
     }
     SendRequest(headers, "", true);
   }
   while (WaitForEvents()) {
   }
 }
 
-QuicSpdyClientStream* QuicClient::CreateReliableClientStream() {
-  QuicSpdyClientStream* stream = QuicClientBase::CreateReliableClientStream();
-  if (stream) {
-    stream->set_visitor(this);
-  }
-  return stream;
-}
-
 bool QuicClient::WaitForEvents() {
   DCHECK(connected());
 
   epoll_server_->WaitForEventsAndExecuteCallbacks();
   base::RunLoop().RunUntilIdle();
 
   DCHECK(session() != nullptr);
   if (!connected() &&
       session()->error() == QUIC_CRYPTO_HANDSHAKE_STATELESS_REJECT) {
     DCHECK(FLAGS_enable_quic_stateless_reject_support);
     DVLOG(1) << "Detected stateless reject while waiting for events.  "
              << "Attempting to reconnect.";
     Connect();
   }
 
   return session()->num_active_requests() != 0;
 }
 
 bool QuicClient::MigrateSocket(const IPAddress& new_host) {
   if (!connected()) {
     return false;
   }
 
   CleanUpUDPSocket(GetLatestFD());
 
-  bind_to_address_ = new_host;
+  set_bind_to_address(new_host);
   if (!CreateUDPSocketAndBind()) {
     return false;
   }
 
   epoll_server_->RegisterFD(GetLatestFD(), this, kEpollFlags);
   session()->connection()->SetSelfAddress(GetLatestClientAddress());
 
   QuicPacketWriter* writer = CreateQuicPacketWriter();
   set_writer(writer);
   session()->connection()->SetQuicPacketWriter(writer, false);
@@ skipping 15 matching lines @@
   }
   if (connected() && (event->in_events & EPOLLOUT)) {
     writer()->SetWritable();
     session()->connection()->OnCanWrite();
   }
   if (event->in_events & EPOLLERR) {
     DVLOG(1) << "Epollerr";
   }
 }
 
-void QuicClient::OnClose(QuicSpdyStream* stream) {
-  DCHECK(stream != nullptr);
-  QuicSpdyClientStream* client_stream =
-      static_cast<QuicSpdyClientStream*>(stream);
-
-  const SpdyHeaderBlock& response_headers = client_stream->response_headers();
-  if (response_listener_.get() != nullptr) {
-    response_listener_->OnCompleteResponse(stream->id(), response_headers,
-                                           client_stream->data());
-  }
-
-  // Store response headers and body.
-  if (store_response_) {
-    auto status = response_headers.find(":status");
-    if (status == response_headers.end() ||
-        !StringToInt(status->second, &latest_response_code_)) {
-      LOG(ERROR) << "Invalid response headers: no status code";
-    }
-    latest_response_headers_ = response_headers.DebugString();
-    latest_response_header_block_ = response_headers.Clone();
-    latest_response_body_ = client_stream->data();
-    latest_response_trailers_ =
-        client_stream->received_trailers().DebugString();
-  }
-}
-
-size_t QuicClient::latest_response_code() const {
-  QUIC_BUG_IF(!store_response_) << "Response not stored!";
-  return latest_response_code_;
-}
-
-const string& QuicClient::latest_response_headers() const {
-  QUIC_BUG_IF(!store_response_) << "Response not stored!";
-  return latest_response_headers_;
-}
-
-const SpdyHeaderBlock& QuicClient::latest_response_header_block() const {
-  QUIC_BUG_IF(!store_response_) << "Response not stored!";
-  return latest_response_header_block_;
-}
-
-const string& QuicClient::latest_response_body() const {
-  QUIC_BUG_IF(!store_response_) << "Response not stored!";
-  return latest_response_body_;
-}
-
-const string& QuicClient::latest_response_trailers() const {
-  QUIC_BUG_IF(!store_response_) << "Response not stored!";
-  return latest_response_trailers_;
-}
-
 QuicPacketWriter* QuicClient::CreateQuicPacketWriter() {
   return new QuicDefaultPacketWriter(GetLatestFD());
 }
 
 const IPEndPoint QuicClient::GetLatestClientAddress() const {
   if (fd_address_map_.empty()) {
     return IPEndPoint();
   }
 
   return fd_address_map_.back().second;
 }
 
 int QuicClient::GetLatestFD() const {
   if (fd_address_map_.empty()) {
     return -1;
   }
 
   return fd_address_map_.back().first;
 }
 
 void QuicClient::ProcessPacket(const IPEndPoint& self_address,
                                const IPEndPoint& peer_address,
                                const QuicReceivedPacket& packet) {
   session()->connection()->ProcessUdpPacket(self_address, peer_address, packet);
 }
 
 }  // namespace net