Landing Recent QUIC changes until Sat Apr 29 00:22:04 2017 +0000

net/tools/quic/quic_simple_server_stream_test.cc

 // Copyright (c) 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/tools/quic/quic_simple_server_stream.h"
 
 #include <list>
 #include <memory>
 #include <utility>
 
 #include "net/quic/core/quic_utils.h"
 #include "net/quic/core/spdy_utils.h"
 #include "net/quic/platform/api/quic_ptr_util.h"
 #include "net/quic/platform/api/quic_socket_address.h"
 #include "net/quic/platform/api/quic_test.h"
 #include "net/quic/test_tools/crypto_test_utils.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/test/gtest_util.h"
 #include "net/tools/quic/quic_http_response_cache.h"
 #include "net/tools/quic/quic_simple_server_session.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using std::string;
 using testing::_;
@@ skipping 166 matching lines @@
     header_list_.OnHeader(":version", "HTTP/1.1");
     header_list_.OnHeader("content-length", "11");
     header_list_.OnHeaderBlockEnd(128);
 
     // New streams rely on having the peer's flow control receive window
     // negotiated in the config.
     session_.config()->SetInitialStreamFlowControlWindowToSend(
         kInitialStreamFlowControlWindowForTest);
     session_.config()->SetInitialSessionFlowControlWindowToSend(
         kInitialSessionFlowControlWindowForTest);
-    stream_ = new QuicSimpleServerStreamPeer(kClientDataStreamId1, &session_,
-                                             &response_cache_);
+    stream_ = new QuicSimpleServerStreamPeer(
+        QuicSpdySessionPeer::GetNthClientInitiatedStreamId(session_, 0),
+        &session_, &response_cache_);
     // Register stream_ in dynamic_stream_map_ and pass ownership to session_.
     session_.ActivateStream(QuicWrapUnique(stream_));
   }
 
   const string& StreamBody() {
     return QuicSimpleServerStreamPeer::body(stream_);
   }
 
   string StreamHeadersValue(const string& key) {
     return (*stream_->mutable_headers())[key].as_string();
@@ skipping 222 matching lines @@
       host, request_path, 200, body, push_resources);
 
   SpdyHeaderBlock* request_headers = stream_->mutable_headers();
   (*request_headers)[":path"] = request_path;
   (*request_headers)[":authority"] = host;
   (*request_headers)[":version"] = "HTTP/1.1";
   (*request_headers)[":method"] = "GET";
 
   stream_->set_fin_received(true);
   InSequence s;
-  EXPECT_CALL(session_, PromisePushResourcesMock(host + request_path, _,
-                                                 kClientDataStreamId1, _));
+  EXPECT_CALL(
+      session_,
+      PromisePushResourcesMock(
+          host + request_path, _,
+          QuicSpdySessionPeer::GetNthClientInitiatedStreamId(session_, 0), _));
   EXPECT_CALL(session_, WriteHeadersMock(stream_->id(), _, false, _, _));
   EXPECT_CALL(session_, WritevData(_, _, _, _, _, _))
       .Times(1)
       .WillOnce(Return(QuicConsumedData(body.length(), true)));
   QuicSimpleServerStreamPeer::SendResponse(stream_);
   EXPECT_EQ(*request_headers, session_.original_request_headers_);
 }
 
 TEST_P(QuicSimpleServerStreamTest, PushResponseOnClientInitiatedStream) {
   // Calling PushResponse() on a client initialted stream is never supposed to
@@ skipping 32 matching lines @@
 
   // Call PushResponse() should trigger stream to fetch response from cache
   // and send it back.
   EXPECT_CALL(session_,
               WriteHeadersMock(kServerInitiatedStreamId, _, false,
                                server_initiated_stream->priority(), _));
   EXPECT_CALL(session_, WritevData(_, kServerInitiatedStreamId, _, _, _, _))
       .Times(1)
       .WillOnce(Return(QuicConsumedData(kBody.size(), true)));
   server_initiated_stream->PushResponse(std::move(headers));
-  EXPECT_EQ(
-      kPath,
-      QuicSimpleServerStreamPeer::headers(server_initiated_stream)[":path"]
-          .as_string());
-  EXPECT_EQ(
-      "GET",
-      QuicSimpleServerStreamPeer::headers(server_initiated_stream)[":method"]
-          .as_string());
+  EXPECT_EQ(kPath, QuicSimpleServerStreamPeer::headers(
+                       server_initiated_stream)[":path"]
+                       .as_string());
+  EXPECT_EQ("GET", QuicSimpleServerStreamPeer::headers(
+                       server_initiated_stream)[":method"]
+                       .as_string());
 }
 
 TEST_P(QuicSimpleServerStreamTest, TestSendErrorResponse) {
   EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(0);
 
   stream_->set_fin_received(true);
 
   InSequence s;
   EXPECT_CALL(session_, WriteHeadersMock(_, _, _, _, _));
   EXPECT_CALL(session_, WritevData(_, _, _, _, _, _))
@@ skipping 119 matching lines @@
   };
   QuicStringPiece data(arr, arraysize(arr));
   QuicStreamFrame frame(stream_->id(), true, 0, data);
   // Verify that we don't crash when we get a invalid headers in stream frame.
   stream_->OnStreamFrame(frame);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net