Log GOAWAY frame debug data.

net/spdy/buffered_spdy_framer.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/spdy/buffered_spdy_framer.h"
 
 #include "base/logging.h"
 
 namespace net {
 
+namespace {
+
+// GOAWAY frame debug data is only buffered up to this many bytes.
+size_t kGoAwayDebugDataMaxSize = 1024;
+
+}  // namespace
+
 SpdyMajorVersion NextProtoToSpdyMajorVersion(NextProto next_proto) {
   switch (next_proto) {
     case kProtoDeprecatedSPDY2:
       return SPDY2;
     case kProtoSPDY3:
     case kProtoSPDY31:
       return SPDY3;
     case kProtoHTTP2:
       return HTTP2;
     case kProtoUnknown:
@@ skipping 198 matching lines @@
 void BufferedSpdyFramer::OnPing(SpdyPingId unique_id, bool is_ack) {
   visitor_->OnPing(unique_id, is_ack);
 }
 
 void BufferedSpdyFramer::OnRstStream(SpdyStreamId stream_id,
                                      SpdyRstStreamStatus status) {
   visitor_->OnRstStream(stream_id, status);
 }
 void BufferedSpdyFramer::OnGoAway(SpdyStreamId last_accepted_stream_id,
                                   SpdyGoAwayStatus status) {
-  visitor_->OnGoAway(last_accepted_stream_id, status);
+  DCHECK(!goaway_fields_);
+  goaway_fields_.reset(new GoAwayFields());
+  goaway_fields_->last_accepted_stream_id = last_accepted_stream_id;
+  goaway_fields_->status = status;
+}
+
+bool BufferedSpdyFramer::OnGoAwayFrameData(const char* goaway_data,
+                                           size_t len) {
+  if (len > 0) {
+    goaway_fields_->debug_data.append(
+        goaway_data, std::min(len, kGoAwayDebugDataMaxSize -
+                                       goaway_fields_->debug_data.size()));

[eroman, 2015/10/07 17:00:51]

This looks correct.

However when first reading it I had to pause to consider whether the unsigned
subtraction (kGoAwayDebugDataMaxSize - goaway_fields_->debug_data.size()) could
ever underflow.

Consider wrapping it in:

if (goaway_fields_->debug_data.size() < kGoAwayDebugDataMaxSize) {
  ...
}

As a defensive measure in case goaway_fields_ is ever increased beyond the
maximum outside this function.

[Bence, 2015/10/30 11:55:27]

Done.

+    return true;
+  }
+  visitor_->OnGoAway(goaway_fields_->last_accepted_stream_id,
+                     goaway_fields_->status, goaway_fields_->debug_data);
+  goaway_fields_.reset();
+  return true;
 }
 
 void BufferedSpdyFramer::OnWindowUpdate(SpdyStreamId stream_id,
                                         int delta_window_size) {
   visitor_->OnWindowUpdate(stream_id, delta_window_size);
 }
 
 void BufferedSpdyFramer::OnPushPromise(SpdyStreamId stream_id,
                                        SpdyStreamId promised_stream_id,
                                        bool end) {
@@ skipping 107 matching lines @@
 SpdyFrame* BufferedSpdyFramer::CreatePingFrame(SpdyPingId unique_id,
                                                bool is_ack) const {
   SpdyPingIR ping_ir(unique_id);
   ping_ir.set_is_ack(is_ack);
   return spdy_framer_.SerializePing(ping_ir);
 }
 
 // TODO(jgraettinger): Eliminate uses of this method (prefer SpdyGoAwayIR).
 SpdyFrame* BufferedSpdyFramer::CreateGoAway(
     SpdyStreamId last_accepted_stream_id,
-    SpdyGoAwayStatus status) const {
-  SpdyGoAwayIR go_ir(last_accepted_stream_id, status, "");
+    SpdyGoAwayStatus status,
+    base::StringPiece debug_data) const {
+  SpdyGoAwayIR go_ir(last_accepted_stream_id, status, debug_data);
   return spdy_framer_.SerializeGoAway(go_ir);
 }
 
 // TODO(jgraettinger): Eliminate uses of this method (prefer SpdyHeadersIR).
 SpdyFrame* BufferedSpdyFramer::CreateHeaders(
     SpdyStreamId stream_id,
     SpdyControlFlags flags,
     SpdyPriority priority,
     const SpdyHeaderBlock* headers) {
   SpdyHeadersIR headers_ir(stream_id);
@@ skipping 42 matching lines @@
 
 void BufferedSpdyFramer::InitHeaderStreaming(SpdyStreamId stream_id) {
   memset(header_buffer_, 0, kHeaderBufferSize);
   header_buffer_used_ = 0;
   header_buffer_valid_ = true;
   header_stream_id_ = stream_id;
   DCHECK_NE(header_stream_id_, SpdyFramer::kInvalidStream);
 }
 
 }  // namespace net