Avoids the "re-encode HPACK as SPDY3" step.

net/quic/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/quic_headers_stream.h"
 
 #include "net/quic/quic_utils.h"
 #include "net/quic/spdy_utils.h"
 #include "net/quic/test_tools/quic_connection_peer.h"
 #include "net/quic/test_tools/quic_spdy_session_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/quic/test_tools/reliable_quic_stream_peer.h"
 #include "net/spdy/spdy_alt_svc_wire_format.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::ostream;
 using std::string;
 using std::vector;
 using testing::ElementsAre;
 using testing::InSequence;
 using testing::Invoke;
+using testing::Return;
 using testing::StrictMock;
 using testing::WithArgs;
 using testing::_;
 
 namespace net {
 namespace test {
 namespace {
 
 // TODO(ckrasic):  this workaround is due to absence of std::initializer_list
 const bool kFins[] = {false, true};
@@ skipping 119 matching lines @@
 
   bool SaveHeaderData(const char* data, int len) {
     saved_header_data_.append(data, len);
     return true;
   }
 
   void SaveHeaderDataStringPiece(StringPiece data) {
     saved_header_data_.append(data.data(), data.length());
   }
 
+  void SavePromiseHeaderList(QuicStreamId /* stream_id */,
+                             QuicStreamId /* promised_stream_id */,
+                             size_t size,
+                             const QuicHeaderList& header_list) {
+    SaveToHandler(size, header_list);
+  }
+
+  void SaveHeaderList(QuicStreamId /* stream_id */,
+                      bool /* fin */,
+                      size_t size,
+                      const QuicHeaderList& header_list) {
+    SaveToHandler(size, header_list);
+  }
+
+  void SaveToHandler(size_t size, const QuicHeaderList& header_list) {
+    headers_handler_.reset(new TestHeadersHandler);
+    headers_handler_->OnHeaderBlockStart();
+    for (const auto& p : header_list) {
+      headers_handler_->OnHeader(p.first, p.second);
+    }
+    headers_handler_->OnHeaderBlockEnd(size);
+  }
+
   void WriteHeadersAndExpectSynStream(QuicStreamId stream_id,
                                       bool fin,
                                       SpdyPriority priority) {
     WriteHeadersAndCheckData(stream_id, fin, priority, SYN_STREAM);
   }
 
   void WriteHeadersAndExpectSynReply(QuicStreamId stream_id, bool fin) {
     WriteHeadersAndCheckData(stream_id, fin, 0, SYN_REPLY);
   }
 
@@ skipping 12 matching lines @@
                   OnHeaders(stream_id, kHasPriority, priority,
                             /*parent_stream_id=*/0,
                             /*exclusive=*/false, fin, kFrameComplete));
     } else {
       EXPECT_CALL(visitor_,
                   OnHeaders(stream_id, !kHasPriority,
                             /*priority=*/0,
                             /*parent_stream_id=*/0,
                             /*exclusive=*/false, fin, kFrameComplete));
     }
-    EXPECT_CALL(visitor_, OnControlFrameHeaderData(stream_id, _, _))
-        .WillRepeatedly(WithArgs<1, 2>(
-            Invoke(this, &QuicHeadersStreamTest::SaveHeaderData)));
+    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);
     if (fin) {
       EXPECT_CALL(visitor_, OnStreamEnd(stream_id));
     }
     framer_->ProcessInput(saved_data_.data(), saved_data_.length());
     EXPECT_FALSE(framer_->HasError())
         << SpdyFramer::ErrorCodeToString(framer_->error_code());
 
     CheckHeaders();
     saved_data_.clear();
   }
 
   void CheckHeaders() {
-    SpdyHeaderBlock headers;
-    EXPECT_TRUE(framer_->ParseHeaderBlockInBuffer(
-        saved_header_data_.data(), saved_header_data_.length(), &headers));
-    EXPECT_EQ(headers_, headers);
-    saved_header_data_.clear();
+    EXPECT_EQ(headers_, headers_handler_->decoded_block());
+    headers_handler_.reset();
   }
 
   Perspective perspective() { return GetParam().perspective; }
 
   QuicVersion version() { return GetParam().version; }
 
   QuicVersionVector GetVersion() {
     QuicVersionVector versions;
     versions.push_back(version());
     return versions;
   }
 
   void TearDownLocalConnectionState() {
     QuicConnectionPeer::TearDownLocalConnectionState(connection_);
   }
 
   QuicStreamId NextPromisedStreamId() { return next_promised_stream_id_ += 2; }
 
   static const bool kFrameComplete = true;
   static const bool kHasPriority = true;
 
   MockConnectionHelper helper_;
   MockAlarmFactory alarm_factory_;
   StrictMock<MockConnection>* connection_;
   StrictMock<MockQuicSpdySession> session_;
   QuicHeadersStream* headers_stream_;
   SpdyHeaderBlock headers_;
