Landing Recent QUIC changes until Mon Nov 14 04:43:50 2016 +0000

net/quic/core/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/core/quic_connection.h"
 
 #include <string.h>
 #include <sys/types.h>
 
 #include <algorithm>
@@ skipping 238 matching lines @@
       ping_alarm_(
           alarm_factory_->CreateAlarm(arena_.New<PingAlarmDelegate>(this),
                                       &arena_)),
       mtu_discovery_alarm_(alarm_factory_->CreateAlarm(
           arena_.New<MtuDiscoveryAlarmDelegate>(this),
           &arena_)),
       visitor_(nullptr),
       debug_visitor_(nullptr),
       packet_generator_(connection_id_,
                         &framer_,
-                        random_generator_,
                         helper->GetBufferAllocator(),
                         this),
       idle_network_timeout_(QuicTime::Delta::Infinite()),
       handshake_timeout_(QuicTime::Delta::Infinite()),
       time_of_last_received_packet_(clock_->ApproximateNow()),
       time_of_last_sent_new_packet_(clock_->ApproximateNow()),
       last_send_for_timeout_(clock_->ApproximateNow()),
       packet_number_of_last_sent_packet_(0),
       sent_packet_manager_(new QuicSentPacketManager(
           perspective,
@@ skipping 12 matching lines @@
       packets_between_mtu_probes_(kPacketsBetweenMtuProbesBase),
       next_mtu_probe_at_(kPacketsBetweenMtuProbesBase),
       largest_received_packet_size_(0),
       goaway_sent_(false),
       goaway_received_(false),
       multipath_enabled_(false),
       write_error_occured_(false) {
   DVLOG(1) << ENDPOINT
            << "Created connection with connection_id: " << connection_id;
   framer_.set_visitor(this);
-  framer_.set_received_entropy_calculator(&received_packet_manager_);
   if (!FLAGS_quic_receive_packet_once_decrypted) {
     last_stop_waiting_frame_.least_unacked = 0;
   }
   stats_.connection_creation_time = clock_->ApproximateNow();
   if (FLAGS_quic_enable_multipath) {
     sent_packet_manager_.reset(new QuicMultipathSentPacketManager(
         sent_packet_manager_.release(), this));
   }
   // TODO(ianswett): Supply the NetworkChangeVisitor as a constructor argument
   // and make it required non-null, because it's always used.
   sent_packet_manager_->SetNetworkChangeVisitor(this);
   // Allow the packet writer to potentially reduce the packet size to a value
   // even smaller than kDefaultMaxPacketSize.
   SetMaxPacketLength(perspective_ == Perspective::IS_SERVER
                          ? kDefaultServerMaxPacketSize
                          : kDefaultMaxPacketSize);
-  received_packet_manager_.SetVersion(version());
 }
 
 QuicConnection::~QuicConnection() {
   if (owns_writer_) {
     delete writer_;
   }
   ClearQueuedPackets();
 }
 
 void QuicConnection::ClearQueuedPackets() {
@@ skipping 173 matching lines @@
     case NEGOTIATED_VERSION:
       // Might be old packets that were sent by the client before the version
       // was negotiated. Drop these.
       return false;
 
     default:
       DCHECK(false);
   }
 
   version_negotiation_state_ = NEGOTIATED_VERSION;
-  received_packet_manager_.SetVersion(received_version);
   visitor_->OnSuccessfulVersionNegotiation(received_version);
   if (debug_visitor_ != nullptr) {
     debug_visitor_->OnSuccessfulVersionNegotiation(received_version);
   }
   DVLOG(1) << ENDPOINT << "version negotiated " << received_version;
 
   // Store the new version.
   framer_.set_version(received_version);
 
   // TODO(satyamshekhar): Store the packet number of this packet and close the
@@ skipping 42 matching lines @@
         "No common version found. Supported versions: {" +
             QuicVersionVectorToString(framer_.supported_versions()) +
             "}, peer supported versions: {" +
             QuicVersionVectorToString(packet.versions) + "}",
         ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
     return;
   }
 
   DVLOG(1) << ENDPOINT
            << "Negotiated version: " << QuicVersionToString(version());
-  received_packet_manager_.SetVersion(version());
   server_supported_versions_ = packet.versions;
   version_negotiation_state_ = NEGOTIATION_IN_PROGRESS;
   RetransmitUnackedPackets(ALL_UNACKED_RETRANSMISSION);
 }
 
 bool QuicConnection::OnUnauthenticatedPublicHeader(
     const QuicPacketPublicHeader& header) {
   if (header.connection_id == connection_id_) {
     return true;
   }
@@ skipping 148 matching lines @@
   if (error != nullptr) {
     CloseConnection(QUIC_INVALID_ACK_DATA, error,
                     ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
     return false;
   }
 
   if (send_alarm_->IsSet()) {
     send_alarm_->Cancel();
   }
   ProcessAckFrame(incoming_ack);
-  if (incoming_ack.is_truncated) {
-    should_last_packet_instigate_acks_ = true;
-  }
   // If the incoming ack's packets set expresses missing packets: peer is still
   // waiting for a packet lower than a packet that we are no longer planning to
   // send.
   // If the incoming ack's packets set expresses received packets: peer is still
   // acking packets which we never care about.
   // Send an ack to raise the high water mark.
   if (!incoming_ack.packets.Empty() &&
       GetLeastUnacked(incoming_ack.path_id) > incoming_ack.packets.Min()) {
     ++stop_waiting_count_;
   } else {
     stop_waiting_count_ = 0;
   }
 
   return connected_;
 }
 
 void QuicConnection::ProcessAckFrame(const QuicAckFrame& incoming_ack) {
   largest_seen_packet_with_ack_ = last_header_.packet_number;
   sent_packet_manager_->OnIncomingAck(incoming_ack,
                                       time_of_last_received_packet_);
-  if (version() <= QUIC_VERSION_33) {
-    sent_entropy_manager_.ClearEntropyBefore(
-        sent_packet_manager_->GetLeastPacketAwaitedByPeer(
-            incoming_ack.path_id) -
-        1);
-  }
   // Always reset the retransmission alarm when an ack comes in, since we now
   // have a better estimate of the current rtt than when it was set.
   SetRetransmissionAlarm();
 }
 
 void QuicConnection::ProcessStopWaitingFrame(
     const QuicStopWaitingFrame& stop_waiting) {
   largest_seen_packet_with_stop_waiting_ = last_header_.packet_number;
   received_packet_manager_.UpdatePacketInformationSentByPeer(stop_waiting);
 }
@@ skipping 57 matching lines @@
             << incoming_ack.largest_observed << " vs "
             << sent_packet_manager_->GetLargestObserved(incoming_ack.path_id)
             << " packet_number:" << last_header_.packet_number
             << " largest seen with ack:" << largest_seen_packet_with_ack_
             << " connection_id: " << connection_id_;
     // A new ack has a diminished largest_observed value.  Error out.
     // If this was an old packet, we wouldn't even have checked.
     return "Largest observed too low.";
   }
 
