Always use recvmmsg or recvmsg if it's available, and consolidate ReadAndDispatchPackets and ReadAn…

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 56 matching lines @@
                      supported_versions,
                      config,
                      new QuicEpollConnectionHelper(epoll_server),
                      proof_verifier),
       server_address_(server_address),
       local_port_(0),
       epoll_server_(epoll_server),
       initialized_(false),
       packets_dropped_(0),
       overflow_supported_(false),
-      use_recvmmsg_(false),
       store_response_(false),
       latest_response_code_(-1),
       packet_reader_(new QuicPacketReader()) {}
 
 QuicClient::~QuicClient() {
   if (connected()) {
     session()->connection()->SendConnectionCloseWithDetails(
         QUIC_PEER_GOING_AWAY, "Client being torn down");
   }
 
   STLDeleteElements(&data_to_resend_on_connect_);
   STLDeleteElements(&data_sent_before_handshake_);
 
   CleanUpAllUDPSockets();
 }
 
 bool QuicClient::Initialize() {
   QuicClientBase::Initialize();
 
-#if MMSG_MORE
-  use_recvmmsg_ = true;
-#endif
-
   set_num_sent_client_hellos(0);
   set_num_stateless_rejects_received(0);
   set_connection_error(QUIC_NO_ERROR);
 
   // If an initial flow control window has not explicitly been set, then use the
   // same values that Chrome uses.
   const uint32_t kSessionMaxRecvWindowSize = 15 * 1024 * 1024;  // 15 MB
   const uint32_t kStreamMaxRecvWindowSize = 6 * 1024 * 1024;    //  6 MB
   if (config()->GetInitialStreamFlowControlWindowToSend() ==
       kMinimumFlowControlSendWindow) {
@@ skipping 278 matching lines @@
 
   return true;
 }
 
 void QuicClient::OnEvent(int fd, EpollEvent* event) {
   DCHECK_EQ(fd, GetLatestFD());
 
   if (event->in_events & EPOLLIN) {
     bool more_to_read = true;
     while (connected() && more_to_read) {
-      if (use_recvmmsg_) {
-        more_to_read = packet_reader_->ReadAndDispatchPackets(
-            GetLatestFD(), QuicClient::GetLatestClientAddress().port(), this,
-            overflow_supported_ ? &packets_dropped_ : nullptr);
-      } else {
-        more_to_read = QuicPacketReader::ReadAndDispatchSinglePacket(
-            GetLatestFD(), QuicClient::GetLatestClientAddress().port(), this,
-            overflow_supported_ ? &packets_dropped_ : nullptr);
-      }
+      more_to_read = packet_reader_->ReadAndDispatchPackets(
+          GetLatestFD(), QuicClient::GetLatestClientAddress().port(), this,
+          overflow_supported_ ? &packets_dropped_ : nullptr);
     }
   }
   if (connected() && (event->in_events & EPOLLOUT)) {
     writer()->SetWritable();
     session()->connection()->OnCanWrite();
   }
   if (event->in_events & EPOLLERR) {
     DVLOG(1) << "Epollerr";
   }
 }
@@ skipping 78 matching lines @@
   return fd_address_map_.back().first;
 }
 
 void QuicClient::ProcessPacket(const IPEndPoint& self_address,
                                const IPEndPoint& peer_address,
                                const QuicEncryptedPacket& packet) {
   session()->connection()->ProcessUdpPacket(self_address, peer_address, packet);
 }
 
 }  // namespace net