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 100 matching lines @@
 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() {
+  if (synchronous_read_count_ == 0) {

[Ryan Hamilton, 2016/09/07 19:46:18]

If you wanted, you could add  a comment here like:

// Only process buffered packets once per message loop.

+    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)));
 
   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.

[Ryan Hamilton, 2016/09/07 19:46:18]

nit: Can you shrink this comment to:

// No more packets to read, so yield before processing buffered packets.

+      base::ThreadTaskRunnerHandle::Get()->PostTask(
+          FROM_HERE, base::Bind(&QuicSimpleServer::StartReading,
+                                weak_factory_.GetWeakPtr()));
+    }
     return;
   }
 
+  // For synchronous read, if server has read enough for current socket event,
+  // yeild and continue processing in next event.

[Ryan Hamilton, 2016/09/07 19:46:18]

I'd just drop this comment (and the next two) since they're not super helpful.
(And this comment mentions "server" but I think it's actually referring to the
comment.

   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));
   } else {
+    // No need to check buffer for following reads.
     OnReadComplete(result);
   }
 }
 
 void QuicSimpleServer::OnReadComplete(int result) {
   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();
 }
 
 }  // namespace net