+  std::unique_ptr<TestHeadersHandler> headers_handler_;
   string body_;
   string saved_data_;
   string saved_header_data_;
   std::unique_ptr<SpdyFramer> framer_;
   StrictMock<MockVisitor> visitor_;
   QuicStreamFrame stream_frame_;
   QuicStreamId next_promised_stream_id_;
 };
 
 INSTANTIATE_TEST_CASE_P(Tests,
@@ skipping 27 matching lines @@
     if (perspective() == Perspective::IS_SERVER) {
       // Write the headers and capture the outgoing data
       EXPECT_CALL(session_, WritevData(kHeadersStreamId, _, _, false, nullptr))
           .WillOnce(WithArgs<1>(Invoke(this, &QuicHeadersStreamTest::SaveIov)));
       headers_stream_->WritePushPromise(stream_id, promised_stream_id, headers_,
                                         nullptr);
 
       // Parse the outgoing data and check that it matches was was written.
       EXPECT_CALL(visitor_,
                   OnPushPromise(stream_id, promised_stream_id, kFrameComplete));
-      EXPECT_CALL(visitor_, OnControlFrameHeaderData(stream_id, _, _))
-          .WillRepeatedly(WithArgs<1, 2>(
-              Invoke(this, &QuicHeadersStreamTest::SaveHeaderData)));
+      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_DFATAL(headers_stream_->WritePushPromise(
                         stream_id, promised_stream_id, headers_, nullptr),
                     "Client shouldn't send PUSH_PROMISE");
     }
@@ skipping 13 matching lines @@
           headers_frame.set_fin(fin);
           headers_frame.set_has_priority(true);
           frame = framer_->SerializeFrame(headers_frame);
           EXPECT_CALL(session_, OnStreamHeadersPriority(stream_id, 0));
         } else {
           SpdyHeadersIR headers_frame(stream_id);
           headers_frame.set_header_block(headers_);
           headers_frame.set_fin(fin);
           frame = framer_->SerializeFrame(headers_frame);
         }
-        EXPECT_CALL(session_, OnStreamHeaders(stream_id, _))
-            .WillRepeatedly(WithArgs<1>(Invoke(
-                this, &QuicHeadersStreamTest::SaveHeaderDataStringPiece)));
         EXPECT_CALL(session_,
-                    OnStreamHeadersComplete(stream_id, fin, frame.size()));
+                    OnStreamHeaderList(stream_id, fin, frame.size(), _))
+            .WillOnce(Invoke(this, &QuicHeadersStreamTest::SaveHeaderList));
         stream_frame_.frame_buffer = frame.data();
         stream_frame_.frame_length = frame.size();
         headers_stream_->OnStreamFrame(stream_frame_);
         stream_frame_.offset += frame.size();
         CheckHeaders();
       }
     }
   }
 }
 
 TEST_P(QuicHeadersStreamTest, ProcessPushPromise) {
   if (perspective() == Perspective::IS_SERVER)
     return;
   for (QuicStreamId stream_id = kClientDataStreamId1;
        stream_id < kClientDataStreamId3; stream_id += 2) {
     QuicStreamId promised_stream_id = NextPromisedStreamId();
     SpdyPushPromiseIR push_promise(stream_id, promised_stream_id);
     push_promise.set_header_block(headers_);
     SpdySerializedFrame frame(framer_->SerializeFrame(push_promise));
     if (perspective() == Perspective::IS_SERVER) {
       EXPECT_CALL(*connection_,
                   CloseConnection(QUIC_INVALID_HEADERS_STREAM_DATA,
                                   "PUSH_PROMISE not supported.", _))
           .WillRepeatedly(InvokeWithoutArgs(
               this, &QuicHeadersStreamTest::TearDownLocalConnectionState));
     } else {
-      EXPECT_CALL(session_, OnPromiseHeaders(stream_id, _))
-          .WillRepeatedly(WithArgs<1>(
-              Invoke(this, &QuicHeadersStreamTest::SaveHeaderDataStringPiece)));
-      EXPECT_CALL(session_, OnPromiseHeadersComplete(
-                                stream_id, promised_stream_id, frame.size()));
+      EXPECT_CALL(session_, OnPromiseHeaderList(stream_id, promised_stream_id,
+                                                frame.size(), _))
+          .WillOnce(
+              Invoke(this, &QuicHeadersStreamTest::SavePromiseHeaderList));
     }
     stream_frame_.frame_buffer = frame.data();
     stream_frame_.frame_length = frame.size();
     headers_stream_->OnStreamFrame(stream_frame_);
     if (perspective() == Perspective::IS_CLIENT) {
       stream_frame_.offset += frame.size();
       CheckHeaders();
     }
   }
 }
