Move QuicClient::ClientQuicDataToResend from QuicClient to QuicClientBase.

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 26 matching lines @@
 
 using base::StringPiece;
 using base::StringToInt;
 using std::string;
 using std::vector;
 
 namespace net {
 
 const int kEpollFlags = EPOLLIN | EPOLLOUT | EPOLLET;
 
-void QuicClient::ClientQuicDataToResend::Resend() {
-  client_->SendRequest(*headers_, body_, fin_);
-  headers_ = nullptr;
-}
-
 QuicClient::QuicClient(IPEndPoint server_address,
                        const QuicServerId& server_id,
                        const QuicVersionVector& supported_versions,
                        EpollServer* epoll_server,
                        std::unique_ptr<ProofVerifier> proof_verifier)
     : QuicClient(server_address,
                  server_id,
                  supported_versions,
                  QuicConfig(),
                  epoll_server,
@@ skipping 105 matching lines @@
 
 bool QuicClient::Connect() {
   // Attempt multiple connects until the maximum number of client hellos have
   // been sent.
   while (!connected() &&
          GetNumSentClientHellos() <= QuicCryptoClientStream::kMaxClientHellos) {
     StartConnect();
     while (EncryptionBeingEstablished()) {
       WaitForEvents();
     }
-    if (FLAGS_enable_quic_stateless_reject_support && connected() &&
-        !data_to_resend_on_connect_.empty()) {
-      // A connection has been established and there was previously queued data
-      // to resend.  Resend it and empty the queue.
-      std::vector<std::unique_ptr<QuicDataToResend>> old_data;
-      old_data.swap(data_to_resend_on_connect_);
-      for (const auto& data : old_data) {
-        data->Resend();
-      }
+    if (FLAGS_enable_quic_stateless_reject_support && connected()) {
+      // Resend any previously queued data.

[Zhongyi Shi, 2016/09/27 04:40:25]

nit: comments here seem to be out of sync with internal code?

[Ryan Hamilton, 2016/09/27 14:28:00]

Silly long story, but will be fixed in the next cl.

+      ResendSavedData();
     }
     if (session() != nullptr &&
         session()->error() != QUIC_CRYPTO_HANDSHAKE_STATELESS_REJECT) {
       // We've successfully created a session but we're not connected, and there
       // is no stateless reject to recover from.  Give up trying.
       break;
     }
   }
   if (!connected() &&
       GetNumSentClientHellos() > QuicCryptoClientStream::kMaxClientHellos &&
       session() != nullptr &&
       session()->error() == QUIC_CRYPTO_HANDSHAKE_STATELESS_REJECT) {
     // The overall connection failed due too many stateless rejects.
     set_connection_error(QUIC_CRYPTO_TOO_MANY_REJECTS);
   }
   return session()->connection()->connected();
 }
 
 void QuicClient::StartConnect() {
   DCHECK(initialized_);
   DCHECK(!connected());
 
   QuicPacketWriter* writer = CreateQuicPacketWriter();
 
   if (connected_or_attempting_connect()) {
     // If the last error was not a stateless reject, then the queued up data
     // does not need to be resent.
     if (session()->error() != QUIC_CRYPTO_HANDSHAKE_STATELESS_REJECT) {
-      data_to_resend_on_connect_.clear();
+      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,
       /* 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);
 }
 
 void QuicClient::Disconnect() {
   DCHECK(initialized_);
 
   if (connected()) {
     session()->connection()->CloseConnection(
         QUIC_PEER_GOING_AWAY, "Client disconnecting",
         ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
   }
 
-  data_to_resend_on_connect_.clear();
+  ClearDataToResend();
 
   CleanUpAllUDPSockets();
 
   initialized_ = false;
 }
 
 void QuicClient::CleanUpUDPSocket(int fd) {
   CleanUpUDPSocketImpl(fd);
   fd_address_map_.erase(fd);
 }
@@ skipping 16 matching lines @@
 void QuicClient::SendRequest(const SpdyHeaderBlock& headers,
                              StringPiece body,
                              bool fin) {
   QuicClientPushPromiseIndex::TryHandle* handle;
   QuicAsyncStatus rv = push_promise_index()->Try(headers, this, &handle);
   if (rv == QUIC_SUCCESS)
     return;
 
   if (rv == QUIC_PENDING) {
     // May need to retry request if asynchronous rendezvous fails.
-    std::unique_ptr<SpdyHeaderBlock> new_headers(
-        new SpdyHeaderBlock(headers.Clone()));
-    push_promise_data_to_resend_.reset(
-        new ClientQuicDataToResend(std::move(new_headers), body, fin, this));
+    AddPromiseDataToResend(headers, body, fin);
     return;
   }
 
   QuicSpdyClientStream* stream = CreateReliableClientStream();
   if (stream == nullptr) {
     QUIC_BUG << "stream creation failed!";
     return;
   }
   stream->SendRequest(headers.Clone(), body, fin);
-  if (FLAGS_enable_quic_stateless_reject_support) {
-    // Record this in case we need to resend.
-    std::unique_ptr<SpdyHeaderBlock> new_headers(
-        new SpdyHeaderBlock(headers.Clone()));
-    auto data_to_resend =
-        new ClientQuicDataToResend(std::move(new_headers), body, fin, this);
-    MaybeAddQuicDataToResend(std::unique_ptr<QuicDataToResend>(data_to_resend));
-  }
-}
-
-void QuicClient::MaybeAddQuicDataToResend(
-    std::unique_ptr<QuicDataToResend> data_to_resend) {
-  DCHECK(FLAGS_enable_quic_stateless_reject_support);
-  if (session()->IsCryptoHandshakeConfirmed()) {
-    // The handshake is confirmed.  No need to continue saving requests to
-    // resend.
-    data_to_resend_on_connect_.clear();
-    return;
-  }
-
-  // The handshake is not confirmed.  Push the data onto the queue of data to
-  // resend if statelessly rejected.
-  data_to_resend_on_connect_.push_back(std::move(data_to_resend));
+  // Record this in case we need to resend.
+  MaybeAddDataToResend(headers, body, fin);
 }
 
 void QuicClient::SendRequestAndWaitForResponse(const SpdyHeaderBlock& headers,
                                                StringPiece body,
                                                bool fin) {
   SendRequest(headers, body, fin);
   while (WaitForEvents()) {
   }
 }
 
@@ skipping 99 matching lines @@
       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();
   }
 }
 
-bool QuicClient::CheckVary(const SpdyHeaderBlock& client_request,
-                           const SpdyHeaderBlock& promise_request,
-                           const SpdyHeaderBlock& promise_response) {
-  return true;
-}
-
-void QuicClient::OnRendezvousResult(QuicSpdyStream* stream) {
-  std::unique_ptr<ClientQuicDataToResend> data_to_resend =
-      std::move(push_promise_data_to_resend_);
-  if (stream) {
-    stream->set_visitor(this);
-    stream->OnDataAvailable();
-  } else if (data_to_resend.get()) {
-    data_to_resend->Resend();
-  }
-}
-
 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_;
 }
 
@@ skipping 32 matching lines @@
   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