-  if (version() <= QUIC_VERSION_33) {
-    if (!incoming_ack.packets.Empty() &&
-        incoming_ack.packets.Max() > incoming_ack.largest_observed) {
-      LOG(WARNING) << ENDPOINT
-                   << "Peer sent missing packet: " << incoming_ack.packets.Max()
-                   << " which is greater than largest observed: "
-                   << incoming_ack.largest_observed;
-      return "Missing packet higher than largest observed.";
-    }
-
-    if (!incoming_ack.packets.Empty() &&
-        incoming_ack.packets.Min() <
-            sent_packet_manager_->GetLeastPacketAwaitedByPeer(
-                incoming_ack.path_id)) {
-      LOG(WARNING) << ENDPOINT
-                   << "Peer sent missing packet: " << incoming_ack.packets.Min()
-                   << " which is smaller than least_packet_awaited_by_peer_: "
-                   << sent_packet_manager_->GetLeastPacketAwaitedByPeer(
-                          incoming_ack.path_id);
-      return "Missing packet smaller than least awaited.";
-    }
-    if (!sent_entropy_manager_.IsValidEntropy(incoming_ack.largest_observed,
-                                              incoming_ack.packets,
-                                              incoming_ack.entropy_hash)) {
-      DLOG(WARNING) << ENDPOINT << "Peer sent invalid entropy."
-                    << " largest_observed:" << incoming_ack.largest_observed
-                    << " last_received:" << last_header_.packet_number;
-      return "Invalid entropy.";
-    }
-  } else {
-    if (!incoming_ack.packets.Empty() &&
-        incoming_ack.packets.Max() != incoming_ack.largest_observed) {
-      QUIC_BUG << ENDPOINT
-               << "Peer last received packet: " << incoming_ack.packets.Max()
-               << " which is not equal to largest observed: "
-               << incoming_ack.largest_observed;
-      return "Last received packet not equal to largest observed.";
-    }
+  if (!incoming_ack.packets.Empty() &&
+      incoming_ack.packets.Max() != incoming_ack.largest_observed) {
+    QUIC_BUG << ENDPOINT
+             << "Peer last received packet: " << incoming_ack.packets.Max()
+             << " which is not equal to largest observed: "
+             << incoming_ack.largest_observed;
+    return "Last received packet not equal to largest observed.";
   }
 
   return nullptr;
 }
 
 const char* QuicConnection::ValidateStopWaitingFrame(
     const QuicStopWaitingFrame& stop_waiting) {
   if (stop_waiting.least_unacked <
       received_packet_manager_.peer_least_packet_awaiting_ack()) {
     DLOG(ERROR) << ENDPOINT << "Peer's sent low least_unacked: "
@@ skipping 15 matching lines @@
 }
 
 bool QuicConnection::OnRstStreamFrame(const QuicRstStreamFrame& frame) {
   DCHECK(connected_);
   if (debug_visitor_ != nullptr) {
     debug_visitor_->OnRstStreamFrame(frame);
   }
   DVLOG(1) << ENDPOINT
            << "RST_STREAM_FRAME received for stream: " << frame.stream_id
            << " with error: "
-           << QuicUtils::StreamErrorToString(frame.error_code);
+           << QuicRstStreamErrorCodeToString(frame.error_code);
   visitor_->OnRstStream(frame);
   visitor_->PostProcessAfterData();
   should_last_packet_instigate_acks_ = true;
   return connected_;
 }
 
 bool QuicConnection::OnConnectionCloseFrame(
     const QuicConnectionCloseFrame& frame) {
   DCHECK(connected_);
   if (debug_visitor_ != nullptr) {
     debug_visitor_->OnConnectionCloseFrame(frame);
   }
   DVLOG(1) << ENDPOINT
            << "Received ConnectionClose for connection: " << connection_id()
-           << ", with error: " << QuicUtils::ErrorToString(frame.error_code)
+           << ", with error: " << QuicErrorCodeToString(frame.error_code)
            << " (" << frame.error_details << ")";
   if (frame.error_code == QUIC_BAD_MULTIPATH_FLAG) {
-    LOG(ERROR) << " quic_version: " << version()
+    LOG(ERROR) << "Unexpected QUIC_BAD_MULTIPATH_FLAG error."
                << " last_received_header: " << last_header_
                << " encryption_level: " << encryption_level_;
   }
   TearDownLocalConnectionState(frame.error_code, frame.error_details,
                                ConnectionCloseSource::FROM_PEER);
   return connected_;
 }
 
 bool QuicConnection::OnGoAwayFrame(const QuicGoAwayFrame& frame) {
   DCHECK(connected_);
   if (debug_visitor_ != nullptr) {
     debug_visitor_->OnGoAwayFrame(frame);
   }
   DVLOG(1) << ENDPOINT << "GOAWAY_FRAME received with last good stream: "
            << frame.last_good_stream_id
-           << " and error: " << QuicUtils::ErrorToString(frame.error_code)
+           << " and error: " << QuicErrorCodeToString(frame.error_code)
            << " and reason: " << frame.reason_phrase;
 
   goaway_received_ = true;
   visitor_->OnGoAway(frame);
   visitor_->PostProcessAfterData();
   should_last_packet_instigate_acks_ = true;
   return connected_;
 }
 
 bool QuicConnection::OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame) {
@@ skipping 73 matching lines @@
       ProcessStopWaitingFrame(last_stop_waiting_frame_);
       if (!connected_) {
         return;
       }
     }
 
     MaybeQueueAck(was_missing);
   }
 
   ClearLastFrames();
