QUIC - refactor in preparation for two streams per HTTP transaction.

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>
 #include <utility>
 
 #include "base/strings/string_number_conversions.h"
 #include "net/quic/core/quic_bug_tracker.h"
 #include "net/quic/core/quic_flags.h"
 #include "net/quic/core/quic_utils.h"
 #include "net/quic/core/spdy_utils.h"
 #include "net/quic/platform/api/quic_str_cat.h"
 #include "net/quic/test_tools/quic_connection_peer.h"
-#include "net/quic/test_tools/quic_headers_stream_peer.h"
 #include "net/quic/test_tools/quic_spdy_session_peer.h"
 #include "net/quic/test_tools/quic_stream_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/spdy/spdy_alt_svc_wire_format.h"
 #include "net/spdy/spdy_flags.h"
 #include "net/spdy/spdy_protocol.h"
 #include "net/spdy/spdy_test_utils.h"
 #include "net/test/gtest_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::StringPiece;
 using std::string;
 using testing::_;
 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 MockHpackDebugVisitor : public QuicHeadersStream::HpackDebugVisitor {
+class MockQuicHpackDebugVisitor : public QuicHpackDebugVisitor {
  public:
-  MockHpackDebugVisitor() : HpackDebugVisitor() {}
+  MockQuicHpackDebugVisitor() : QuicHpackDebugVisitor() {}
 
   MOCK_METHOD1(OnUseEntry, void(QuicTime::Delta elapsed));
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(MockHpackDebugVisitor);
+  DISALLOW_COPY_AND_ASSIGN(MockQuicHpackDebugVisitor);
 };
 
 namespace {
 
 // TODO(ckrasic):  this workaround is due to absence of std::initializer_list
 const bool kFins[] = {false, true};
 
 class MockVisitor : public SpdyFramerVisitorInterface {
  public:
   MOCK_METHOD1(OnError, void(SpdyFramer* framer));
@@ skipping 154 matching lines @@
   // to construct a decoder adapter.
   QuicHeadersStreamTest()
       : test_params_(GetParam()),
         connection_(new StrictMock<MockQuicConnection>(&helper_,
                                                        &alarm_factory_,
                                                        perspective(),
                                                        GetVersion())),
         session_(connection_),
         headers_stream_(QuicSpdySessionPeer::GetHeadersStream(&session_)),
         body_("hello world"),
-        hpack_encoder_visitor_(new StrictMock<MockHpackDebugVisitor>),
-        hpack_decoder_visitor_(new StrictMock<MockHpackDebugVisitor>),
+        hpack_encoder_visitor_(new StrictMock<MockQuicHpackDebugVisitor>),
+        hpack_decoder_visitor_(new StrictMock<MockQuicHpackDebugVisitor>),
         stream_frame_(kHeadersStreamId, /*fin=*/false, /*offset=*/0, ""),
         next_promised_stream_id_(2) {
     headers_[":version"] = "HTTP/1.1";
     headers_[":status"] = "200 Ok";
     headers_["content-length"] = "11";
     framer_ = std::unique_ptr<SpdyFramer>(
         new SpdyFramer(SpdyFramer::ENABLE_COMPRESSION));
     framer_->set_visitor(&visitor_);
     EXPECT_EQ(version(), session_.connection()->version());
     EXPECT_TRUE(headers_stream_ != nullptr);
@@ skipping 77 matching lines @@
   }
 
   void WriteHeadersAndCheckData(QuicStreamId stream_id,
                                 bool fin,
                                 SpdyPriority priority,
                                 bool is_request) {
     // Write the headers and capture the outgoing data
     EXPECT_CALL(session_,
                 WritevData(headers_stream_, kHeadersStreamId, _, _, false, _))
         .WillOnce(WithArgs<2>(Invoke(this, &QuicHeadersStreamTest::SaveIov)));
-    headers_stream_->WriteHeaders(stream_id, headers_.Clone(), fin, priority,
-                                  nullptr);
+    QuicSpdySessionPeer::WriteHeadersImpl(
+        &session_, stream_id, headers_.Clone(), fin, priority, nullptr);
 
     // Parse the outgoing data and check that it matches was was written.
     if (is_request) {
       EXPECT_CALL(visitor_,
                   OnHeaders(stream_id, kHasPriority,
                             Spdy3PriorityToHttp2Weight(priority),
                             /*parent_stream_id=*/0,
                             /*exclusive=*/false, fin, kFrameComplete));
     } else {
       EXPECT_CALL(visitor_,
@@ skipping 49 matching lines @@
   StrictMock<MockQuicSpdySession> session_;
   QuicHeadersStream* headers_stream_;
   SpdyHeaderBlock headers_;
   std::unique_ptr<TestHeadersHandler> headers_handler_;
   string body_;
   string saved_data_;
   string saved_header_data_;
   string saved_payloads_;
   std::unique_ptr<SpdyFramer> framer_;
   StrictMock<MockVisitor> visitor_;
-  std::unique_ptr<StrictMock<MockHpackDebugVisitor>> hpack_encoder_visitor_;
-  std::unique_ptr<StrictMock<MockHpackDebugVisitor>> hpack_decoder_visitor_;
+  std::unique_ptr<StrictMock<MockQuicHpackDebugVisitor>> hpack_encoder_visitor_;
+  std::unique_ptr<StrictMock<MockQuicHpackDebugVisitor>> hpack_decoder_visitor_;
   QuicStreamFrame stream_frame_;
   QuicStreamId next_promised_stream_id_;
 };
 
 // Run all tests with each version, perspective (client or server),
 // HTTP/2 and HPACK decoder.
 INSTANTIATE_TEST_CASE_P(
     Tests,
     QuicHeadersStreamTest,
     ::testing::Combine(
@@ skipping 26 matching lines @@
 
 TEST_P(QuicHeadersStreamTest, WritePushPromises) {
   for (QuicStreamId stream_id = kClientDataStreamId1;
        stream_id < kClientDataStreamId3; stream_id += 2) {
     QuicStreamId promised_stream_id = NextPromisedStreamId();
     if (perspective() == Perspective::IS_SERVER) {
       // Write the headers and capture the outgoing data
       EXPECT_CALL(session_,
                   WritevData(headers_stream_, kHeadersStreamId, _, _, false, _))
           .WillOnce(WithArgs<2>(Invoke(this, &QuicHeadersStreamTest::SaveIov)));
-      headers_stream_->WritePushPromise(stream_id, promised_stream_id,
-                                        headers_.Clone());
+      session_.WritePushPromise(stream_id, promised_stream_id,
+                                headers_.Clone());
 
       // Parse the outgoing data and check that it matches was was written.
       EXPECT_CALL(visitor_,
                   OnPushPromise(stream_id, promised_stream_id, kFrameComplete));
       headers_handler_.reset(new TestHeadersHandler);
       EXPECT_CALL(visitor_, OnHeaderFrameStart(stream_id))
           .WillOnce(Return(headers_handler_.get()));
       EXPECT_CALL(visitor_, OnHeaderFrameEnd(stream_id, true)).Times(1);
       framer_->ProcessInput(saved_data_.data(), saved_data_.length());
       EXPECT_FALSE(framer_->HasError())
           << SpdyFramer::ErrorCodeToString(framer_->error_code());
       CheckHeaders();
       saved_data_.clear();
     } else {
-      EXPECT_QUIC_BUG(headers_stream_->WritePushPromise(
-                          stream_id, promised_stream_id, headers_.Clone()),
+      EXPECT_QUIC_BUG(session_.WritePushPromise(stream_id, promised_stream_id,
+                                                headers_.Clone()),
                       "Client shouldn't send PUSH_PROMISE");
     }
   }
 }
 
 TEST_P(QuicHeadersStreamTest, ProcessRawData) {
   for (QuicStreamId stream_id = kClientDataStreamId1;
        stream_id < kClientDataStreamId3; stream_id += 2) {
     for (bool fin : {false, true}) {
       for (SpdyPriority priority = 0; priority < 7; ++priority) {
@@ skipping 145 matching lines @@
 
   for (int stream_num = 9; stream_num >= 0; --stream_num) {
     DVLOG(1) << "OnStreamFrame for stream " << stream_num << " offset "
              << stream_frames[stream_num].offset;
     headers_stream_->OnStreamFrame(stream_frames[stream_num]);
     connection_->AdvanceTime(QuicTime::Delta::FromMilliseconds(1));
   }
 }
 
 TEST_P(QuicHeadersStreamTest, ProcessLargeRawData) {
-  headers_stream_->set_max_uncompressed_header_bytes(256 * 1024);
+  QuicSpdySessionPeer::SetMaxUncompressedHeaderBytes(&session_, 256 * 1024);
   // We want to create a frame that is more than the SPDY Framer's max control
   // frame size, which is 16K, but less than the HPACK decoders max decode
   // buffer size, which is 32K.
   headers_["key0"] = string(1 << 13, '.');
   headers_["key1"] = string(1 << 13, '.');
   headers_["key2"] = string(1 << 13, '.');
   for (QuicStreamId stream_id = kClientDataStreamId1;
        stream_id < kClientDataStreamId3; stream_id += 2) {
     for (bool fin : {false, true}) {
       for (SpdyPriority priority = 0; priority < 7; ++priority) {
@@ skipping 108 matching lines @@
   SpdySettingsIR data;
   // Respect supported settings frames SETTINGS_HEADER_TABLE_SIZE,
   // SETTINGS_MAX_HEADER_LIST_SIZE.
   data.AddSetting(SETTINGS_HEADER_TABLE_SIZE, kTestHeaderTableSize);
   data.AddSetting(SETTINGS_MAX_HEADER_LIST_SIZE, 2000);
   SpdySerializedFrame frame(framer_->SerializeFrame(data));
   stream_frame_.data_buffer = frame.data();
   stream_frame_.data_length = frame.size();
   headers_stream_->OnStreamFrame(stream_frame_);
   EXPECT_EQ(kTestHeaderTableSize,
-            QuicHeadersStreamPeer::GetSpdyFramer(headers_stream_)
+            QuicSpdySessionPeer::GetSpdyFramer(&session_)
                 .header_encoder_table_size());
 }
 
 TEST_P(QuicHeadersStreamTest, RespectHttp2SettingsFrameUnsupportedFields) {
   FLAGS_quic_reloadable_flag_quic_respect_http2_settings_frame = true;
   FLAGS_quic_reloadable_flag_quic_send_max_header_list_size = true;
   SpdySettingsIR data;
   // Does not support SETTINGS_MAX_CONCURRENT_STREAMS,
   // SETTINGS_INITIAL_WINDOW_SIZE, SETTINGS_ENABLE_PUSH and
   // SETTINGS_MAX_FRAME_SIZE.
@@ skipping 70 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 (FLAGS_use_nested_spdy_framer_decoder)
-    return;
-
-  StrictMock<MockHpackDebugVisitor>* hpack_decoder_visitor =
+  StrictMock<MockQuicHpackDebugVisitor>* hpack_decoder_visitor =
       hpack_decoder_visitor_.get();
-  headers_stream_->SetHpackDecoderDebugVisitor(
-      std::move(hpack_decoder_visitor_));
+  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, '.');
   {
     InSequence seq;
     // Number of indexed representations generated in headers below.
     for (int i = 1; i < 28; i++) {
@@ skipping 28 matching lines @@
         connection_->AdvanceTime(QuicTime::Delta::FromMilliseconds(1));
         headers_stream_->OnStreamFrame(stream_frame_);
         stream_frame_.offset += frame.size();
         CheckHeaders();
       }
     }
   }
 }
 
 TEST_P(QuicHeadersStreamTest, HpackEncoderDebugVisitor) {
-  StrictMock<MockHpackDebugVisitor>* hpack_encoder_visitor =
+  StrictMock<MockQuicHpackDebugVisitor>* hpack_encoder_visitor =
       hpack_encoder_visitor_.get();
-  headers_stream_->SetHpackEncoderDebugVisitor(
-      std::move(hpack_encoder_visitor_));
+  QuicSpdySessionPeer::SetHpackEncoderDebugVisitor(
+      &session_, std::move(hpack_encoder_visitor_));
 
   if (perspective() == Perspective::IS_SERVER) {
     InSequence seq;
     for (int i = 1; i < 4; i++) {
       EXPECT_CALL(*hpack_encoder_visitor,
                   OnUseEntry(QuicTime::Delta::FromMilliseconds(i)));
     }
   } else {
     InSequence seq;
     for (int i = 1; i < 28; i++) {
@@ skipping 36 matching lines @@
     for (bool use_ack_listener : {true, false}) {
       QuicReferenceCountedPointer<ForceHolAckListener> ack_listener;
       if (use_ack_listener) {
         ack_listener = new ForceHolAckListener();
       }
       EXPECT_CALL(session_,
                   WritevData(headers_stream_, kHeadersStreamId, _, _, false, _))
           .WillRepeatedly(WithArgs<2, 5>(Invoke(
               this, &QuicHeadersStreamTest::SaveIovAndNotifyAckListener)));
 
-      QuicConsumedData consumed_data = headers_stream_->WritevStreamData(
+      QuicConsumedData consumed_data = session_.WritevStreamData(
           id, MakeIOVector(data, &iov), offset, fin, ack_listener);
 
       EXPECT_EQ(consumed_data.bytes_consumed, data_len);
       EXPECT_EQ(consumed_data.fin_consumed, fin);
       // Now process the written data with the SPDY framer, and verify
       // that the original data is unchanged.
       EXPECT_CALL(visitor_, OnDataFrameHeader(id, _, _))
           .Times(AtLeast(kMinDataFrames));
       EXPECT_CALL(visitor_, OnStreamFrameData(id, _, _))
           .WillRepeatedly(WithArgs<1, 2>(
@@ skipping 17 matching lines @@
 
 TEST_P(QuicHeadersStreamTest, WritevStreamDataFinOnly) {
   struct iovec iov;
   string data;
 
   EXPECT_CALL(session_,
               WritevData(headers_stream_, kHeadersStreamId, _, _, false, _))
       .WillOnce(WithArgs<2, 5>(
           Invoke(this, &QuicHeadersStreamTest::SaveIovAndNotifyAckListener)));
 
-  QuicConsumedData consumed_data = headers_stream_->WritevStreamData(
+  QuicConsumedData consumed_data = session_.WritevStreamData(
       kClientDataStreamId1, MakeIOVector(data, &iov), 0, true, nullptr);
 
   EXPECT_EQ(consumed_data.bytes_consumed, 0u);
   EXPECT_EQ(consumed_data.fin_consumed, true);
 }
 
 TEST_P(QuicHeadersStreamTest, WritevStreamDataSendBlocked) {
   QuicStreamId id = kClientDataStreamId1;
   QuicStreamOffset offset = 0;
   struct iovec iov;
@@ skipping 11 matching lines @@
 
   bool fin = true;
   // So force the underlying |WritevData| to consume only 1 byte.
   // In that case, |WritevStreamData| should consume just one
   // HTTP/2 data frame's worth of data.
   EXPECT_CALL(session_,
               WritevData(headers_stream_, kHeadersStreamId, _, _, false, _))
       .WillOnce(
           WithArgs<2>(Invoke(this, &QuicHeadersStreamTest::SaveIovShort)));
 
-  QuicConsumedData consumed_data = headers_stream_->WritevStreamData(
+  QuicConsumedData consumed_data = session_.WritevStreamData(
       id, MakeIOVector(data, &iov), offset, fin, nullptr);
 
   // bytes_consumed is max HTTP/2 data frame size minus the HTTP/2
   // data header size.
   EXPECT_EQ(consumed_data.bytes_consumed,
             kSpdyInitialFrameSizeLimit - kDataFrameMinimumSize);
   EXPECT_EQ(consumed_data.fin_consumed, false);
 
   // If session already blocked, then bytes_consumed should be zero.
-  consumed_data = headers_stream_->WritevStreamData(
-      id, MakeIOVector(data, &iov), offset, fin, nullptr);
+  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