Rewriting the headers stream test to not use SYN_STREAM/SYN_REPLY

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 <string>
 
 #include "base/strings/string_number_conversions.h"
 #include "net/quic/core/quic_bug_tracker.h"
@@ skipping 296 matching lines @@
 
   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 WriteAndExpectRequestHeaders(QuicStreamId stream_id,
+                                    bool fin,
+                                    SpdyPriority priority) {
+    WriteHeadersAndCheckData(stream_id, fin, priority, true /*is_request*/);
   }
 
-  void WriteHeadersAndExpectSynReply(QuicStreamId stream_id, bool fin) {
-    WriteHeadersAndCheckData(stream_id, fin, 0, SYN_REPLY);
+  void WriteAndExpectResponseHeaders(QuicStreamId stream_id, bool fin) {
+    WriteHeadersAndCheckData(stream_id, fin, 0, false /*is_request*/);
   }
 
   void WriteHeadersAndCheckData(QuicStreamId stream_id,
                                 bool fin,
                                 SpdyPriority priority,
-                                SpdyFrameType type) {
+                                bool is_request) {
     // Write the headers and capture the outgoing data
     EXPECT_CALL(session_, WritevData(headers_stream_, kHeadersStreamId, _, _,
                                      false, nullptr))
         .WillOnce(WithArgs<2>(Invoke(this, &QuicHeadersStreamTest::SaveIov)));
     headers_stream_->WriteHeaders(stream_id, headers_.Clone(), fin, priority,
                                   nullptr);
 
     // Parse the outgoing data and check that it matches was was written.
-    if (type == SYN_STREAM) {
+    if (is_request) {
       EXPECT_CALL(visitor_,
                   OnHeaders(stream_id, kHasPriority,
                             Spdy3PriorityToHttp2Weight(priority),
                             /*parent_stream_id=*/0,
                             /*exclusive=*/false, fin, kFrameComplete));
     } else {
       EXPECT_CALL(visitor_,
                   OnHeaders(stream_id, !kHasPriority,
                             /*priority=*/0,
                             /*parent_stream_id=*/0,
@@ skipping 74 matching lines @@
 
 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) {
-        WriteHeadersAndExpectSynReply(stream_id, fin);
+        WriteAndExpectResponseHeaders(stream_id, fin);
       } else {
         for (SpdyPriority priority = 0; priority < 7; ++priority) {
           // TODO(rch): implement priorities correctly.
-          WriteHeadersAndExpectSynStream(stream_id, fin, 0);
+          WriteAndExpectRequestHeaders(stream_id, fin, 0);
         }
       }
     }
   }
 }
 
 TEST_P(QuicHeadersStreamTest, WritePushPromises) {
   for (QuicStreamId stream_id = kClientDataStreamId1;
        stream_id < kClientDataStreamId3; stream_id += 2) {
     QuicStreamId promised_stream_id = NextPromisedStreamId();
@@ skipping 476 matching lines @@
     testing::InSequence seq;
     for (int i = 1; i < 28; i++) {
       EXPECT_CALL(*hpack_encoder_visitor,
                   OnUseEntry(QuicTime::Delta::FromMilliseconds(i)));
     }
   }
   for (QuicStreamId stream_id = kClientDataStreamId1;
        stream_id < kClientDataStreamId3; stream_id += 2) {
     for (bool fin : {false, true}) {
       if (perspective() == Perspective::IS_SERVER) {
-        WriteHeadersAndExpectSynReply(stream_id, fin);
+        WriteAndExpectResponseHeaders(stream_id, fin);
         connection_->AdvanceTime(QuicTime::Delta::FromMilliseconds(1));
       } else {
         for (SpdyPriority priority = 0; priority < 7; ++priority) {
           // TODO(rch): implement priorities correctly.
-          WriteHeadersAndExpectSynStream(stream_id, fin, 0);
+          WriteAndExpectRequestHeaders(stream_id, fin, 0);
           connection_->AdvanceTime(QuicTime::Delta::FromMilliseconds(1));
         }
       }
     }
   }
 }
 
 TEST_P(QuicHeadersStreamTest, WritevStreamData) {
   QuicStreamId id = kClientDataStreamId1;
   QuicStreamOffset offset = 0;
@@ skipping 105 matching lines @@
   consumed_data = headers_stream_->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