Landing Recent QUIC changes until 4/22/2016 14:55 UTC

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"
@@ skipping 78 matching lines @@
                void(SpdyStreamId stream_id,
                     StringPiece origin,
                     const SpdyAltSvcWireFormat::AlternativeServiceVector&
                         altsvc_vector));
   MOCK_METHOD2(OnUnknownFrame, bool(SpdyStreamId stream_id, int frame_type));
 };
 
 // Run all tests with each version, perspective (client or server),
 // and relevant flag options (false or true)
 struct TestParams {
-  TestParams(QuicVersion version,
-             Perspective perspective,
-             bool spdy_on_stream_end)
-      : version(version),
-        perspective(perspective),
-        spdy_on_stream_end(spdy_on_stream_end) {}
+  TestParams(QuicVersion version, Perspective perspective)
+      : version(version), perspective(perspective) {}
 
   friend ostream& operator<<(ostream& os, const TestParams& p) {
     os << "{ version: " << QuicVersionToString(p.version);
-    os << ", perspective: " << p.perspective;
-    os << ", spdy_on_stream_end: " << p.spdy_on_stream_end << " }";
+    os << ", perspective: " << p.perspective << " }";
     return os;
   }
 
   QuicVersion version;
   Perspective perspective;
-  bool spdy_on_stream_end;
 };
 
 // Constructs various test permutations.
 vector<TestParams> GetTestParams() {
   vector<TestParams> params;
   QuicVersionVector all_supported_versions = QuicSupportedVersions();
   for (const QuicVersion version : all_supported_versions) {
-    params.push_back(TestParams(version, Perspective::IS_CLIENT, true));
-    params.push_back(TestParams(version, Perspective::IS_SERVER, true));
-    params.push_back(TestParams(version, Perspective::IS_CLIENT, false));
-    params.push_back(TestParams(version, Perspective::IS_SERVER, false));
+    params.push_back(TestParams(version, Perspective::IS_CLIENT));
+    params.push_back(TestParams(version, Perspective::IS_SERVER));
   }
   FLAGS_quic_supports_push_promise = true;
   return params;
 }
 
 class QuicHeadersStreamTest : public ::testing::TestWithParam<TestParams> {
  public:
   QuicHeadersStreamTest()
       : connection_(new StrictMock<MockConnection>(&helper_,
                                                    &alarm_factory_,
                                                    perspective(),
                                                    GetVersion())),
         session_(connection_),
         headers_stream_(QuicSpdySessionPeer::GetHeadersStream(&session_)),
         body_("hello world"),
         stream_frame_(kHeadersStreamId, /*fin=*/false, /*offset=*/0, ""),
         next_promised_stream_id_(2) {
     FLAGS_quic_always_log_bugs_for_tests = true;
     headers_[":version"] = "HTTP/1.1";
     headers_[":status"] = "200 Ok";
     headers_["content-length"] = "11";
-    FLAGS_spdy_on_stream_end = GetParam().spdy_on_stream_end;
     framer_ = std::unique_ptr<SpdyFramer>(new SpdyFramer(HTTP2));
     framer_->set_visitor(&visitor_);
     EXPECT_EQ(version(), session_.connection()->version());
     EXPECT_TRUE(headers_stream_ != nullptr);
     VLOG(1) << GetParam();
     connection_->AdvanceTime(QuicTime::Delta::FromMilliseconds(1));
   }
 
   QuicConsumedData SaveIov(const QuicIOVector& data) {
     const iovec* iov = data.iov;
@@ skipping 42 matching lines @@
       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)));
     if (fin) {
-      if (FLAGS_spdy_on_stream_end) {
-        EXPECT_CALL(visitor_, OnStreamEnd(stream_id));
-      } else {
-        EXPECT_CALL(visitor_, OnStreamFrameData(stream_id, nullptr, 0, true));
-      }
+      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() {
@@ skipping 365 matching lines @@
 }
 
 TEST_P(QuicHeadersStreamTest, NoConnectionLevelFlowControl) {
   EXPECT_FALSE(ReliableQuicStreamPeer::StreamContributesToConnectionFlowControl(
       headers_stream_));
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net