relnote: QUIC header streams support to receive PUSH_PROMISE. Protected by --quic_supports_push_pr…

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 207 matching lines @@
   QuicVersion version() { return GetParam().version; }
 
   QuicVersionVector GetVersion() {
     QuicVersionVector versions;
     versions.push_back(version());
     return versions;
   }
 
   void CloseConnection() { QuicConnectionPeer::CloseConnection(connection_); }
 
-  QuicStreamId NextPromisedStreamId() { return next_promised_stream_id_++; }
+  QuicStreamId NextPromisedStreamId() { return next_promised_stream_id_ += 2; }
 
   static const bool kFrameComplete = true;
   static const bool kHasPriority = true;
 
   MockConnectionHelper helper_;
   StrictMock<MockConnection>* connection_;
   StrictMock<MockQuicSpdySession> session_;
   QuicHeadersStream* headers_stream_;
   SpdyHeaderBlock headers_;
   string body_;
@@ skipping 92 matching lines @@
         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) {
+  FLAGS_quic_supports_push_promise = true;
+  for (QuicStreamId stream_id = kClientDataStreamId1;
+       stream_id < kClientDataStreamId3; stream_id += 2) {
+    QuicStreamId promised_stream_id = NextPromisedStreamId();
+    scoped_ptr<SpdySerializedFrame> frame;
+    SpdyPushPromiseIR push_promise(stream_id, promised_stream_id);
+    push_promise.set_header_block(headers_);
+    frame.reset(framer_.SerializeFrame(push_promise));
+    if (perspective() == Perspective::IS_SERVER) {
+      EXPECT_CALL(*connection_, SendConnectionCloseWithDetails(
+                                    QUIC_INVALID_HEADERS_STREAM_DATA,
+                                    "PUSH_PROMISE not supported."))
+          .WillRepeatedly(
+              InvokeWithoutArgs(this, &QuicHeadersStreamTest::CloseConnection));
+    } 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()));
+    }
+    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();
+    }
+  }
+}
+
+TEST_P(QuicHeadersStreamTest, PushPromiseOutOfOrder) {
+  FLAGS_quic_supports_push_promise = true;
+  if (perspective() == Perspective::IS_SERVER) {
+    return;
+  }
+
+  QuicStreamId promised_stream_id = NextPromisedStreamId();
+  QuicStreamId stream_id = kClientDataStreamId1;
+
+  scoped_ptr<SpdySerializedFrame> frame;
+  SpdyPushPromiseIR push_promise(stream_id, promised_stream_id);
+  push_promise.set_header_block(headers_);
+  frame.reset(framer_.SerializeFrame(push_promise));
+  EXPECT_CALL(session_, OnPromiseHeaders(stream_id, _))
+      .WillRepeatedly(WithArgs<1>(
+          Invoke(this, &QuicHeadersStreamTest::SaveHeaderDataStringPiece)));
+  EXPECT_CALL(session_, OnPromiseHeadersComplete(stream_id, promised_stream_id,
+                                                 frame->size()));
+  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();
+  }
+
+  stream_id += 2;
+  push_promise.set_stream_id(stream_id);
+  frame.reset(framer_.SerializeFrame(push_promise));
+  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(*connection_, SendConnectionCloseWithDetails(
+                                QUIC_INVALID_STREAM_ID,
+                                "Received push stream id lesser or equal to the"
+                                " last accepted before"))
+      .WillRepeatedly(
+          InvokeWithoutArgs(this, &QuicHeadersStreamTest::CloseConnection));
+  stream_frame_.frame_buffer = frame->data();
+  stream_frame_.frame_length = frame->size();
+  headers_stream_->OnStreamFrame(stream_frame_);
+}
+
 TEST_P(QuicHeadersStreamTest, EmptyHeaderHOLBlockedTime) {
   EXPECT_CALL(session_, OnHeadersHeadOfLineBlocking(_)).Times(0);
   testing::InSequence seq;
   bool fin = true;
   for (int stream_num = 0; stream_num < 10; stream_num++) {
     QuicStreamId stream_id = QuicClientDataStreamId(stream_num);
     // Replace with "WriteHeadersAndSaveData"
     scoped_ptr<SpdySerializedFrame> frame;
     if (perspective() == Perspective::IS_SERVER) {
       SpdyHeadersIR headers_frame(stream_id);
@@ skipping 197 matching lines @@
 }
 
 TEST_P(QuicHeadersStreamTest, NoConnectionLevelFlowControl) {
   EXPECT_FALSE(ReliableQuicStreamPeer::StreamContributesToConnectionFlowControl(
       headers_stream_));
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net