relnote: n/a (changing DLOGs). Tidy up the DLOG messages on receipt of

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>
@@ skipping 889 matching lines @@
     group->UpdateFec(last_decrypted_packet_level_,
                      last_header_.packet_packet_number, fec);
   }
 }
 
 bool QuicConnection::OnRstStreamFrame(const QuicRstStreamFrame& frame) {
   DCHECK(connected_);
   if (debug_visitor_ != nullptr) {
     debug_visitor_->OnRstStreamFrame(frame);
   }
-  DVLOG(1) << ENDPOINT << "Stream reset with error "
+  DVLOG(1) << ENDPOINT
+           << "RST_STREAM_FRAME received for stream: " << frame.stream_id
+           << " with error: "
            << QuicUtils::StreamErrorToString(frame.error_code);
   if (FLAGS_quic_process_frames_inline) {
     visitor_->OnRstStream(frame);
     should_last_packet_instigate_acks_ = true;
   } else {
     last_rst_frames_.push_back(frame);
   }
   return connected_;
 }
 
 bool QuicConnection::OnConnectionCloseFrame(
     const QuicConnectionCloseFrame& frame) {
   DCHECK(connected_);
   if (debug_visitor_ != nullptr) {
     debug_visitor_->OnConnectionCloseFrame(frame);
   }
-  DVLOG(1) << ENDPOINT << "Connection " << connection_id()
-           << " closed with error "
-           << QuicUtils::ErrorToString(frame.error_code)
+  DVLOG(1) << ENDPOINT << "CONNECTION_CLOSE_FRAME received for connection: "
+           << connection_id()
+           << " with error: " << QuicUtils::ErrorToString(frame.error_code)
            << " " << frame.error_details;
   if (FLAGS_quic_process_frames_inline) {
     CloseConnection(frame.error_code, true);
   } else {
     last_close_frames_.push_back(frame);
   }
   return connected_;
 }
 
 bool QuicConnection::OnGoAwayFrame(const QuicGoAwayFrame& frame) {
   DCHECK(connected_);
   if (debug_visitor_ != nullptr) {
     debug_visitor_->OnGoAwayFrame(frame);
   }
-  DVLOG(1) << ENDPOINT << "Go away received with error "
-           << QuicUtils::ErrorToString(frame.error_code)
-           << " and reason:" << frame.reason_phrase;
+  DVLOG(1) << ENDPOINT << "GOAWAY_FRAME received with last good stream: "
+           << frame.last_good_stream_id
+           << " and error: " << QuicUtils::ErrorToString(frame.error_code)
+           << " and reason: " << frame.reason_phrase;
 
   goaway_received_ = true;
   if (FLAGS_quic_process_frames_inline) {
     visitor_->OnGoAway(frame);
     should_last_packet_instigate_acks_ = true;
   } else {
     last_goaway_frames_.push_back(frame);
   }
   return connected_;
 }
 
 bool QuicConnection::OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame) {
   DCHECK(connected_);
   if (debug_visitor_ != nullptr) {
     debug_visitor_->OnWindowUpdateFrame(frame);
   }
-  DVLOG(1) << ENDPOINT << "WindowUpdate received for stream: "
-           << frame.stream_id << " with byte offset: " << frame.byte_offset;
+  DVLOG(1) << ENDPOINT
+           << "WINDOW_UPDATE_FRAME received for stream: " << frame.stream_id
+           << " with byte offset: " << frame.byte_offset;
   if (FLAGS_quic_process_frames_inline) {
     visitor_->OnWindowUpdateFrame(frame);
     should_last_packet_instigate_acks_ = true;
   } else {
     last_window_update_frames_.push_back(frame);
   }
   return connected_;
 }
 
 bool QuicConnection::OnBlockedFrame(const QuicBlockedFrame& frame) {
   DCHECK(connected_);
   if (debug_visitor_ != nullptr) {
     debug_visitor_->OnBlockedFrame(frame);
   }
-  DVLOG(1) << ENDPOINT << "Blocked frame received for stream: "
-           << frame.stream_id;
+  DVLOG(1) << ENDPOINT
+           << "BLOCKED_FRAME received for stream: " << frame.stream_id;
   if (FLAGS_quic_process_frames_inline) {
     visitor_->OnBlockedFrame(frame);
     should_last_packet_instigate_acks_ = true;
   } else {
     last_blocked_frames_.push_back(frame);
   }
   return connected_;
 }
 
 void QuicConnection::OnPacketComplete() {
@@ skipping 1458 matching lines @@
       packet_number_of_last_sent_packet_ + packets_between_mtu_probes_ + 1;
   ++mtu_probe_count_;
 
   DVLOG(2) << "Sending a path MTU discovery packet #" << mtu_probe_count_;
   SendMtuDiscoveryPacket(mtu_discovery_target_);
 
   DCHECK(!mtu_discovery_alarm_->IsSet());
 }
 
 }  // namespace net