Land Recent QUIC Changes

net/tools/quic/quic_spdy_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_spdy_server_stream.h"
 
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "net/quic/quic_connection.h"
 #include "net/quic/quic_protocol.h"
@@ skipping 28 matching lines @@
 
 class QuicSpdyServerStreamPeer : public QuicSpdyServerStream {
  public:
   QuicSpdyServerStreamPeer(QuicStreamId stream_id, QuicSession* session)
       : QuicSpdyServerStream(stream_id, session) {
   }
 
   using QuicSpdyServerStream::SendResponse;
   using QuicSpdyServerStream::SendErrorResponse;
 
-  BalsaHeaders* mutable_headers() {
-    return &headers_;
+  SpdyHeaderBlock* mutable_headers() {
+    return &request_headers_;
   }
 
   static void SendResponse(QuicSpdyServerStream* stream) {
     stream->SendResponse();
   }
 
   static void SendErrorResponse(QuicSpdyServerStream* stream) {
     stream->SendResponse();
   }
 
   static const string& body(QuicSpdyServerStream* stream) {
     return stream->body_;
   }
 
-  static const BalsaHeaders& headers(QuicSpdyServerStream* stream) {
-    return stream->headers_;
+  static const SpdyHeaderBlock& headers(QuicSpdyServerStream* stream) {
+    return stream->request_headers_;
   }
 };
 
 namespace {
 
 class QuicSpdyServerStreamTest : public ::testing::TestWithParam<QuicVersion> {
  public:
   QuicSpdyServerStreamTest()
       : connection_(
             new StrictMock<MockConnection>(Perspective::IS_SERVER,
                                            SupportedVersions(GetParam()))),
         session_(connection_),
         body_("hello world") {
-    BalsaHeaders request_headers;
-    request_headers.SetRequestFirstlineFromStringPieces(
-        "POST", "https://www.google.com/", "HTTP/1.1");
-    request_headers.ReplaceOrAppendHeader("content-length", "11");
+    SpdyHeaderBlock request_headers;
+    request_headers[":host"] = "";
+    request_headers[":path"] = "/";
+    request_headers[":method"] = "POST";
+    request_headers[":version"] = "HTTP/1.1";
+    request_headers["content-length"] = "11";
 
-    headers_string_ = SpdyUtils::SerializeRequestHeaders(request_headers);
+    headers_string_ = SpdyUtils::SerializeUncompressedHeaders(request_headers);
 
     // 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_.reset(new QuicSpdyServerStreamPeer(3, &session_));
-  }
 
-  static void SetUpTestCase() {
     QuicInMemoryCachePeer::ResetForTests();
-  }
-
-  void SetUp() override {
-    QuicInMemoryCache* cache = QuicInMemoryCache::GetInstance();
-
-    BalsaHeaders response_headers;
-    StringPiece body("Yum");
-    response_headers.SetRequestFirstlineFromStringPieces("HTTP/1.1",
-                                                         "200",
-                                                         "OK");
-    response_headers.AppendHeader("content-length",
-                                  base::IntToString(body.length()));
 
     string host = "";
     string path = "/foo";
-    // Check if response already exists and matches.
-    const QuicInMemoryCache::Response* cached_response =
-        cache->GetResponse(host, path);
-    if (cached_response != nullptr) {
-      string cached_response_headers_str, response_headers_str;
-      cached_response->headers().DumpToString(&cached_response_headers_str);
-      response_headers.DumpToString(&response_headers_str);
-      CHECK_EQ(cached_response_headers_str, response_headers_str);
-      CHECK_EQ(cached_response->body(), body);
-      return;
-    }
+    SpdyHeaderBlock response_headers;
+    StringPiece body("Yum");
+    QuicInMemoryCache::GetInstance()->AddResponse(host, path, response_headers,
+                                                  body);
+  }
 
-    cache->AddResponse(host, path, response_headers, body);
+  ~QuicSpdyServerStreamTest() override {
+    QuicInMemoryCachePeer::ResetForTests();
   }
 
   const string& StreamBody() {
     return QuicSpdyServerStreamPeer::body(stream_.get());
   }
 
-  const BalsaHeaders& StreamHeaders() {
-    return QuicSpdyServerStreamPeer::headers(stream_.get());
+  const string& StreamHeadersValue(const string& key) {
+    return (*stream_->mutable_headers())[key];
   }
 
-  BalsaHeaders response_headers_;
+  SpdyHeaderBlock response_headers_;
   EpollServer eps_;
   StrictMock<MockConnection>* connection_;
   StrictMock<MockSession> session_;
   scoped_ptr<QuicSpdyServerStreamPeer> stream_;
   string headers_string_;
   string body_;
 };
 
 QuicConsumedData ConsumeAllData(
     QuicStreamId id,
     const IOVector& data,
     QuicStreamOffset offset,
     bool fin,
     FecProtection /*fec_protection_*/,
     QuicAckNotifier::DelegateInterface* /*ack_notifier_delegate*/) {
   return QuicConsumedData(data.TotalBufferSize(), fin);
 }
 
 INSTANTIATE_TEST_CASE_P(Tests, QuicSpdyServerStreamTest,
                         ::testing::ValuesIn(QuicSupportedVersions()));
 
 TEST_P(QuicSpdyServerStreamTest, TestFraming) {
   EXPECT_CALL(session_, WritevData(_, _, _, _, _, _)).Times(AnyNumber()).
       WillRepeatedly(Invoke(ConsumeAllData));
-
-  EXPECT_EQ(headers_string_.size(), stream_->ProcessData(
-      headers_string_.c_str(), headers_string_.size()));
+  stream_->OnStreamHeaders(headers_string_);
+  stream_->OnStreamHeadersComplete(false, headers_string_.size());
   EXPECT_EQ(body_.size(), stream_->ProcessData(body_.c_str(), body_.size()));
-  EXPECT_EQ(11u, StreamHeaders().content_length());
-  EXPECT_EQ("https://www.google.com/", StreamHeaders().request_uri());
-  EXPECT_EQ("POST", StreamHeaders().request_method());
+  EXPECT_EQ("11", StreamHeadersValue("content-length"));
+  EXPECT_EQ("/", StreamHeadersValue(":path"));
+  EXPECT_EQ("POST", StreamHeadersValue(":method"));
   EXPECT_EQ(body_, StreamBody());
 }
 
 TEST_P(QuicSpdyServerStreamTest, TestFramingOnePacket) {
   EXPECT_CALL(session_, WritevData(_, _, _, _, _, _)).Times(AnyNumber()).
       WillRepeatedly(Invoke(ConsumeAllData));
 
-  string message = headers_string_ + body_;
-
-  EXPECT_EQ(message.size(), stream_->ProcessData(
-      message.c_str(), message.size()));
-  EXPECT_EQ(11u, StreamHeaders().content_length());
-  EXPECT_EQ("https://www.google.com/", StreamHeaders().request_uri());
-  EXPECT_EQ("POST", StreamHeaders().request_method());
+  stream_->OnStreamHeaders(headers_string_);
+  stream_->OnStreamHeadersComplete(false, headers_string_.size());
+  EXPECT_EQ(body_.size(), stream_->ProcessData(body_.c_str(), body_.size()));
+  EXPECT_EQ("11", StreamHeadersValue("content-length"));
+  EXPECT_EQ("/", StreamHeadersValue(":path"));
+  EXPECT_EQ("POST", StreamHeadersValue(":method"));
   EXPECT_EQ(body_, StreamBody());
 }
 
 TEST_P(QuicSpdyServerStreamTest, TestFramingExtraData) {
   string large_body = "hello world!!!!!!";
 
   // We'll automatically write out an error (headers + body)
   EXPECT_CALL(session_, WritevData(_, _, _, _, _, _)).Times(AnyNumber()).
       WillRepeatedly(Invoke(ConsumeAllData));
 
-  EXPECT_EQ(headers_string_.size(), stream_->ProcessData(
-      headers_string_.c_str(), headers_string_.size()));
+  stream_->OnStreamHeaders(headers_string_);
+  stream_->OnStreamHeadersComplete(false, headers_string_.size());
+  EXPECT_EQ(body_.size(), stream_->ProcessData(body_.c_str(), body_.size()));
   // Content length is still 11.  This will register as an error and we won't
   // accept the bytes.
   stream_->ProcessData(large_body.c_str(), large_body.size());
-  EXPECT_EQ(11u, StreamHeaders().content_length());
-  EXPECT_EQ("https://www.google.com/", StreamHeaders().request_uri());
-  EXPECT_EQ("POST", StreamHeaders().request_method());
+  EXPECT_EQ("11", StreamHeadersValue("content-length"));
+  EXPECT_EQ("/", StreamHeadersValue(":path"));
+  EXPECT_EQ("POST", StreamHeadersValue(":method"));
 }
 
 TEST_P(QuicSpdyServerStreamTest, TestSendResponse) {
-  BalsaHeaders* request_headers = stream_->mutable_headers();
-  request_headers->SetRequestFirstlineFromStringPieces(
-      "GET",
-      "https://www.google.com/foo",
-      "HTTP/1.1");
+  SpdyHeaderBlock* request_headers = stream_->mutable_headers();
+  (*request_headers)[":path"] = "/foo";
+  (*request_headers)[":host"] = "";
+  (*request_headers)[":version"] = "HTTP/1.1";
+  (*request_headers)[":method"] = "GET";
 
-  response_headers_.SetResponseFirstlineFromStringPieces(
-      "HTTP/1.1", "200", "OK");
-  response_headers_.ReplaceOrAppendHeader("content-length", "3");
+  response_headers_[":version"] = "HTTP/1.1";
+  response_headers_[":status"] = "200 OK";
+  response_headers_["content-length"] = "3";
 
   InSequence s;
   EXPECT_CALL(session_, WritevData(kHeadersStreamId, _, 0, false, _, nullptr));
   EXPECT_CALL(session_, WritevData(_, _, _, _, _, _)).Times(1).
       WillOnce(Return(QuicConsumedData(3, true)));
 
   QuicSpdyServerStreamPeer::SendResponse(stream_.get());
   EXPECT_TRUE(stream_->read_side_closed());
   EXPECT_TRUE(stream_->write_side_closed());
 }
 
 TEST_P(QuicSpdyServerStreamTest, TestSendErrorResponse) {
-  response_headers_.SetResponseFirstlineFromStringPieces(
-      "HTTP/1.1", "500", "Server Error");
-  response_headers_.ReplaceOrAppendHeader("content-length", "3");
+  response_headers_[":version"] = "HTTP/1.1";
+  response_headers_[":status"] = "500 Server Error";
+  response_headers_["content-length"] = "3";
 
   InSequence s;
   EXPECT_CALL(session_, WritevData(kHeadersStreamId, _, 0, false, _, nullptr));
   EXPECT_CALL(session_, WritevData(_, _, _, _, _, _)).Times(1).
       WillOnce(Return(QuicConsumedData(3, true)));
 
   QuicSpdyServerStreamPeer::SendErrorResponse(stream_.get());
   EXPECT_TRUE(stream_->read_side_closed());
   EXPECT_TRUE(stream_->write_side_closed());
 }
@@ skipping 25 matching lines @@
   StringPiece data(arr, arraysize(arr));
   QuicStreamFrame frame(stream_->id(), true, 0, MakeIOVector(data));
   // Verify that we don't crash when we get a invalid headers in stream frame.
   stream_->OnStreamFrame(frame);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace tools
 }  // namespace net