Landing Recent QUIC changes until 4AM, Aug 7, 2016 UTC-4

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 80 matching lines @@
     hdr->msg_controllen = QuicSocketUtils::kSpaceForCmsg;
   }
 
   int packets_read =
       recvmmsg(fd, mmsg_hdr_, kNumPacketsPerReadMmsgCall, 0, nullptr);
 
   if (packets_read <= 0) {
     return false;  // recvmmsg failed.
   }
 
-  QuicTime fallback_timestamp = QuicTime::Zero();
   QuicWallTime fallback_walltimestamp = QuicWallTime::Zero();
   for (int i = 0; i < packets_read; ++i) {
     if (mmsg_hdr_[i].msg_len == 0) {
       continue;
     }
 
     if (mmsg_hdr_[i].msg_hdr.msg_controllen >= QuicSocketUtils::kSpaceForCmsg) {
       QUIC_BUG << "Incorrectly set control length: "
                << mmsg_hdr_[i].msg_hdr.msg_controllen << ", expected "
                << QuicSocketUtils::kSpaceForCmsg;
       continue;
     }
 
     IPEndPoint client_address = IPEndPoint(packets_[i].raw_address);
     IPAddress server_ip;
-    QuicTime packet_timestamp = QuicTime::Zero();
     QuicWallTime packet_walltimestamp = QuicWallTime::Zero();
-    bool latched_walltimestamps = FLAGS_quic_socket_walltimestamps;
     QuicSocketUtils::GetAddressAndTimestampFromMsghdr(
-        &mmsg_hdr_[i].msg_hdr, &server_ip, &packet_timestamp,
-        &packet_walltimestamp, latched_walltimestamps);
+        &mmsg_hdr_[i].msg_hdr, &server_ip, &packet_walltimestamp);
     if (!IsInitializedAddress(server_ip)) {
       QUIC_BUG << "Unable to get server address.";
       continue;
     }
 
     // This isn't particularly desirable, but not all platforms support socket
     // timestamping.
-    if (latched_walltimestamps) {
-      if (packet_walltimestamp.IsZero()) {
-        if (fallback_walltimestamp.IsZero()) {
-          fallback_walltimestamp = clock.WallNow();
-        }
-        packet_walltimestamp = fallback_walltimestamp;
+    if (packet_walltimestamp.IsZero()) {
+      if (fallback_walltimestamp.IsZero()) {
+        fallback_walltimestamp = clock.WallNow();
       }
-      packet_timestamp = clock.ConvertWallTimeToQuicTime(packet_walltimestamp);
-    } else {
-      if (packet_timestamp == QuicTime::Zero()) {
-        if (fallback_timestamp == QuicTime::Zero()) {
-          fallback_timestamp = clock.Now();
-        }
-        packet_timestamp = fallback_timestamp;
-      }
+      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, packet_timestamp, false);
+                              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,
     const QuicClock& clock,
     ProcessPacketInterface* processor,
     QuicPacketCount* packets_dropped) {
-  bool latched_walltimestamps = FLAGS_quic_socket_walltimestamps;
   char buf[kMaxPacketSize];
 
   IPEndPoint client_address;
   IPAddress server_ip;
-  QuicTime timestamp = QuicTime::Zero();
   QuicWallTime walltimestamp = QuicWallTime::Zero();
-  int bytes_read = QuicSocketUtils::ReadPacket(
-      fd, buf, arraysize(buf), packets_dropped, &server_ip, &timestamp,
-      &walltimestamp, latched_walltimestamps, &client_address);
-
+  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 (latched_walltimestamps) {
-    if (walltimestamp.IsZero()) {
-      walltimestamp = clock.WallNow();
-    }
-    timestamp = clock.ConvertWallTimeToQuicTime(walltimestamp);
-  } else {
-    if (timestamp == QuicTime::Zero()) {
-      timestamp = clock.Now();
-    }
+  if (walltimestamp.IsZero()) {
+    walltimestamp = clock.WallNow();
   }
+  QuicTime timestamp = clock.ConvertWallTimeToQuicTime(walltimestamp);
 
   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