Limits only 16 new QUIC connections can be opened per socket event for QuicSimpleServer. Fix test f…

net/tools/quic/quic_simple_server.cc

 // Copyright 2014 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_server.h"
 
 #include <string.h>
 
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "net/quic/core/crypto/crypto_handshake.h"
 #include "net/quic/core/crypto/quic_random.h"
 #include "net/quic/core/quic_crypto_stream.h"
 #include "net/quic/core/quic_data_reader.h"
 #include "net/quic/core/quic_protocol.h"
 #include "net/tools/quic/quic_simple_dispatcher.h"
 #include "net/tools/quic/quic_simple_per_connection_packet_writer.h"
 #include "net/tools/quic/quic_simple_server_packet_writer.h"
 #include "net/tools/quic/quic_simple_server_session_helper.h"
 #include "net/udp/udp_server_socket.h"
 
 namespace net {
 
 namespace {
 
 const char kSourceAddressTokenSecret[] = "secret";
+const size_t kNumSessionsToCreatePerSocketEvent = 16;
 
 // Allocate some extra space so we can send an error if the client goes over
 // the limit.
 const int kReadBufferSize = 2 * kMaxPacketSize;
 
 }  // namespace
 
 QuicSimpleServer::QuicSimpleServer(
     std::unique_ptr<ProofSource> proof_source,
     const QuicConfig& config,
@@ skipping 85 matching lines @@
   dispatcher_.reset(new QuicSimpleDispatcher(
       config_, &crypto_config_, &version_manager_,
       std::unique_ptr<QuicConnectionHelperInterface>(helper_),
       std::unique_ptr<QuicServerSessionBase::Helper>(
           new QuicSimpleServerSessionHelper(QuicRandom::GetInstance())),
       std::unique_ptr<QuicAlarmFactory>(alarm_factory_)));
   QuicSimpleServerPacketWriter* writer =
       new QuicSimpleServerPacketWriter(socket_.get(), dispatcher_.get());
   dispatcher_->InitializeWithWriter(writer);
 
-  StartReading();
+  StartReading(true);
 
   return OK;
 }
 
 void QuicSimpleServer::Shutdown() {
   // Before we shut down the epoll server, give all active sessions a chance to
   // notify clients that they're closing.
   dispatcher_->Shutdown();
 
   socket_->Close();
   socket_.reset();
 }
 
-void QuicSimpleServer::StartReading() {
+void QuicSimpleServer::StartReading(bool check_packet_buffer) {
+  if (check_packet_buffer) {

[Ryan Hamilton, 2016/09/06 23:21:46]

I wonder if you could simply check synchronous_read_count_ == 0 here instead,
since that's only true once per event loop? If so, that'd be pretty simple.

+    dispatcher_->ProcessBufferedChlos(kNumSessionsToCreatePerSocketEvent);
+  }
+
   if (read_pending_) {
     return;
   }
   read_pending_ = true;
 
   int result = socket_->RecvFrom(
       read_buffer_.get(), read_buffer_->size(), &client_address_,
-      base::Bind(&QuicSimpleServer::OnReadComplete, base::Unretained(this)));
+      base::Bind(&QuicSimpleServer::OnAsyncReadComplete,
+                 base::Unretained(this)));
 
   if (result == ERR_IO_PENDING) {
     synchronous_read_count_ = 0;
+    if (dispatcher_->HasChlosBuffered()) {
+      // No more packets to read, but still keep processing buffered packets in
+      // next socket event if there is any.
+      base::ThreadTaskRunnerHandle::Get()->PostTask(
+          FROM_HERE, base::Bind(&QuicSimpleServer::StartReading,
+                                weak_factory_.GetWeakPtr(), true));
+    }
     return;
   }
 
+  // For synchronous read, if server has read enough for current socket event,
+  // yeild and continue processing in next event.
   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.
+    // Check buffer in next event.
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&QuicSimpleServer::OnReadComplete,
-                              weak_factory_.GetWeakPtr(), result));
+                              weak_factory_.GetWeakPtr(), result, true));
   } else {
-    OnReadComplete(result);
+    // No need to check buffer for following reads.
+    OnReadComplete(result, false);
   }
 }
 
-void QuicSimpleServer::OnReadComplete(int result) {
+void QuicSimpleServer::OnAsyncReadComplete(
+    int result) {  // For asynchronous read, check the buffer again.
+  OnReadComplete(result, true);
+}
+
+void QuicSimpleServer::OnReadComplete(int result, bool check_packet_buffer) {
   read_pending_ = false;
   if (result == 0)
     result = ERR_CONNECTION_CLOSED;
 
   if (result < 0) {
     LOG(ERROR) << "QuicSimpleServer read failed: " << ErrorToString(result);
     Shutdown();
     return;
   }
 
   QuicReceivedPacket packet(read_buffer_->data(), result,
                             helper_->GetClock()->Now(), false);
   dispatcher_->ProcessPacket(server_address_, client_address_, packet);
 
-  StartReading();
+  StartReading(check_packet_buffer);
 }
 
 }  // namespace net