-  MaybeCloseIfTooManyOutstandingPackets();
 }
 
 void QuicConnection::MaybeQueueAck(bool was_missing) {
   ++num_packets_received_since_last_ack_sent_;
   // Always send an ack every 20 packets in order to allow the peer to discard
   // information from the SentPacketManager and provide an RTT measurement.
   if (num_packets_received_since_last_ack_sent_ >=
       kMaxPacketsReceivedBeforeAckSend) {
     ack_queued_ = true;
   }
@@ skipping 53 matching lines @@
   }
 }
 
 void QuicConnection::ClearLastFrames() {
   should_last_packet_instigate_acks_ = false;
   if (!FLAGS_quic_receive_packet_once_decrypted) {
     last_stop_waiting_frame_.least_unacked = 0;
   }
 }
 
-void QuicConnection::MaybeCloseIfTooManyOutstandingPackets() {
-  if (version() > QUIC_VERSION_33) {
-    return;
-  }
-  // This occurs if we don't discard old packets we've sent fast enough.
-  // It's possible largest observed is less than least unacked.
-  if (sent_packet_manager_->GetLargestObserved(last_header_.path_id) >
-      (sent_packet_manager_->GetLeastUnacked(last_header_.path_id) +
-       kMaxTrackedPackets)) {
-    CloseConnection(
-        QUIC_TOO_MANY_OUTSTANDING_SENT_PACKETS,
-        StringPrintf("More than %" PRIu64 " outstanding.", kMaxTrackedPackets),
-        ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
-  }
-  // This occurs if there are received packet gaps and the peer does not raise
-  // the least unacked fast enough.
-  if (received_packet_manager_.NumTrackedPackets() > kMaxTrackedPackets) {
-    CloseConnection(
-        QUIC_TOO_MANY_OUTSTANDING_RECEIVED_PACKETS,
-        StringPrintf("More than %" PRIu64 " outstanding.", kMaxTrackedPackets),
-        ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
-  }
-}
-
 const QuicFrame QuicConnection::GetUpdatedAckFrame() {
   return received_packet_manager_.GetUpdatedAckFrame(clock_->ApproximateNow());
 }
 
 void QuicConnection::PopulateStopWaitingFrame(
     QuicStopWaitingFrame* stop_waiting) {
   stop_waiting->least_unacked = GetLeastUnacked(stop_waiting->path_id);
-  if (version() <= QUIC_VERSION_33) {
-    stop_waiting->entropy_hash = sent_entropy_manager_.GetCumulativeEntropy(
-        stop_waiting->least_unacked - 1);
-  }
 }
 
 QuicPacketNumber QuicConnection::GetLeastUnacked(QuicPathId path_id) const {
   return sent_packet_manager_->GetLeastUnacked(path_id);
 }
 
 void QuicConnection::MaybeSendInResponseToPacket() {
   if (!connected_) {
     return;
   }
@@ skipping 312 matching lines @@
                          " without version flag before version negotiated.",
                          ENDPOINT, header.packet_number);
         DLOG(WARNING) << error_details;
         CloseConnection(QUIC_INVALID_VERSION, error_details,
                         ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
         return false;
       } else {
         DCHECK_EQ(1u, header.public_header.versions.size());
         DCHECK_EQ(header.public_header.versions[0], version());
         version_negotiation_state_ = NEGOTIATED_VERSION;
-        received_packet_manager_.SetVersion(version());
         visitor_->OnSuccessfulVersionNegotiation(version());
         if (debug_visitor_ != nullptr) {
           debug_visitor_->OnSuccessfulVersionNegotiation(version());
         }
       }
     } else {
       DCHECK(!header.public_header.version_flag);
       // If the client gets a packet without the version flag from the server
       // it should stop sending version since the version negotiation is done.
       packet_generator_.StopSendingVersion();
       version_negotiation_state_ = NEGOTIATED_VERSION;
-      received_packet_manager_.SetVersion(version());
       visitor_->OnSuccessfulVersionNegotiation(version());
       if (debug_visitor_ != nullptr) {
         debug_visitor_->OnSuccessfulVersionNegotiation(version());
       }
     }
   }
 
   DCHECK_EQ(NEGOTIATED_VERSION, version_negotiation_state_);
 
   if (last_size_ > largest_received_packet_size_) {
@@ skipping 186 matching lines @@
     visitor_->OnWriteBlocked();
     // If the socket buffers the the data, then the packet should not
     // be queued and sent again, which would result in an unnecessary
     // duplicate packet being sent.  The helper must call OnCanWrite
     // when the write completes, and OnWriteError if an error occurs.
     if (!writer_->IsWriteBlockedDataBuffered()) {
       return false;
     }
   }
 
