Add HpackDecoder3, an adapter using HpackDecoder (in net/http2/hpack/decoder).

net/quic/core/quic_headers_stream_test.cc

 // Copyright 2013 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/core/quic_headers_stream.h"
 
 #include <cstdint>
 #include <ostream>
 #include <string>
 #include <tuple>
@@ skipping 22 matching lines @@
 using testing::AtLeast;
 using testing::HasSubstr;
 using testing::InSequence;
 using testing::Invoke;
 using testing::Return;
 using testing::StrictMock;
 using testing::WithArgs;
 
 // TODO(bnc): Merge these correctly.
 bool FLAGS_use_http2_frame_decoder_adapter;
-bool FLAGS_spdy_use_hpack_decoder2;
 bool FLAGS_spdy_framer_use_new_methods4;
 
 namespace net {
 namespace test {
 
 class MockQuicHpackDebugVisitor : public QuicHpackDebugVisitor {
  public:
   MockQuicHpackDebugVisitor() : QuicHpackDebugVisitor() {}
 
   MOCK_METHOD1(OnUseEntry, void(QuicTime::Delta elapsed));
@@ skipping 92 matching lines @@
     case HTTP2_DECODER_SPDY:
       return os << "SPDY";
     case HTTP2_DECODER_NESTED_SPDY:
       return os << "NESTED_SPDY";
     case HTTP2_DECODER_NEW:
       return os << "NEW";
   }
   return os;
 }
 
-enum HpackDecoderChoice { HPACK_DECODER_SPDY, HPACK_DECODER_NEW };
+enum HpackDecoderChoice { HPACK_DECODER_SPDY, HPACK_DECODER2, HPACK_DECODER3 };
 std::ostream& operator<<(std::ostream& os, HpackDecoderChoice v) {
   switch (v) {
     case HPACK_DECODER_SPDY:
       return os << "SPDY";
-    case HPACK_DECODER_NEW:
-      return os << "NEW";
+    case HPACK_DECODER2:
+      return os << "HPACK_DECODER2";
+    case HPACK_DECODER3:
+      return os << "HPACK_DECODER3";
   }
   return os;
 }
 
 typedef testing::
     tuple<QuicVersion, Perspective, Http2DecoderChoice, HpackDecoderChoice>
         TestParamsTuple;
 
 struct TestParams {
   explicit TestParams(TestParamsTuple params)
@@ skipping 13 matching lines @@
       case HTTP2_DECODER_NEW:
         FLAGS_use_nested_spdy_framer_decoder = false;
         FLAGS_use_http2_frame_decoder_adapter = true;
         // Http2FrameDecoderAdapter needs the new header methods, else
         // --use_http2_frame_decoder_adapter=true will be ignored.
         FLAGS_spdy_framer_use_new_methods4 = true;
         break;
     }
     switch (hpack_decoder) {
       case HPACK_DECODER_SPDY:
-        FLAGS_spdy_use_hpack_decoder2 = false;
+        FLAGS_chromium_http2_flag_spdy_use_hpack_decoder2 = false;
+        FLAGS_chromium_http2_flag_spdy_use_hpack_decoder3 = false;
         break;
-      case HPACK_DECODER_NEW:
-        FLAGS_spdy_use_hpack_decoder2 = true;
-        // Needs new header methods to be used.
-        FLAGS_spdy_framer_use_new_methods4 = true;
+      case HPACK_DECODER2:
+        FLAGS_chromium_http2_flag_spdy_use_hpack_decoder2 = true;
+        FLAGS_chromium_http2_flag_spdy_use_hpack_decoder3 = false;
+        break;
+      case HPACK_DECODER3:
+        FLAGS_chromium_http2_flag_spdy_use_hpack_decoder2 = false;
+        FLAGS_chromium_http2_flag_spdy_use_hpack_decoder3 = true;
         break;
     }
     QUIC_LOG(INFO) << "TestParams: version: " << QuicVersionToString(version)
                    << ", perspective: " << perspective
                    << ", http2_decoder: " << http2_decoder
                    << ", hpack_decoder: " << hpack_decoder;
   }
 
   QuicVersion version;
   Perspective perspective;
@@ skipping 196 matching lines @@
 // HTTP/2 and HPACK decoder.
 INSTANTIATE_TEST_CASE_P(
     Tests,
     QuicHeadersStreamTest,
     ::testing::Combine(
         ::testing::ValuesIn(AllSupportedVersions()),
         ::testing::Values(Perspective::IS_CLIENT, Perspective::IS_SERVER),
         ::testing::Values(HTTP2_DECODER_SPDY,
                           HTTP2_DECODER_NESTED_SPDY,
                           HTTP2_DECODER_NEW),
-        ::testing::Values(HPACK_DECODER_SPDY, HPACK_DECODER_NEW)));
+        ::testing::Values(HPACK_DECODER_SPDY, HPACK_DECODER2, HPACK_DECODER3)));
 
 TEST_P(QuicHeadersStreamTest, StreamId) {
   EXPECT_EQ(3u, headers_stream_->id());
 }
 
 TEST_P(QuicHeadersStreamTest, WriteHeaders) {
   for (QuicStreamId stream_id = kClientDataStreamId1;
        stream_id < kClientDataStreamId3; stream_id += 2) {
     for (bool fin : kFins) {
       if (perspective() == Perspective::IS_SERVER) {
@@ skipping 413 matching lines @@
   stream_frame_.data_length = frame.size();
   headers_stream_->OnStreamFrame(stream_frame_);
 }
 
 TEST_P(QuicHeadersStreamTest, NoConnectionLevelFlowControl) {
   EXPECT_FALSE(QuicStreamPeer::StreamContributesToConnectionFlowControl(
       headers_stream_));
 }
 
 TEST_P(QuicHeadersStreamTest, HpackDecoderDebugVisitor) {
+  if (test_params_.hpack_decoder == HPACK_DECODER3) {
+    return;
+  }
+
   StrictMock<MockQuicHpackDebugVisitor>* hpack_decoder_visitor =
       hpack_decoder_visitor_.get();
   QuicSpdySessionPeer::SetHpackDecoderDebugVisitor(
       &session_, std::move(hpack_decoder_visitor_));
 
   // Create some headers we expect to generate entries in HPACK's
   // dynamic table, in addition to content-length.
   headers_["key0"] = string(1 << 1, '.');
   headers_["key1"] = string(1 << 2, '.');
   headers_["key2"] = string(1 << 3, '.');
@@ skipping 182 matching lines @@
   consumed_data = session_.WritevStreamData(id, MakeIOVector(data, &iov),
                                             offset, fin, nullptr);
 
   EXPECT_EQ(consumed_data.bytes_consumed, 0u);
   EXPECT_EQ(consumed_data.fin_consumed, false);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net