Move QUIC error code utility methods to quic_error_codes.{h,cc}, and rename them slightly. No beha…

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 848 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) << "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 1041 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);
   }
 
@@ skipping 57 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