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

net/quic/chromium/quic_chromium_client_stream_test.cc

 // Copyright (c) 2012 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/chromium/quic_chromium_client_stream.h"
 
 #include <string>
 
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/quic/chromium/quic_chromium_client_session.h"
 #include "net/quic/core/quic_client_session_base.h"
 #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/test_tools/crypto_test_utils.h"
+#include "net/quic/test_tools/quic_spdy_session_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/test/gtest_util.h"
+#include "net/tools/quic/quic_spdy_client_stream.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gmock_mutant.h"
 
 using testing::AnyNumber;
 using testing::CreateFunctor;
 using testing::Invoke;
 using testing::Return;
 using testing::StrEq;
 using testing::_;
 
@@ skipping 21 matching lines @@
   MOCK_METHOD0(OnClose, void());
   MOCK_METHOD1(OnError, void(int));
   MOCK_METHOD0(HasSendHeadersComplete, bool());
 
   SpdyHeaderBlock headers_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockDelegate);
 };
 
+class TestQuicClientSessionBaseStream : public QuicSpdyStream {
+ public:
+  TestQuicClientSessionBaseStream(QuicStreamId id, QuicSpdySession* session)
+      : QuicSpdyStream(id, session) {}
+
+  void OnDataAvailable() override {}
+};
+
 class MockQuicClientSessionBase : public QuicClientSessionBase {
  public:
   explicit MockQuicClientSessionBase(QuicConnection* connection,
                                      QuicClientPushPromiseIndex* index);
   ~MockQuicClientSessionBase() override;
 
   const QuicCryptoStream* GetCryptoStream() const override {
     return crypto_stream_.get();
   }
 
@@ skipping 49 matching lines @@
   MOCK_METHOD5(
       WriteHeadersMock,
       size_t(QuicStreamId id,
              const SpdyHeaderBlock& headers,
              bool fin,
              SpdyPriority priority,
              const QuicReferenceCountedPointer<QuicAckListenerInterface>&
                  ack_listener));
   MOCK_METHOD1(OnHeadersHeadOfLineBlocking, void(QuicTime::Delta delta));
 
+  std::unique_ptr<QuicStream> CreateStream(QuicStreamId id) {
+    return QuicMakeUnique<TestQuicClientSessionBaseStream>(id, this);
+  }
+
   using QuicSession::ActivateStream;
 
   // Returns a QuicConsumedData that indicates all of |data| (and |fin| if set)
   // has been consumed.
   static QuicConsumedData ConsumeAllData(
       QuicStreamId id,
       const QuicIOVector& data,
       QuicStreamOffset offset,
       bool fin,
       QuicAckListenerInterface* ack_listener);
@@ skipping 97 matching lines @@
   QuicHeaderList ProcessHeadersFull(const SpdyHeaderBlock& headers) {
     QuicHeaderList h = ProcessHeaders(headers);
     EXPECT_CALL(delegate_,
                 OnHeadersAvailableMock(_, h.uncompressed_header_bytes()));
     base::RunLoop().RunUntilIdle();
     EXPECT_EQ(headers, delegate_.headers_);
     EXPECT_TRUE(stream_->header_list().empty());
     return h;
   }
 
+  QuicStreamId GetNthClientInitiatedStreamId(int n) {
+    return QuicSpdySessionPeer::GetNthClientInitiatedStreamId(session_, n);
+  }
+
+  QuicStreamId GetNthServerInitiatedStreamId(int n) {
+    return QuicSpdySessionPeer::GetNthServerInitiatedStreamId(session_, n);
+  }
+
   QuicCryptoClientConfig crypto_config_;
   testing::StrictMock<MockDelegate> delegate_;
   MockQuicConnectionHelper helper_;
   MockAlarmFactory alarm_factory_;
   MockQuicClientSessionBase session_;
   QuicChromiumClientStream* stream_;
   SpdyHeaderBlock headers_;
   QuicClientPushPromiseIndex push_promise_index_;
 };
 
@@ skipping 327 matching lines @@
       .WillOnce(Return(QuicConsumedData(buf2->size(), true)));
   stream_->OnCanWrite();
   ASSERT_TRUE(callback.have_result());
   EXPECT_THAT(callback.WaitForResult(), IsOk());
 }
 
 TEST_P(QuicChromiumClientStreamTest, HeadersBeforeDelegate) {
   // We don't use stream_ because we want an incoming server push
   // stream.
   QuicChromiumClientStream* stream = new QuicChromiumClientStream(
-      kServerDataStreamId1, &session_, NetLogWithSource());
+      GetNthServerInitiatedStreamId(0), &session_, NetLogWithSource());
   session_.ActivateStream(base::WrapUnique(stream));
 
   InitializeHeaders();
   stream->SetDelegate(&delegate_);
   ProcessHeadersFull(headers_);
 
   // Times(2) because OnClose will be called for stream and stream_.
   EXPECT_CALL(delegate_, OnClose()).Times(2);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net