Squelch a variety of "GMOCK WARNING" messages in quic_session_test by

net/quic/quic_session_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/quic_session.h"
 
 #include <set>
 
 #include "base/basictypes.h"
 #include "base/containers/hash_tables.h"
@@ skipping 166 matching lines @@
 
  private:
   StrictMock<TestCryptoStream> crypto_stream_;
 
   bool writev_consumes_all_data_;
 };
 
 class QuicSessionTest : public ::testing::TestWithParam<QuicVersion> {
  protected:
   QuicSessionTest()
-      : connection_(new MockConnection(true, SupportedVersions(GetParam()))),
+      : connection_(
+            new StrictMock<MockConnection>(true,
+                                           SupportedVersions(GetParam()))),
         session_(connection_) {
     session_.config()->SetInitialStreamFlowControlWindowToSend(
         kInitialStreamFlowControlWindowForTest);
     session_.config()->SetInitialSessionFlowControlWindowToSend(
         kInitialSessionFlowControlWindowForTest);
     headers_[":host"] = "www.google.com";
     headers_[":path"] = "/index.hml";
     headers_[":scheme"] = "http";
     headers_["cookie"] =
         "__utma=208381060.1228362404.1372200928.1372200928.1372200928.1; "
@@ skipping 26 matching lines @@
     for (int i = kCryptoStreamId; i < 100; i++) {
       if (!ContainsKey(closed_streams_, i)) {
         EXPECT_FALSE(session_.IsClosedStream(i)) << " stream id: " << i;
       } else {
         EXPECT_TRUE(session_.IsClosedStream(i)) << " stream id: " << i;
       }
     }
   }
 
   void CloseStream(QuicStreamId id) {
+    EXPECT_CALL(*connection_, SendRstStream(id, _, _));
     session_.CloseStream(id);
     closed_streams_.insert(id);
   }
 
   QuicVersion version() const { return connection_->version(); }
 
-  MockConnection* connection_;
+  StrictMock<MockConnection>* connection_;
   TestSession session_;
   set<QuicStreamId> closed_streams_;
   SpdyHeaderBlock headers_;
 };
 
 INSTANTIATE_TEST_CASE_P(Tests, QuicSessionTest,
                         ::testing::ValuesIn(QuicSupportedVersions()));
 
 TEST_P(QuicSessionTest, PeerAddress) {
   EXPECT_EQ(IPEndPoint(Loopback4(), kTestPort), session_.peer_address());
@@ skipping 75 matching lines @@
   };
   EXPECT_CALL(*connection_, SendConnectionCloseWithDetails(
                                 QUIC_INVALID_HEADERS_STREAM_DATA,
                                 "SPDY framing error: DECOMPRESS_FAILURE"));
   stream->ProcessRawData(reinterpret_cast<const char*>(data),
                          arraysize(data));
 }
 
 TEST_P(QuicSessionTest, DebugDFatalIfMarkingClosedStreamWriteBlocked) {
   TestStream* stream2 = session_.CreateOutgoingDataStream();
+  QuicStreamId kClosedStreamId = stream2->id();
   // Close the stream.
+  EXPECT_CALL(*connection_, SendRstStream(kClosedStreamId, _, _));
   stream2->Reset(QUIC_BAD_APPLICATION_PAYLOAD);
   // TODO(rtenneti): enable when chromium supports EXPECT_DEBUG_DFATAL.
   /*
-  QuicStreamId kClosedStreamId = stream2->id();
   EXPECT_DEBUG_DFATAL(
       session_.MarkWriteBlocked(kClosedStreamId, kSomeMiddlePriority),
       "Marking unknown stream 2 blocked.");
   */
 }
 
 TEST_P(QuicSessionTest, DebugDFatalIfMarkWriteBlockedCalledWithWrongPriority) {
   const QuicPriority kDifferentPriority = 0;
 
   TestStream* stream2 = session_.CreateOutgoingDataStream();
@@ skipping 231 matching lines @@
 }
 
 TEST_P(QuicSessionTest, RstStreamBeforeHeadersDecompressed) {
   // Send two bytes of payload.
   QuicStreamFrame data1(kClientDataStreamId1, false, 0, MakeIOVector("HT"));
   vector<QuicStreamFrame> frames;
   frames.push_back(data1);
   session_.OnStreamFrames(frames);
   EXPECT_EQ(1u, session_.GetNumOpenStreams());
 
+  EXPECT_CALL(*connection_, SendRstStream(kClientDataStreamId1, _, _));
   QuicRstStreamFrame rst1(kClientDataStreamId1, QUIC_STREAM_NO_ERROR, 0);
   session_.OnRstStream(rst1);
   EXPECT_EQ(0u, session_.GetNumOpenStreams());
   // Connection should remain alive.
   EXPECT_TRUE(connection_->connected());
 }
 
 TEST_P(QuicSessionTest, MultipleRstStreamsCauseSingleConnectionClose) {
   // If multiple invalid reset stream frames arrive in a single packet, this
   // should trigger a connection close. However there is no need to send
@@ skipping 28 matching lines @@
   // Ensure that Writev consumes all the data it is given (simulate no socket
   // blocking).
   session_.set_writev_consumes_all_data(true);
 
   // Create a stream, and send enough data to make it flow control blocked.
   TestStream* stream2 = session_.CreateOutgoingDataStream();
   string body(kMinimumFlowControlSendWindow, '.');
   EXPECT_FALSE(stream2->flow_controller()->IsBlocked());
   EXPECT_FALSE(session_.IsConnectionFlowControlBlocked());
   EXPECT_FALSE(session_.IsStreamFlowControlBlocked());
+  EXPECT_CALL(*connection_, SendBlocked(stream2->id()));
+  EXPECT_CALL(*connection_, SendBlocked(0));
   stream2->SendBody(body, false);
   EXPECT_TRUE(stream2->flow_controller()->IsBlocked());
   EXPECT_TRUE(session_.IsConnectionFlowControlBlocked());
   EXPECT_TRUE(session_.IsStreamFlowControlBlocked());
 
   // The handshake message will call OnCanWrite, so the stream can resume
   // writing.
   EXPECT_CALL(*stream2, OnCanWrite());
   // Now complete the crypto handshake, resulting in an increased flow control
   // send window.
@@ skipping 13 matching lines @@
   TestCryptoStream* crypto_stream = session_.GetCryptoStream();
   EXPECT_FALSE(crypto_stream->flow_controller()->IsBlocked());
   EXPECT_FALSE(session_.IsConnectionFlowControlBlocked());
   EXPECT_FALSE(session_.IsStreamFlowControlBlocked());
   QuicHeadersStream* headers_stream =
       QuicSessionPeer::GetHeadersStream(&session_);
   EXPECT_FALSE(headers_stream->flow_controller()->IsBlocked());
   EXPECT_FALSE(session_.IsConnectionFlowControlBlocked());
   EXPECT_FALSE(session_.IsStreamFlowControlBlocked());
   // Write until the crypto stream is flow control blocked.
+  EXPECT_CALL(*connection_, SendBlocked(kCryptoStreamId));
   int i = 0;
   while (!crypto_stream->flow_controller()->IsBlocked() && i < 1000) {
     EXPECT_FALSE(session_.IsConnectionFlowControlBlocked());
     EXPECT_FALSE(session_.IsStreamFlowControlBlocked());
     QuicConfig config;
     CryptoHandshakeMessage crypto_message;
     config.ToHandshakeMessage(&crypto_message);
     crypto_stream->SendHandshakeMessage(crypto_message);
     ++i;
   }
@@ skipping 26 matching lines @@
   EXPECT_FALSE(crypto_stream->flow_controller()->IsBlocked());
   EXPECT_FALSE(session_.IsConnectionFlowControlBlocked());
   EXPECT_FALSE(session_.IsStreamFlowControlBlocked());
   QuicHeadersStream* headers_stream =
       QuicSessionPeer::GetHeadersStream(&session_);
   EXPECT_FALSE(headers_stream->flow_controller()->IsBlocked());
   EXPECT_FALSE(session_.IsConnectionFlowControlBlocked());
   EXPECT_FALSE(session_.IsStreamFlowControlBlocked());
   QuicStreamId stream_id = 5;
   // Write until the header stream is flow control blocked.
+  EXPECT_CALL(*connection_, SendBlocked(kHeadersStreamId));
   SpdyHeaderBlock headers;
   while (!headers_stream->flow_controller()->IsBlocked() && stream_id < 2000) {
     EXPECT_FALSE(session_.IsConnectionFlowControlBlocked());
     EXPECT_FALSE(session_.IsStreamFlowControlBlocked());
     headers["header"] = base::Uint64ToString(base::RandUint64()) +
         base::Uint64ToString(base::RandUint64()) +
         base::Uint64ToString(base::RandUint64());
     headers_stream->WriteHeaders(stream_id, headers, true, nullptr);
     stream_id += 2;
   }
@@ skipping 30 matching lines @@
   const QuicStreamOffset kByteOffset =
       1 + kInitialSessionFlowControlWindowForTest / 2;
 
   // Expect no stream WINDOW_UPDATE frames, as stream read side closed.
   EXPECT_CALL(*connection_, SendWindowUpdate(stream->id(), _)).Times(0);
   // We do expect a connection level WINDOW_UPDATE when the stream is reset.
   EXPECT_CALL(*connection_,
               SendWindowUpdate(0, kInitialSessionFlowControlWindowForTest +
                                       kByteOffset)).Times(1);
 
+  EXPECT_CALL(*connection_, SendRstStream(stream->id(), _, _));
   QuicRstStreamFrame rst_frame(stream->id(), QUIC_STREAM_CANCELLED,
                                kByteOffset);
   session_.OnRstStream(rst_frame);
   session_.PostProcessAfterData();
   EXPECT_EQ(kByteOffset, session_.flow_controller()->bytes_consumed());
 }
 
 TEST_P(QuicSessionTest, ConnectionFlowControlAccountingFinAndLocalReset) {
   // Test the situation where we receive a FIN on a stream, and before we fully
   // consume all the data from the sequencer buffer we locally RST the stream.
   // The bytes between highest consumed byte, and the final byte offset that we
   // determined when the FIN arrived, should be marked as consumed at the
   // connection level flow controller when the stream is reset.
   TestStream* stream = session_.CreateOutgoingDataStream();
 
   const QuicStreamOffset kByteOffset =
-      1 + kInitialSessionFlowControlWindowForTest / 2;
+      kInitialSessionFlowControlWindowForTest / 2;
   QuicStreamFrame frame(stream->id(), true, kByteOffset, IOVector());
   vector<QuicStreamFrame> frames;
   frames.push_back(frame);
   session_.OnStreamFrames(frames);
   session_.PostProcessAfterData();
+  EXPECT_TRUE(connection_->connected());
 
   EXPECT_EQ(0u, stream->flow_controller()->bytes_consumed());
   EXPECT_EQ(kByteOffset,
             stream->flow_controller()->highest_received_byte_offset());
 
   // Reset stream locally.
+  EXPECT_CALL(*connection_, SendRstStream(stream->id(), _, _));
   stream->Reset(QUIC_STREAM_CANCELLED);
   EXPECT_EQ(kByteOffset, session_.flow_controller()->bytes_consumed());
 }
 
 TEST_P(QuicSessionTest, ConnectionFlowControlAccountingFinAfterRst) {
   // Test that when we RST the stream (and tear down stream state), and then
   // receive a FIN from the peer, we correctly adjust our connection level flow
   // control receive window.
 
   // Connection starts with some non-zero highest received byte offset,
   // due to other active streams.
   const uint64 kInitialConnectionBytesConsumed = 567;
   const uint64 kInitialConnectionHighestReceivedOffset = 1234;
   EXPECT_LT(kInitialConnectionBytesConsumed,
             kInitialConnectionHighestReceivedOffset);
   session_.flow_controller()->UpdateHighestReceivedOffset(
       kInitialConnectionHighestReceivedOffset);
   session_.flow_controller()->AddBytesConsumed(kInitialConnectionBytesConsumed);
 
   // Reset our stream: this results in the stream being closed locally.
   TestStream* stream = session_.CreateOutgoingDataStream();
+  EXPECT_CALL(*connection_, SendRstStream(stream->id(), _, _));
   stream->Reset(QUIC_STREAM_CANCELLED);
 
   // Now receive a response from the peer with a FIN. We should handle this by
   // adjusting the connection level flow control receive window to take into
   // account the total number of bytes sent by the peer.
   const QuicStreamOffset kByteOffset = 5678;
   string body = "hello";
   IOVector data = MakeIOVector(body);
   QuicStreamFrame frame(stream->id(), true, kByteOffset, data);
   vector<QuicStreamFrame> frames;
@@ skipping 19 matching lines @@
   const uint64 kInitialConnectionBytesConsumed = 567;
   const uint64 kInitialConnectionHighestReceivedOffset = 1234;
   EXPECT_LT(kInitialConnectionBytesConsumed,
             kInitialConnectionHighestReceivedOffset);
   session_.flow_controller()->UpdateHighestReceivedOffset(
       kInitialConnectionHighestReceivedOffset);
   session_.flow_controller()->AddBytesConsumed(kInitialConnectionBytesConsumed);
 
   // Reset our stream: this results in the stream being closed locally.
   TestStream* stream = session_.CreateOutgoingDataStream();
+  EXPECT_CALL(*connection_, SendRstStream(stream->id(), _, _));
   stream->Reset(QUIC_STREAM_CANCELLED);
 
   // Now receive a RST from the peer. We should handle this by adjusting the
   // connection level flow control receive window to take into account the total
   // number of bytes sent by the peer.
   const QuicStreamOffset kByteOffset = 5678;
   QuicRstStreamFrame rst_frame(stream->id(), QUIC_STREAM_CANCELLED,
                                kByteOffset);
   session_.OnRstStream(rst_frame);
 
@@ skipping 30 matching lines @@
 TEST_P(QuicSessionTest, FlowControlWithInvalidFinalOffset) {
   // Test that if we receive a stream RST with a highest byte offset that
   // violates flow control, that we close the connection.
   const uint64 kLargeOffset = kInitialSessionFlowControlWindowForTest + 1;
   EXPECT_CALL(*connection_,
               SendConnectionClose(QUIC_FLOW_CONTROL_RECEIVED_TOO_MUCH_DATA))
       .Times(2);
 
   // Check that stream frame + FIN results in connection close.
   TestStream* stream = session_.CreateOutgoingDataStream();
+  EXPECT_CALL(*connection_, SendRstStream(stream->id(), _, _));
   stream->Reset(QUIC_STREAM_CANCELLED);
   QuicStreamFrame frame(stream->id(), true, kLargeOffset, IOVector());
   vector<QuicStreamFrame> frames;
   frames.push_back(frame);
   session_.OnStreamFrames(frames);
 
   // Check that RST results in connection close.
   QuicRstStreamFrame rst_frame(stream->id(), QUIC_STREAM_CANCELLED,
                                kLargeOffset);
   session_.OnRstStream(rst_frame);
@@ skipping 35 matching lines @@
   // Create kMaxStreams + 1 data streams, and close them all without receiving a
   // FIN or a RST from the client.
   const int kFirstStreamId = kClientDataStreamId1;
   const int kFinalStreamId = kClientDataStreamId1 + 2 * kMaxStreams + 1;
   for (int i = kFirstStreamId; i < kFinalStreamId; i += 2) {
     QuicStreamFrame data1(i, false, 0, MakeIOVector("HT"));
     vector<QuicStreamFrame> frames;
     frames.push_back(data1);
     session_.OnStreamFrames(frames);
     EXPECT_EQ(1u, session_.GetNumOpenStreams());
+    EXPECT_CALL(*connection_, SendRstStream(i, _, _));
     session_.CloseStream(i);
   }
 
   // Called after any new data is received by the session, and triggers the call
   // to close the connection.
   session_.PostProcessAfterData();
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net