Various QUIC cleanups to sync with internal code.

net/quic/quic_connection.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/quic/quic_connection.h"
 
 #include <string.h>
 #include <sys/types.h>
 #include <algorithm>
 #include <iterator>
@@ skipping 17 matching lines @@
 using base::StringPiece;
 using std::list;
 using std::make_pair;
 using std::min;
 using std::max;
 using std::numeric_limits;
 using std::vector;
 using std::set;
 using std::string;
 
-int FLAGS_fake_packet_loss_percentage = 0;
-
-// If true, then QUIC connections will bundle acks with any outgoing packet when
-// an ack is being delayed. This is an optimization to reduce ack latency and
-// packet count of pure ack packets.
-bool FLAGS_bundle_ack_with_outgoing_packet = false;
+extern bool FLAGS_quic_allow_oversized_packets_for_test;
 
 namespace net {
 
 class QuicDecrypter;
 class QuicEncrypter;
 
 namespace {
 
 // The largest gap in packets we'll accept without closing the connection.
 // This will likely have to be tuned.
 const QuicPacketSequenceNumber kMaxPacketGap = 5000;
 
 // Limit the number of FEC groups to two.  If we get enough out of order packets
 // that this becomes limiting, we can revisit.
 const size_t kMaxFecGroups = 2;
 
 // Limit the number of undecryptable packets we buffer in
 // expectation of the CHLO/SHLO arriving.
 const size_t kMaxUndecryptablePackets = 10;
 
 bool Near(QuicPacketSequenceNumber a, QuicPacketSequenceNumber b) {
   QuicPacketSequenceNumber delta = (a > b) ? a - b : b - a;
   return delta <= kMaxPacketGap;
 }
 
-
 // An alarm that is scheduled to send an ack if a timeout occurs.
 class AckAlarm : public QuicAlarm::Delegate {
  public:
   explicit AckAlarm(QuicConnection* connection)
       : connection_(connection) {
   }
 
   virtual QuicTime OnAlarm() OVERRIDE {
     connection_->SendAck();
     return QuicTime::Zero();
@@ skipping 50 matching lines @@
     // Never reschedule the alarm, since CheckForTimeout does that.
     return QuicTime::Zero();
   }
 
  private:
   QuicConnection* connection_;
 };
 
 // Indicates if any of the frames are intended to be sent with FORCE.
 // Returns FORCE when one of the frames is a CONNECTION_CLOSE_FRAME.
-net::QuicConnection::Force HasForcedFrames(
+QuicConnection::Force HasForcedFrames(
     const RetransmittableFrames* retransmittable_frames) {
   if (!retransmittable_frames) {
-    return net::QuicConnection::NO_FORCE;
+    return QuicConnection::NO_FORCE;
   }
   for (size_t i = 0; i < retransmittable_frames->frames().size(); ++i) {
     if (retransmittable_frames->frames()[i].type == CONNECTION_CLOSE_FRAME) {
-      return net::QuicConnection::FORCE;
+      return QuicConnection::FORCE;
     }
   }
-  return net::QuicConnection::NO_FORCE;
+  return QuicConnection::NO_FORCE;
 }
 
 }  // namespace
 
 #define ENDPOINT (is_server_ ? "Server: " : " Client: ")
 
 QuicConnection::QuicConnection(QuicGuid guid,
                                IPEndPoint address,
                                QuicConnectionHelperInterface* helper,
                                QuicPacketWriter* writer,
@@ skipping 660 matching lines @@
       (consumed_data.bytes_consumed == 0 && !consumed_data.fin_consumed)) {
     // No data was consumed, nor was a fin consumed, so delete the notifier.
     delete notifier;
   }
 
   return consumed_data;
 }
 
 void QuicConnection::SendRstStream(QuicStreamId id,
                                    QuicRstStreamErrorCode error) {
-  DVLOG(1) << "Sending RST_STREAM: " << id << " code: " << error;
   // Opportunistically bundle an ack with this outgoing packet.
   ScopedPacketBundler ack_bundler(this, true);
   packet_generator_.AddControlFrame(
       QuicFrame(new QuicRstStreamFrame(id, error)));
 }
 
 const QuicConnectionStats& QuicConnection::GetStats() {
   // Update rtt and estimated bandwidth.
   stats_.rtt = sent_packet_manager_.SmoothedRtt().ToMicroseconds();
   stats_.estimated_bandwidth =
@@ skipping 288 matching lines @@
              << " : " << (packet->is_fec_packet() ? "FEC " :
                  (retransmittable == HAS_RETRANSMITTABLE_DATA
                       ? "data bearing " : " ack only "))
              << ", encryption level: "
              << QuicUtils::EncryptionLevelToString(level)
              << ", length:" << packet->length() << ", encrypted length:"
              << encrypted->length();
   DVLOG(2) << ENDPOINT << "packet(" << sequence_number << "): " << std::endl
            << QuicUtils::StringToHexASCIIDump(packet->AsStringPiece());
 
-  DCHECK(encrypted->length() <= kMaxPacketSize)
+  DCHECK(encrypted->length() <= kMaxPacketSize ||
+         FLAGS_quic_allow_oversized_packets_for_test)
       << "Packet " << sequence_number << " will not be read; too large: "
       << packet->length() << " " << encrypted->length() << " "
       << " forced: " << (forced == FORCE ? "yes" : "no");
 
   DCHECK(pending_write_.get() == NULL);
   pending_write_.reset(new PendingWrite(sequence_number, transmission_type,
                                         retransmittable, level,
                                         packet->is_fec_packet(),
                                         packet->length()));
 
@@ skipping 434 matching lines @@
   if (timeout < overall_connection_timeout_) {
     overall_connection_timeout_ = timeout;
     CheckForTimeout();
   } else {
     overall_connection_timeout_ = timeout;
   }
 }
 
 bool QuicConnection::CheckForTimeout() {
   QuicTime now = clock_->ApproximateNow();
-  QuicTime time_of_last_packet = std::max(time_of_last_received_packet_,
-                                          time_of_last_sent_new_packet_);
+  QuicTime time_of_last_packet = max(time_of_last_received_packet_,
+                                     time_of_last_sent_new_packet_);
 
   // |delta| can be < 0 as |now| is approximate time but |time_of_last_packet|
   // is accurate time. However, this should not change the behavior of
   // timeout handling.
   QuicTime::Delta delta = now.Subtract(time_of_last_packet);
   DVLOG(1) << ENDPOINT << "last packet "
            << time_of_last_packet.ToDebuggingValue()
            << " now:" << now.ToDebuggingValue()
            << " delta:" << delta.ToMicroseconds()
            << " network_timeout: " << idle_network_timeout_.ToMicroseconds();
@@ skipping 52 matching lines @@
   // If we changed the generator's batch state, restore original batch state.
   if (!already_in_batch_mode_) {
     DVLOG(1) << "Leaving Batch Mode.";
     connection_->packet_generator_.FinishBatchOperations();
   }
   DCHECK_EQ(already_in_batch_mode_,
             connection_->packet_generator_.InBatchMode());
 }
 
 }  // namespace net