Log GOAWAY frame debug data.

net/spdy/buffered_spdy_framer_unittest.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 "net/spdy/spdy_test_util_common.h"
 #include "testing/platform_test.h"
 
 namespace net {
 
 namespace {
 
 class TestBufferedSpdyVisitor : public BufferedSpdyFramerVisitorInterface {
  public:
   explicit TestBufferedSpdyVisitor(SpdyMajorVersion spdy_version)
       : buffered_spdy_framer_(spdy_version, true),
         error_count_(0),
         setting_count_(0),
         syn_frame_count_(0),
         syn_reply_frame_count_(0),
         headers_frame_count_(0),
         push_promise_frame_count_(0),
+        goaway_count_(0),
         header_stream_id_(static_cast<SpdyStreamId>(-1)),
-        promised_stream_id_(static_cast<SpdyStreamId>(-1)) {
-  }
+        promised_stream_id_(static_cast<SpdyStreamId>(-1)) {}

[eroman, 2015/10/06 17:19:41]

unrelated side-note: seems like this would be cleaner to express as something
like MAX_SPDY_STREAM_ID. The signed --> unsigned conversion to accomplish this
is icky in my opinion.

[Bence, 2015/10/07 15:18:27]

Acknowledged.

 
   void OnError(SpdyFramer::SpdyError error_code) override {
     LOG(INFO) << "SpdyFramer Error: " << error_code;
     error_count_++;
   }
 
   void OnStreamError(SpdyStreamId stream_id,
                      const std::string& description) override {
     LOG(INFO) << "SpdyFramer Error on stream: " << stream_id  << " "
               << description;
@@ skipping 56 matching lines @@
   void OnSetting(SpdySettingsIds id, uint8 flags, uint32 value) override {
     setting_count_++;
   }
 
   void OnPing(SpdyPingId unique_id, bool is_ack) override {}
 
   void OnRstStream(SpdyStreamId stream_id,
                    SpdyRstStreamStatus status) override {}
 
   void OnGoAway(SpdyStreamId last_accepted_stream_id,
-                SpdyGoAwayStatus status) override {}
+                SpdyGoAwayStatus status,
+                StringPiece debug_data) override {
+    goaway_count_++;
+    goaway_last_accepted_stream_id_ = last_accepted_stream_id;
+    goaway_status_ = status;
+    goaway_debug_data_.assign(debug_data.data(), debug_data.size());
+  }
 
   bool OnCredentialFrameData(const char*, size_t) {
     LOG(FATAL) << "Unexpected OnCredentialFrameData call.";
     return false;
   }
 
   void OnDataFrameHeader(const SpdyFrame* frame) {
     LOG(FATAL) << "Unexpected OnDataFrameHeader call.";
   }
 
@@ skipping 41 matching lines @@
 
   BufferedSpdyFramer buffered_spdy_framer_;
 
   // Counters from the visitor callbacks.
   int error_count_;
   int setting_count_;
   int syn_frame_count_;
   int syn_reply_frame_count_;
   int headers_frame_count_;
   int push_promise_frame_count_;
+  int goaway_count_;
 
   // Header block streaming state:
   SpdyStreamId header_stream_id_;
   SpdyStreamId promised_stream_id_;
 
   // Headers from OnSyn, OnSynReply, OnHeaders and OnPushPromise for
   // verification.
   SpdyHeaderBlock headers_;
+
+  // OnGoAway parameters.
+  SpdyStreamId goaway_last_accepted_stream_id_;
+  SpdyGoAwayStatus goaway_status_;
+  std::string goaway_debug_data_;
 };
 
 }  // namespace
 
 class BufferedSpdyFramerTest
     : public PlatformTest,
       public ::testing::WithParamInterface<NextProto> {
  protected:
   // Returns true if the two header blocks have equivalent content.
   bool CompareHeaderBlocks(const SpdyHeaderBlock* expected,
@@ skipping 150 matching lines @@
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(0, visitor.syn_frame_count_);
   EXPECT_EQ(0, visitor.syn_reply_frame_count_);
   EXPECT_EQ(0, visitor.headers_frame_count_);
   EXPECT_EQ(1, visitor.push_promise_frame_count_);
   EXPECT_TRUE(CompareHeaderBlocks(&headers, &visitor.headers_));
   EXPECT_EQ(1u, visitor.header_stream_id_);
   EXPECT_EQ(2u, visitor.promised_stream_id_);
 }
 
+TEST_P(BufferedSpdyFramerTest, GoAwayDebugData) {
+  if (spdy_version() < HTTP2)
+    return;
+  BufferedSpdyFramer framer(spdy_version(), true);
+  scoped_ptr<SpdyFrame> goaway_frame(
+      framer.CreateGoAway(2u, GOAWAY_FRAME_SIZE_ERROR, "foo"));
+
+  TestBufferedSpdyVisitor visitor(spdy_version());
+  visitor.SimulateInFramer(
+      reinterpret_cast<unsigned char*>(goaway_frame.get()->data()),
+      goaway_frame.get()->size());
+  EXPECT_EQ(0, visitor.error_count_);
+  EXPECT_EQ(1, visitor.goaway_count_);
+  EXPECT_EQ(2u, visitor.goaway_last_accepted_stream_id_);
+  EXPECT_EQ(GOAWAY_FRAME_SIZE_ERROR, visitor.goaway_status_);
+  EXPECT_EQ("foo", visitor.goaway_debug_data_);
+}
+
 }  // namespace net