Add Http2FrameDecoderAdapter.

net/spdy/spdy_framer_test.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/spdy_framer.h"
 
 #include <stdlib.h>
 #include <string.h>
 
 #include <algorithm>
@@ skipping 595 matching lines @@
   reader.ReadUInt8(&serialized_type);
   SpdyFrameType type = SpdyConstants::ParseFrameType(serialized_type);
   DCHECK_EQ(HEADERS, type);
   uint8_t flags;
   reader.ReadUInt8(&flags);
 
   return StringPiece(frame.data() + framer.GetHeadersMinimumSize(),
                      frame.size() - framer.GetHeadersMinimumSize());
 }
 
-enum DecoderChoice { DECODER_SELF, DECODER_NESTED };
+enum DecoderChoice { DECODER_SELF, DECODER_NESTED, DECODER_HTTP2 };
 enum HpackChoice { HPACK_DECODER_1, HPACK_DECODER_2 };
 
 class SpdyFramerTest
     : public ::testing::TestWithParam<std::tuple<DecoderChoice, HpackChoice>> {
  protected:
   void SetUp() override {
     auto param = GetParam();
     switch (std::get<0>(param)) {
       case DECODER_SELF:
         FLAGS_use_nested_spdy_framer_decoder = false;
+        FLAGS_use_http2_frame_decoder_adapter = false;
         break;
       case DECODER_NESTED:
         FLAGS_use_nested_spdy_framer_decoder = true;
+        FLAGS_use_http2_frame_decoder_adapter = false;
+        break;
+      case DECODER_HTTP2:
+        FLAGS_use_nested_spdy_framer_decoder = false;
+        FLAGS_use_http2_frame_decoder_adapter = true;
         break;
     }
     switch (std::get<1>(param)) {
       case HPACK_DECODER_1:
         FLAGS_chromium_http2_flag_spdy_use_hpack_decoder2 = false;
         break;
       case HPACK_DECODER_2:
         FLAGS_chromium_http2_flag_spdy_use_hpack_decoder2 = true;
         break;
     }
@@ skipping 14 matching lines @@
                      const SpdySerializedFrame& actual_frame) {
     CompareCharArraysWithHexError(
         description,
         reinterpret_cast<const unsigned char*>(expected_frame.data()),
         expected_frame.size(),
         reinterpret_cast<const unsigned char*>(actual_frame.data()),
         actual_frame.size());
   }
 };
 
-INSTANTIATE_TEST_CASE_P(
-    SpdyFramerTests,
-    SpdyFramerTest,
-    ::testing::Combine(::testing::Values(DECODER_SELF, DECODER_NESTED),
-                       ::testing::Values(HPACK_DECODER_1, HPACK_DECODER_2)));
+INSTANTIATE_TEST_CASE_P(SpdyFramerTests,
+                        SpdyFramerTest,
+                        ::testing::Combine(::testing::Values(DECODER_SELF,
+                                                             DECODER_NESTED,
+                                                             DECODER_HTTP2),
+                                           ::testing::Values(HPACK_DECODER_1,
+                                                             HPACK_DECODER_2)));
 
 // Test that we can encode and decode a SpdyHeaderBlock in serialized form.
 TEST_P(SpdyFramerTest, HeaderBlockInBuffer) {
   SpdyFramer framer;
   framer.set_enable_compression(false);
 
   // Encode the header block into a Headers frame.
   SpdyHeadersIR headers(1);
   headers.SetHeader("alpha", "beta");
   headers.SetHeader("gamma", "charlie");
@@ skipping 447 matching lines @@
 // signal SPDY_INVALID_STREAM_ID.
 TEST_P(SpdyFramerTest, PushPromiseWithPromisedStreamIdZero) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer;
   framer.set_visitor(&visitor);
 
   SpdyPushPromiseIR push_promise(3, 0);
   push_promise.SetHeader("alpha", "beta");
   SpdySerializedFrame frame(framer.SerializePushPromise(push_promise));
 
-  // We shouldn't have to read the whole frame before we signal an error.
   EXPECT_CALL(visitor, OnError(testing::Eq(&framer)));
-  EXPECT_GT(frame.size(), framer.ProcessInput(frame.data(), frame.size()));
+  framer.ProcessInput(frame.data(), frame.size());
   EXPECT_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 TEST_P(SpdyFramerTest, DuplicateHeader) {
   SpdyFramer framer;
   // Frame builder with plentiful buffer size.
   SpdyFrameBuilder frame(1024);
   frame.BeginNewFrame(framer, HEADERS, 0, 3);
@@ skipping 1638 matching lines @@
       framer.GetFrameHeaderSize());
   // Zero-len settings frames are permitted as of HTTP/2.
   EXPECT_EQ(0, visitor.error_count_);
 }
 
 // Tests handling of SETTINGS frames with invalid length.
 TEST_P(SpdyFramerTest, ReadBogusLenSettingsFrame) {
   SpdyFramer framer;
   SpdySettingsIR settings_ir;
 
-  // Add a setting to pad the frame so that we don't get a buffer overflow when
-  // calling SimulateInFramer() below.
+  // Add settings to more than fill the frame so that we don't get a buffer
+  // overflow when calling SimulateInFramer() below.  These settings must be
+  // distinct parameters because SpdySettingsIR has a map for settings, and will
+  // collapse multiple copies of the same parameter.
   settings_ir.AddSetting(SETTINGS_INITIAL_WINDOW_SIZE, false, false,
                          0x00000002);
+  settings_ir.AddSetting(SETTINGS_MAX_CONCURRENT_STREAMS, false, false,
+                         0x00000002);
   SpdySerializedFrame control_frame(framer.SerializeSettings(settings_ir));
-  const size_t kNewLength = 14;
+  const size_t kNewLength = 8;
   SetFrameLength(&control_frame, kNewLength);
   TestSpdyVisitor visitor;
   visitor.use_compression_ = false;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.data()),
       framer.GetFrameHeaderSize() + kNewLength);
   // Should generate an error, since its not possible to have a
   // settings frame of length kNewLength.
   EXPECT_EQ(1, visitor.error_count_);
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_SIZE,
@@ skipping 1553 matching lines @@
 
     EXPECT_EQ(1, visitor->data_frame_count_);
     EXPECT_EQ(strlen(four_score), static_cast<unsigned>(visitor->data_bytes_));
     EXPECT_EQ(0, visitor->headers_frame_count_);
   }
 }
 
 }  // namespace test
 
 }  // namespace net