@@ skipping 15 matching lines @@
       headers_frame.set_fin(fin);
       headers_frame.set_has_priority(true);
       frame = framer_->SerializeFrame(headers_frame);
       EXPECT_CALL(session_, OnStreamHeadersPriority(stream_id, 0));
     } else {
       SpdyHeadersIR headers_frame(stream_id);
       headers_frame.set_header_block(headers_);
       headers_frame.set_fin(fin);
       frame = framer_->SerializeFrame(headers_frame);
     }
-    EXPECT_CALL(session_, OnStreamHeaders(stream_id, _));
-    EXPECT_CALL(session_,
-                OnStreamHeadersComplete(stream_id, fin, frame.size()));
+    EXPECT_CALL(session_, OnStreamHeaderList(stream_id, fin, frame.size(), _))
+        .Times(1);
     stream_frame_.frame_buffer = frame.data();
     stream_frame_.frame_length = frame.size();
     headers_stream_->OnStreamFrame(stream_frame_);
     connection_->AdvanceTime(QuicTime::Delta::FromMilliseconds(1));
     stream_frame_.offset += frame.size();
   }
 }
 
 TEST_P(QuicHeadersStreamTest, NonEmptyHeaderHOLBlockedTime) {
   if (!FLAGS_quic_measure_headers_hol_blocking_time) {
@@ skipping 21 matching lines @@
         headers_frame.set_fin(fin);
         frames[stream_num] = framer_->SerializeFrame(headers_frame);
       }
       stream_frames[stream_num].stream_id = stream_frame_.stream_id;
       stream_frames[stream_num].offset = stream_frame_.offset;
       stream_frames[stream_num].frame_buffer = frames[stream_num].data();
       stream_frames[stream_num].frame_length = frames[stream_num].size();
       DVLOG(1) << "make frame for stream " << stream_num << " offset "
                << stream_frames[stream_num].offset;
       stream_frame_.offset += frames[stream_num].size();
-      EXPECT_CALL(session_, OnStreamHeaders(stream_id, _)).Times(1);
-      EXPECT_CALL(session_, OnStreamHeadersComplete(stream_id, fin, _))
-          .Times(1);
+      EXPECT_CALL(session_, OnStreamHeaderList(stream_id, fin, _, _)).Times(1);
     }
   }
 
   // Actually writing the frames in reverse order will cause HOL blocking.
   EXPECT_CALL(session_, OnHeadersHeadOfLineBlocking(_)).Times(9);
 
   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]);
@@ skipping 20 matching lines @@
           headers_frame.set_fin(fin);
           headers_frame.set_has_priority(true);
           frame = framer_->SerializeFrame(headers_frame);
           EXPECT_CALL(session_, OnStreamHeadersPriority(stream_id, 0));
         } else {
           SpdyHeadersIR headers_frame(stream_id);
           headers_frame.set_header_block(headers_);
           headers_frame.set_fin(fin);
           frame = framer_->SerializeFrame(headers_frame);
         }
-        EXPECT_CALL(session_, OnStreamHeaders(stream_id, _))
-            .WillRepeatedly(WithArgs<1>(Invoke(
-                this, &QuicHeadersStreamTest::SaveHeaderDataStringPiece)));
         EXPECT_CALL(session_,
-                    OnStreamHeadersComplete(stream_id, fin, frame.size()));
+                    OnStreamHeaderList(stream_id, fin, frame.size(), _))
+            .WillOnce(Invoke(this, &QuicHeadersStreamTest::SaveHeaderList));
         stream_frame_.frame_buffer = frame.data();
         stream_frame_.frame_length = frame.size();
         headers_stream_->OnStreamFrame(stream_frame_);
         stream_frame_.offset += frame.size();
         CheckHeaders();
       }
     }
   }
 }
 
@@ skipping 83 matching lines @@
 }
 
 TEST_P(QuicHeadersStreamTest, NoConnectionLevelFlowControl) {
   EXPECT_FALSE(ReliableQuicStreamPeer::StreamContributesToConnectionFlowControl(
       headers_stream_));
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net