relnote: moves ProcessPacketInterface from quic_dispatcher.h to

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 11 matching lines @@
 #include "net/quic/quic_protocol.h"
 #include "net/quic/quic_server_id.h"
 #include "net/tools/quic/quic_epoll_connection_helper.h"
 #include "net/tools/quic/quic_socket_utils.h"
 #include "net/tools/quic/spdy_balsa_utils.h"
 
 #ifndef SO_RXQ_OVFL
 #define SO_RXQ_OVFL 40
 #endif
 
+// TODO(rtenneti): Add support for MMSG_MORE.
+#define MMSG_MORE 0
+
 using std::string;
 using std::vector;
 
 namespace net {
 namespace tools {
 
 const int kEpollFlags = EPOLLIN | EPOLLOUT | EPOLLET;
 
 void QuicClient::ClientQuicDataToResend::Resend() {
   client_->SendRequest(*headers_, body_, fin_);
@@ skipping 24 matching lines @@
                      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),
       store_response_(false),
-      latest_response_code_(-1) {}
+      latest_response_code_(-1),
+      packet_reader_(CreateQuicPacketReader()) {}
 
 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_);
 
@@ skipping 298 matching lines @@
   set_writer(writer);
   session()->connection()->SetQuicPacketWriter(writer, false);
 
   return true;
 }
 
 void QuicClient::OnEvent(int fd, EpollEvent* event) {
   DCHECK_EQ(fd, GetLatestFD());
 
   if (event->in_events & EPOLLIN) {
-    while (connected() && ReadAndProcessPacket()) {
+    while (connected()) {
+      if (
+#if MMSG_MORE
+          !ReadAndProcessPackets()
+#else
+          !ReadAndProcessPacket()
+#endif
+              ) {
+        break;
+      }
     }
   }
   if (connected() && (event->in_events & EPOLLOUT)) {
     writer()->SetWritable();
     session()->connection()->OnCanWrite();
   }
   if (event->in_events & EPOLLERR) {
     DVLOG(1) << "Epollerr";
   }
 }
@@ skipping 37 matching lines @@
 
 const string& QuicClient::latest_response_trailers() const {
   QUIC_BUG_IF(!store_response_) << "Response not stored!";
   return latest_response_trailers_;
 }
 
 QuicPacketWriter* QuicClient::CreateQuicPacketWriter() {
   return new QuicDefaultPacketWriter(GetLatestFD());
 }
 
+QuicPacketReader* QuicClient::CreateQuicPacketReader() {
+  return new QuicPacketReader();
+}
+
 int QuicClient::ReadPacket(char* buffer,
                            int buffer_len,
                            IPEndPoint* server_address,
                            IPAddressNumber* client_ip) {
   return QuicSocketUtils::ReadPacket(
       GetLatestFD(), buffer, buffer_len,
       overflow_supported_ ? &packets_dropped_ : nullptr, client_ip,
       server_address);
 }
 
@@ skipping 38 matching lines @@
 }
 
 int QuicClient::GetLatestFD() const {
   if (fd_address_map_.empty()) {
     return -1;
   }
 
   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 tools
 }  // namespace net