Factor out the QUIC socket reading code into a stand alone QuicPacketReader

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 "base/logging.h"
 #include "base/run_loop.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_request_info.h"
 #include "net/quic/crypto/quic_random.h"
 #include "net/quic/quic_connection.h"
 #include "net/quic/quic_connection_helper.h"
 #include "net/quic/quic_default_packet_writer.h"
 #include "net/quic/quic_protocol.h"
 #include "net/quic/quic_server_id.h"
 #include "net/udp/udp_client_socket.h"
 
 using std::string;
 using std::vector;
 
 namespace net {
 namespace tools {
-namespace {
-
-// Allocate some extra space so we can send an error if the server goes over
-// the limit.
-const int kReadBufferSize = 2 * kMaxPacketSize;
-
-}  // namespace
 
 QuicSimpleClient::QuicSimpleClient(IPEndPoint server_address,
                                    const QuicServerId& server_id,
                                    const QuicVersionVector& supported_versions)
     : server_address_(server_address),
       server_id_(server_id),
       local_port_(0),
       helper_(CreateQuicConnectionHelper()),
       initialized_(false),
       supported_versions_(supported_versions),
-      read_pending_(false),
-      synchronous_read_count_(0),
-      read_buffer_(new IOBufferWithSize(kReadBufferSize)),
       weak_factory_(this) {
 }
 
 QuicSimpleClient::QuicSimpleClient(IPEndPoint server_address,
                                    const QuicServerId& server_id,
                                    const QuicVersionVector& supported_versions,
                                    const QuicConfig& config)
     : server_address_(server_address),
       server_id_(server_id),
       config_(config),
       local_port_(0),
       helper_(CreateQuicConnectionHelper()),
       initialized_(false),
       supported_versions_(supported_versions),
-      read_pending_(false),
-      synchronous_read_count_(0),
-      read_buffer_(new IOBufferWithSize(kReadBufferSize)),
       weak_factory_(this) {
 }
 
 QuicSimpleClient::~QuicSimpleClient() {
   if (connected()) {
     session()->connection()->SendConnectionClosePacket(
         QUIC_PEER_GOING_AWAY, "");
   }
 }
 
@@ skipping 57 matching lines @@
     return false;
   }
 
   rc = socket->GetLocalAddress(&client_address_);
   if (rc != OK) {
     LOG(ERROR) << "GetLocalAddress failed: " << ErrorToString(rc);
     return false;
   }
 
   socket_.swap(socket);
-
-  read_pending_ = false;
+  packet_reader_.reset(new QuicPacketReader(socket_.get(), this,
+                                            BoundNetLog()));
 
   if (socket != nullptr) {
     socket->Close();
   }
 
   return true;
 }
 
 bool QuicSimpleClient::Connect() {
   StartConnect();
-  StartReading();
+  packet_reader_->StartReading();
   while (EncryptionBeingEstablished()) {
     WaitForEvents();
   }
   return session_->connection()->connected();
 }
 
 void QuicSimpleClient::StartConnect() {
   DCHECK(initialized_);
   DCHECK(!connected());
 
@@ skipping 17 matching lines @@
 }
 
 void QuicSimpleClient::Disconnect() {
   DCHECK(initialized_);
 
   if (connected()) {
     session()->connection()->SendConnectionClose(QUIC_PEER_GOING_AWAY);
   }
 
   writer_.reset();
-
-  read_pending_ = false;
+  packet_reader_.reset();
 
   initialized_ = false;
 }
 
 void QuicSimpleClient::SendRequest(const HttpRequestInfo& headers,
                                    base::StringPiece body,
                                    bool fin) {
   QuicSimpleClientStream* stream = CreateReliableClientStream();
   if (stream == nullptr) {
     LOG(DFATAL) << "stream creation failed!";
@@ skipping 102 matching lines @@
   return new QuicConnectionHelper(
       base::MessageLoop::current()->message_loop_proxy().get(),
       &clock_,
       QuicRandom::GetInstance());
 }
 
 QuicPacketWriter* QuicSimpleClient::CreateQuicPacketWriter() {
   return new QuicDefaultPacketWriter(socket_.get());
 }
 
-void QuicSimpleClient::StartReading() {
-  if (read_pending_) {
-    return;
-  }
-  read_pending_ = true;
+void QuicSimpleClient::OnReadError(int result) {
+  LOG(ERROR) << "QuicSimpleClient read failed: " << ErrorToString(result);
+  Disconnect();
+}
 
-  int result = socket_->Read(
-      read_buffer_.get(),
-      read_buffer_->size(),
-      base::Bind(&QuicSimpleClient::OnReadComplete,
-                 weak_factory_.GetWeakPtr()));
-
-  if (result == ERR_IO_PENDING) {
-    synchronous_read_count_ = 0;
-    return;
+bool QuicSimpleClient::OnPacket(const QuicEncryptedPacket& packet,
+                                IPEndPoint local_address,
+                                IPEndPoint peer_address) {
+  session_->connection()->ProcessUdpPacket(local_address, peer_address, packet);
+  if (!session_->connection()->connected()) {
+    return false;
   }
 
-  if (++synchronous_read_count_ > 32) {
-    synchronous_read_count_ = 0;
-    // Schedule the processing through the message loop to 1) prevent infinite
-    // recursion and 2) avoid blocking the thread for too long.
-    base::MessageLoop::current()->PostTask(
-        FROM_HERE,
-        base::Bind(&QuicSimpleClient::OnReadComplete,
-                   weak_factory_.GetWeakPtr(), result));
-  } else {
-    OnReadComplete(result);
-  }
-}
-
-void QuicSimpleClient::OnReadComplete(int result) {
-  read_pending_ = false;
-  if (result == 0)
-    result = ERR_CONNECTION_CLOSED;
-
-  if (result < 0) {
-    LOG(ERROR) << "QuicSimpleClient read failed: " << ErrorToString(result);
-    Disconnect();
-    return;
-  }
-
-  QuicEncryptedPacket packet(read_buffer_->data(), result);
-  IPEndPoint local_address;
-  IPEndPoint peer_address;
-  socket_->GetLocalAddress(&local_address);
-  socket_->GetPeerAddress(&peer_address);
-  session_->connection()->ProcessUdpPacket(local_address, peer_address, packet);
-  if (!session_->connection()->connected()) {
-    return;
-  }
-
-  StartReading();
+  return true;
 }
 
 }  // namespace tools
 }  // namespace net