-  if (FLAGS_quic_only_track_sent_packets) {
-    // In some cases, an MTU probe can cause EMSGSIZE. This indicates that the
-    // MTU discovery is permanently unsuccessful.
-    if (result.status == WRITE_STATUS_ERROR &&
-        result.error_code == kMessageTooBigErrorCode &&
-        packet->retransmittable_frames.empty() &&
-        packet->encrypted_length > long_term_mtu_) {
-      mtu_discovery_target_ = 0;
-      mtu_discovery_alarm_->Cancel();
-      // The write failed, but the writer is not blocked, so return true.
-      return true;
-    }
+  // In some cases, an MTU probe can cause EMSGSIZE. This indicates that the
+  // MTU discovery is permanently unsuccessful.
+  if (result.status == WRITE_STATUS_ERROR &&
+      result.error_code == kMessageTooBigErrorCode &&
+      packet->retransmittable_frames.empty() &&
+      packet->encrypted_length > long_term_mtu_) {
+    mtu_discovery_target_ = 0;
+    mtu_discovery_alarm_->Cancel();
+    // The write failed, but the writer is not blocked, so return true.
+    return true;
+  }
 
-    if (result.status == WRITE_STATUS_ERROR) {
-      OnWriteError(result.error_code);
-      DLOG(ERROR) << ENDPOINT << "failed writing " << encrypted_length
-                  << " from host "
-                  << (self_address().address().empty()
-                          ? " empty address "
-                          : self_address().ToStringWithoutPort())
-                  << " to address " << peer_address().ToString()
-                  << " with error code " << result.error_code;
-      return false;
-    }
+  if (result.status == WRITE_STATUS_ERROR) {
+    OnWriteError(result.error_code);
+    DLOG(ERROR) << ENDPOINT << "failed writing " << encrypted_length
+                << " from host " << (self_address().address().empty()
+                                         ? " empty address "
+                                         : self_address().ToStringWithoutPort())
+                << " to address " << peer_address().ToString()
+                << " with error code " << result.error_code;
+    return false;
   }
 
   if (result.status != WRITE_STATUS_ERROR && debug_visitor_ != nullptr) {
     // Pass the write result to the visitor.
     debug_visitor_->OnPacketSent(*packet, packet->original_path_id,
                                  packet->original_packet_number,
                                  packet->transmission_type, packet_send_time);
   }
   if (packet->transmission_type == NOT_RETRANSMISSION) {
     time_of_last_sent_new_packet_ = packet_send_time;
@@ skipping 25 matching lines @@
       sent_packet_manager_->GetLeastUnacked(packet->path_id),
       sent_packet_manager_->EstimateMaxPacketsInFlight(max_packet_length()));
 
   stats_.bytes_sent += result.bytes_written;
   ++stats_.packets_sent;
   if (packet->transmission_type != NOT_RETRANSMISSION) {
     stats_.bytes_retransmitted += result.bytes_written;
     ++stats_.packets_retransmitted;
   }
 
-  if (!FLAGS_quic_only_track_sent_packets) {
-    // In some cases, an MTU probe can cause EMSGSIZE. This indicates that the
-    // MTU discovery is permanently unsuccessful.
-    if (result.status == WRITE_STATUS_ERROR &&
-        result.error_code == kMessageTooBigErrorCode &&
-        packet->retransmittable_frames.empty() &&
-        packet->encrypted_length > long_term_mtu_) {
-      mtu_discovery_target_ = 0;
-      mtu_discovery_alarm_->Cancel();
-      return true;
-    }
-
-    if (result.status == WRITE_STATUS_ERROR) {
-      OnWriteError(result.error_code);
-      DLOG(ERROR) << ENDPOINT << "failed writing " << encrypted_length
-                  << " from host "
-                  << (self_address().address().empty()
-                          ? " empty address "
-                          : self_address().ToStringWithoutPort())
-                  << " to address " << peer_address().ToString()
-                  << " with error code " << result.error_code;
-      return false;
-    }
-  }
-
   return true;
 }
 
 bool QuicConnection::ShouldDiscardPacket(const SerializedPacket& packet) {
   if (!connected_) {
     DVLOG(1) << ENDPOINT << "Not sending packet as connection is disconnected.";
     return true;
   }
 
   QuicPacketNumber packet_number = packet.packet_number;
@@ skipping 92 matching lines @@
     ack_alarm_->Update(clock_->ApproximateNow(), QuicTime::Delta::Zero());
   }
 }
 
 void QuicConnection::SendOrQueuePacket(SerializedPacket* packet) {
   // The caller of this function is responsible for checking CanWrite().
   if (packet->encrypted_buffer == nullptr) {
     QUIC_BUG << "packet.encrypted_buffer == nullptr in to SendOrQueuePacket";
     return;
   }
-  if (version() <= QUIC_VERSION_33) {
-    sent_entropy_manager_.RecordPacketEntropyHash(packet->packet_number,
-                                                  packet->entropy_hash);
-  }
   // If there are already queued packets, queue this one immediately to ensure
   // it's written in sequence number order.
   if (!queued_packets_.empty() || !WritePacket(packet)) {
     // Take ownership of the underlying encrypted packet.
     packet->encrypted_buffer = QuicUtils::CopyBuffer(*packet);
     queued_packets_.push_back(*packet);
     packet->retransmittable_frames.clear();
   }
 
   QuicUtils::ClearSerializedPacket(packet);
@@ skipping 141 matching lines @@
     QuicErrorCode error,
     const string& error_details,
     ConnectionCloseBehavior connection_close_behavior) {
   DCHECK(!error_details.empty());
   if (!connected_) {
     DVLOG(1) << "Connection is already closed.";
     return;
   }
 
   DVLOG(1) << ENDPOINT << "Closing connection: " << connection_id()
-           << ", with error: " << QuicUtils::ErrorToString(error) << " ("
-           << error << "), and details:  " << error_details;
+           << ", with error: " << QuicErrorCodeToString(error) << " (" << error
+           << "), and details:  " << error_details;
 
   if (connection_close_behavior ==
       ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET) {
     SendConnectionClosePacket(error, error_details, SEND_ACK);
   } else if (connection_close_behavior ==
              ConnectionCloseBehavior::
                  SEND_CONNECTION_CLOSE_PACKET_WITH_NO_ACK) {
     SendConnectionClosePacket(error, error_details, NO_ACK);
   }
 
-  TearDownLocalConnectionState(error, error_details,
-                               ConnectionCloseSource::FROM_SELF);
+  ConnectionCloseSource source = ConnectionCloseSource::FROM_SELF;
+  if (perspective_ == Perspective::IS_CLIENT &&
+      error == QUIC_CRYPTO_HANDSHAKE_STATELESS_REJECT) {
+    // Regard stateless rejected connection as closed by server.
+    source = ConnectionCloseSource::FROM_PEER;
+  }
+  TearDownLocalConnectionState(error, error_details, source);
 }
 
 void QuicConnection::SendConnectionClosePacket(QuicErrorCode error,
                                                const string& details,
                                                AckBundling ack_mode) {
   DVLOG(1) << ENDPOINT << "Sending connection close packet.";
   ClearQueuedPackets();
   ScopedPacketBundler ack_bundler(this, ack_mode);
   QuicConnectionCloseFrame* frame = new QuicConnectionCloseFrame();
   frame->error_code = error;
@@ skipping 40 matching lines @@
 
 void QuicConnection::SendGoAway(QuicErrorCode error,
                                 QuicStreamId last_good_stream_id,
                                 const string& reason) {
   if (goaway_sent_) {
     return;
   }
   goaway_sent_ = true;
 
   DVLOG(1) << ENDPOINT << "Going away with error "
-           << QuicUtils::ErrorToString(error) << " (" << error << ")";
+           << QuicErrorCodeToString(error) << " (" << error << ")";
 
   // Opportunistically bundle an ack with this outgoing packet.
   ScopedPacketBundler ack_bundler(this, SEND_ACK_IF_PENDING);
   packet_generator_.AddControlFrame(
       QuicFrame(new QuicGoAwayFrame(error, last_good_stream_id, reason)));
 }
 
 QuicByteCount QuicConnection::max_packet_length() const {
   return packet_generator_.GetCurrentMaxPacketLength();
 }
@@ skipping 425 matching lines @@
 
 void QuicConnection::CheckIfApplicationLimited() {
   if (queued_packets_.empty() &&
       !sent_packet_manager_->HasPendingRetransmissions() &&
       !visitor_->WillingAndAbleToWrite()) {
     sent_packet_manager_->OnApplicationLimited();
   }
 }
 
 }  // namespace net