Automated rollback of internal change 130388085.

net/tools/quic/quic_packet_reader.cc

 // Copyright 2015 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_packet_reader.h"
 
 #include <errno.h>
 #ifndef __APPLE__
 // This is a GNU header that is not present in /usr/include on MacOS
 #include <features.h>
@@ skipping 45 matching lines @@
     hdr->msg_controllen = QuicSocketUtils::kSpaceForCmsg;
   }
 #endif
 }
 
 QuicPacketReader::~QuicPacketReader() {}
 
 bool QuicPacketReader::ReadAndDispatchPackets(
     int fd,
     int port,
-    bool potentially_small_mtu,
     const QuicClock& clock,
     ProcessPacketInterface* processor,
     QuicPacketCount* packets_dropped) {
 #if MMSG_MORE
-  return ReadAndDispatchManyPackets(fd, port, potentially_small_mtu, clock,
-                                    processor, packets_dropped);
+  return ReadAndDispatchManyPackets(fd, port, clock, processor,
+                                    packets_dropped);
 #else
-  return ReadAndDispatchSinglePacket(fd, port, potentially_small_mtu, clock,
-                                     processor, packets_dropped);
+  return ReadAndDispatchSinglePacket(fd, port, clock, processor,
+                                     packets_dropped);
 #endif
 }
 
 bool QuicPacketReader::ReadAndDispatchManyPackets(
     int fd,
     int port,
-    bool potentially_small_mtu,
     const QuicClock& clock,
     ProcessPacketInterface* processor,
     QuicPacketCount* packets_dropped) {
 #if MMSG_MORE
   // Re-set the length fields in case recvmmsg has changed them.
   for (int i = 0; i < kNumPacketsPerReadMmsgCall; ++i) {
     DCHECK_EQ(kMaxPacketSize, packets_[i].iov.iov_len);
     msghdr* hdr = &mmsg_hdr_[i].msg_hdr;
     hdr->msg_namelen = sizeof(sockaddr_storage);
     DCHECK_EQ(1, hdr->msg_iovlen);
@@ skipping 36 matching lines @@
       if (fallback_walltimestamp.IsZero()) {
         fallback_walltimestamp = clock.WallNow();
       }
       packet_walltimestamp = fallback_walltimestamp;
     }
     QuicTime timestamp = clock.ConvertWallTimeToQuicTime(packet_walltimestamp);
     int ttl = 0;
     bool has_ttl =
         QuicSocketUtils::GetTtlFromMsghdr(&mmsg_hdr_[i].msg_hdr, &ttl);
     QuicReceivedPacket packet(reinterpret_cast<char*>(packets_[i].iov.iov_base),
-                              mmsg_hdr_[i].msg_len, timestamp, false,
-                              potentially_small_mtu, ttl, has_ttl);
+                              mmsg_hdr_[i].msg_len, timestamp, false, ttl,
+                              has_ttl);
     IPEndPoint server_address(server_ip, port);
     processor->ProcessPacket(server_address, client_address, packet);
   }
 
   if (packets_dropped != nullptr) {
     QuicSocketUtils::GetOverflowFromMsghdr(&mmsg_hdr_[0].msg_hdr,
                                            packets_dropped);
   }
 
   // We may not have read all of the packets available on the socket.
   return packets_read == kNumPacketsPerReadMmsgCall;
 #else
   LOG(FATAL) << "Unsupported";
   return false;
 #endif
 }
 
 /* static */
 bool QuicPacketReader::ReadAndDispatchSinglePacket(
     int fd,
     int port,
-    bool potentially_small_mtu,
     const QuicClock& clock,
     ProcessPacketInterface* processor,
     QuicPacketCount* packets_dropped) {
   char buf[kMaxPacketSize];
 
   IPEndPoint client_address;
   IPAddress server_ip;
   QuicWallTime walltimestamp = QuicWallTime::Zero();
   int bytes_read =
       QuicSocketUtils::ReadPacket(fd, buf, arraysize(buf), packets_dropped,
                                   &server_ip, &walltimestamp, &client_address);
   if (bytes_read < 0) {
     return false;  // ReadPacket failed.
   }
 
   if (server_ip.empty()) {
     QUIC_BUG << "Unable to get server address.";
     return false;
   }
   // This isn't particularly desirable, but not all platforms support socket
   // timestamping.
   if (walltimestamp.IsZero()) {
     walltimestamp = clock.WallNow();
   }
   QuicTime timestamp = clock.ConvertWallTimeToQuicTime(walltimestamp);
 
-  QuicReceivedPacket packet(buf, bytes_read, timestamp, false /* owns_buffer */,
-                            potentially_small_mtu, -1 /* ttl */,
-                            false /* ttl_valid */);
+  QuicReceivedPacket packet(buf, bytes_read, timestamp, false);
   IPEndPoint server_address(server_ip, port);
   processor->ProcessPacket(server_address, client_address, packet);
 
   // The socket read was successful, so return true even if packet dispatch
   // failed.
   return true;
 }
 
 
 }  // namespace net