Add NetLog event for invalid Http/2 response header

net/spdy/chromium/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/chromium/buffered_spdy_framer.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/logging.h"
+#include "net/log/net_log_with_source.h"
 #include "net/spdy/chromium/spdy_test_util_common.h"
 #include "testing/platform_test.h"
 
 namespace net {
 
 namespace {
 
 class TestBufferedSpdyVisitor : public BufferedSpdyFramerVisitorInterface {
  public:
   TestBufferedSpdyVisitor()
-      : buffered_spdy_framer_(),
+      : buffered_spdy_framer_(NetLogWithSource()),
         error_count_(0),
         setting_count_(0),
         headers_frame_count_(0),
         push_promise_frame_count_(0),
         goaway_count_(0),
         altsvc_count_(0),
         header_stream_id_(static_cast<SpdyStreamId>(-1)),
         promised_stream_id_(static_cast<SpdyStreamId>(-1)) {}
 
   void OnError(SpdyFramer::SpdyFramerError spdy_framer_error) override {
@@ skipping 159 matching lines @@
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(2, visitor.setting_count_);
 }
 
 TEST_F(BufferedSpdyFramerTest, HeaderListTooLarge) {
   SpdyHeaderBlock headers;
   SpdyString long_header_value(256 * 1024, 'x');
   headers["foo"] = long_header_value;
   SpdyHeadersIR headers_ir(/*stream_id=*/1, std::move(headers));
 
-  BufferedSpdyFramer framer;
+  NetLogWithSource net_log;
+  BufferedSpdyFramer framer(net_log);
   SpdySerializedFrame control_frame = framer.SerializeFrame(headers_ir);
 
   TestBufferedSpdyVisitor visitor;
   visitor.SimulateInFramer(control_frame);
 
   EXPECT_EQ(1, visitor.error_count_);
   EXPECT_EQ(0, visitor.headers_frame_count_);
   EXPECT_EQ(0, visitor.push_promise_frame_count_);
   EXPECT_EQ(SpdyHeaderBlock(), visitor.headers_);
 }
@@ skipping 20 matching lines @@
   EXPECT_EQ(1, visitor.error_count_);
   EXPECT_EQ(1, visitor.headers_frame_count_);
 }
 
 TEST_F(BufferedSpdyFramerTest, ReadHeadersHeaderBlock) {
   SpdyHeaderBlock headers;
   headers["alpha"] = "beta";
   headers["gamma"] = "delta";
   SpdyHeadersIR headers_ir(/*stream_id=*/1, headers.Clone());
 
-  BufferedSpdyFramer framer;
+  NetLogWithSource net_log;
+  BufferedSpdyFramer framer(net_log);
   SpdySerializedFrame control_frame = framer.SerializeFrame(headers_ir);
 
   TestBufferedSpdyVisitor visitor;
   visitor.SimulateInFramer(control_frame);
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_EQ(0, visitor.push_promise_frame_count_);
   EXPECT_EQ(headers, visitor.headers_);
 }
 
 TEST_F(BufferedSpdyFramerTest, ReadPushPromiseHeaderBlock) {
   SpdyHeaderBlock headers;
   headers["alpha"] = "beta";
   headers["gamma"] = "delta";
-  BufferedSpdyFramer framer;
+  NetLogWithSource net_log;
+  BufferedSpdyFramer framer(net_log);
   SpdyPushPromiseIR push_promise_ir(/*stream_id=*/1, /*promised_stream_id=*/2,
                                     headers.Clone());
   SpdySerializedFrame control_frame = framer.SerializeFrame(push_promise_ir);
 
   TestBufferedSpdyVisitor visitor;
   visitor.SimulateInFramer(control_frame);
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(0, visitor.headers_frame_count_);
   EXPECT_EQ(1, visitor.push_promise_frame_count_);
   EXPECT_EQ(headers, visitor.headers_);
   EXPECT_EQ(1u, visitor.header_stream_id_);
   EXPECT_EQ(2u, visitor.promised_stream_id_);
 }
 
 TEST_F(BufferedSpdyFramerTest, GoAwayDebugData) {
   SpdyGoAwayIR go_ir(/*last_accepted_stream_id=*/2, ERROR_CODE_FRAME_SIZE_ERROR,
                      "foo");
-  BufferedSpdyFramer framer;
+  NetLogWithSource net_log;
+  BufferedSpdyFramer framer(net_log);
   SpdySerializedFrame goaway_frame = framer.SerializeFrame(go_ir);
 
   TestBufferedSpdyVisitor visitor;
   visitor.SimulateInFramer(goaway_frame);
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.goaway_count_);
   EXPECT_EQ(2u, visitor.goaway_last_accepted_stream_id_);
   EXPECT_EQ(ERROR_CODE_FRAME_SIZE_ERROR, visitor.goaway_error_code_);
   EXPECT_EQ("foo", visitor.goaway_debug_data_);
 }
 
 // ALTSVC frame on stream 0 must have an origin.
 TEST_F(BufferedSpdyFramerTest, OnAltSvcOnStreamZero) {
   const SpdyStreamId altsvc_stream_id(0);
   SpdyAltSvcIR altsvc_ir(altsvc_stream_id);
   SpdyAltSvcWireFormat::AlternativeService alternative_service(
       "quic", "alternative.example.org", 443, 86400,
       SpdyAltSvcWireFormat::VersionVector());
   altsvc_ir.add_altsvc(alternative_service);
   const char altsvc_origin[] = "https://www.example.org";
   altsvc_ir.set_origin(altsvc_origin);
-  BufferedSpdyFramer framer;
+  NetLogWithSource net_log;
+  BufferedSpdyFramer framer(net_log);
   SpdySerializedFrame altsvc_frame(framer.SerializeFrame(altsvc_ir));
 
   TestBufferedSpdyVisitor visitor;
   visitor.SimulateInFramer(altsvc_frame);
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.altsvc_count_);
   EXPECT_EQ(altsvc_stream_id, visitor.altsvc_stream_id_);
   EXPECT_EQ(altsvc_origin, visitor.altsvc_origin_);
   ASSERT_EQ(1u, visitor.altsvc_vector_.size());
   EXPECT_EQ(alternative_service, visitor.altsvc_vector_[0]);
 }
 
 // ALTSVC frame on a non-zero stream must not have an origin.
 TEST_F(BufferedSpdyFramerTest, OnAltSvcOnNonzeroStream) {
   const SpdyStreamId altsvc_stream_id(1);
   SpdyAltSvcIR altsvc_ir(altsvc_stream_id);
   SpdyAltSvcWireFormat::AlternativeService alternative_service(
       "quic", "alternative.example.org", 443, 86400,
       SpdyAltSvcWireFormat::VersionVector());
   altsvc_ir.add_altsvc(alternative_service);
-  BufferedSpdyFramer framer;
+  NetLogWithSource net_log;
+  BufferedSpdyFramer framer(net_log);
   SpdySerializedFrame altsvc_frame(framer.SerializeFrame(altsvc_ir));
 
   TestBufferedSpdyVisitor visitor;
   visitor.SimulateInFramer(altsvc_frame);
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.altsvc_count_);
   EXPECT_EQ(altsvc_stream_id, visitor.altsvc_stream_id_);
   EXPECT_TRUE(visitor.altsvc_origin_.empty());
   ASSERT_EQ(1u, visitor.altsvc_vector_.size());
   EXPECT_EQ(alternative_service, visitor.altsvc_vector_[0]);
 }
 
 }  // namespace net