Refactor gmock_mutant.h

net/quic/quic_stream_sequencer_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_stream_sequencer.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/logging.h"
@@ skipping 164 matching lines @@
 
 INSTANTIATE_TEST_CASE_P(QuicStreamSequencerTests,
                         QuicStreamSequencerTest,
                         ::testing::Values(false, true));
 
 // TODO(rch): reorder these tests so they build on each other.
 
 TEST_P(QuicStreamSequencerTest, RejectOldFrame) {
   EXPECT_CALL(stream_, OnDataAvailable())
       .WillOnce(testing::Invoke(
-          CreateFunctor(this, &QuicStreamSequencerTest::ConsumeData, 3)));
+          CreateFunctor(&QuicStreamSequencerTest::ConsumeData,
+                        base::Unretained(this), 3)));
 
   OnFrame(0, "abc");
 
   EXPECT_EQ(0u, NumBufferedBytes());
   EXPECT_EQ(3u, sequencer_->NumBytesConsumed());
   EXPECT_EQ(3u, stream_.flow_controller()->bytes_consumed());
   // Ignore this - it matches a past packet number and we should not see it
   // again.
   OnFrame(0, "def");
   EXPECT_EQ(0u, NumBufferedBytes());
 }
 
 TEST_P(QuicStreamSequencerTest, RejectBufferedFrame) {
   EXPECT_CALL(stream_, OnDataAvailable());
 
   OnFrame(0, "abc");
   EXPECT_EQ(3u, NumBufferedBytes());
   EXPECT_EQ(0u, sequencer_->NumBytesConsumed());
 
   // Ignore this - it matches a buffered frame.
   // Right now there's no checking that the payload is consistent.
   OnFrame(0, "def");
   EXPECT_EQ(3u, NumBufferedBytes());
 }
 
 TEST_P(QuicStreamSequencerTest, FullFrameConsumed) {
   EXPECT_CALL(stream_, OnDataAvailable())
       .WillOnce(testing::Invoke(
-          CreateFunctor(this, &QuicStreamSequencerTest::ConsumeData, 3)));
+          CreateFunctor(&QuicStreamSequencerTest::ConsumeData,
+                        base::Unretained(this), 3)));
 
   OnFrame(0, "abc");
   EXPECT_EQ(0u, NumBufferedBytes());
   EXPECT_EQ(3u, sequencer_->NumBytesConsumed());
 }
 
 TEST_P(QuicStreamSequencerTest, BlockedThenFullFrameConsumed) {
   sequencer_->SetBlockedUntilFlush();
 
   OnFrame(0, "abc");
   EXPECT_EQ(3u, NumBufferedBytes());
   EXPECT_EQ(0u, sequencer_->NumBytesConsumed());
 
   EXPECT_CALL(stream_, OnDataAvailable())
       .WillOnce(testing::Invoke(
-          CreateFunctor(this, &QuicStreamSequencerTest::ConsumeData, 3)));
+          CreateFunctor(&QuicStreamSequencerTest::ConsumeData,
+                        base::Unretained(this), 3)));
   sequencer_->SetUnblocked();
   EXPECT_EQ(0u, NumBufferedBytes());
   EXPECT_EQ(3u, sequencer_->NumBytesConsumed());
 
   EXPECT_CALL(stream_, OnDataAvailable())
       .WillOnce(testing::Invoke(
-          CreateFunctor(this, &QuicStreamSequencerTest::ConsumeData, 3)));
+          CreateFunctor(&QuicStreamSequencerTest::ConsumeData,
+                        base::Unretained(this), 3)));
   EXPECT_FALSE(sequencer_->IsClosed());
   OnFinFrame(3, "def");
   EXPECT_TRUE(sequencer_->IsClosed());
 }
 
 TEST_P(QuicStreamSequencerTest, BlockedThenFullFrameAndFinConsumed) {
   sequencer_->SetBlockedUntilFlush();
 
   OnFinFrame(0, "abc");
   EXPECT_EQ(3u, NumBufferedBytes());
   EXPECT_EQ(0u, sequencer_->NumBytesConsumed());
 
   EXPECT_CALL(stream_, OnDataAvailable())
       .WillOnce(testing::Invoke(
-          CreateFunctor(this, &QuicStreamSequencerTest::ConsumeData, 3)));
+          CreateFunctor(&QuicStreamSequencerTest::ConsumeData,
+                        base::Unretained(this), 3)));
   EXPECT_FALSE(sequencer_->IsClosed());
   sequencer_->SetUnblocked();
   EXPECT_TRUE(sequencer_->IsClosed());
   EXPECT_EQ(0u, NumBufferedBytes());
   EXPECT_EQ(3u, sequencer_->NumBytesConsumed());
 }
 
 TEST_P(QuicStreamSequencerTest, EmptyFrame) {
   EXPECT_CALL(stream_,
               CloseConnectionWithDetails(QUIC_INVALID_STREAM_FRAME, _));
   OnFrame(0, "");
   EXPECT_EQ(0u, NumBufferedBytes());
   EXPECT_EQ(0u, sequencer_->NumBytesConsumed());
 }
 
 TEST_P(QuicStreamSequencerTest, EmptyFinFrame) {
   EXPECT_CALL(stream_, OnDataAvailable());
   OnFinFrame(0, "");
   EXPECT_EQ(0u, NumBufferedBytes());
   EXPECT_EQ(0u, sequencer_->NumBytesConsumed());
 }
 
 TEST_P(QuicStreamSequencerTest, PartialFrameConsumed) {
   EXPECT_CALL(stream_, OnDataAvailable())
       .WillOnce(testing::Invoke(
-          CreateFunctor(this, &QuicStreamSequencerTest::ConsumeData, 2)));
+          CreateFunctor(&QuicStreamSequencerTest::ConsumeData,
+                        base::Unretained(this), 2)));
 
   OnFrame(0, "abc");
   EXPECT_EQ(1u, NumBufferedBytes());
   EXPECT_EQ(2u, sequencer_->NumBytesConsumed());
 }
 
 TEST_P(QuicStreamSequencerTest, NextxFrameNotConsumed) {
   EXPECT_CALL(stream_, OnDataAvailable());
 
   OnFrame(0, "abc");
@@ skipping 16 matching lines @@
   EXPECT_EQ(0u, sequencer_->NumBytesConsumed());
   EXPECT_EQ(3u, sequencer_->NumBytesBuffered());
   // Buffer the second
   OnFrame(3, "def");
   EXPECT_EQ(6u, NumBufferedBytes());
   EXPECT_EQ(0u, sequencer_->NumBytesConsumed());
   EXPECT_EQ(6u, sequencer_->NumBytesBuffered());
 
   EXPECT_CALL(stream_, OnDataAvailable())
       .WillOnce(testing::Invoke(
-          CreateFunctor(this, &QuicStreamSequencerTest::ConsumeData, 9)));
+          CreateFunctor(&QuicStreamSequencerTest::ConsumeData,
+                        base::Unretained(this), 9)));
 
   // Now process all of them at once.
   OnFrame(0, "abc");
   EXPECT_EQ(9u, sequencer_->NumBytesConsumed());
   EXPECT_EQ(0u, sequencer_->NumBytesBuffered());
 
   EXPECT_EQ(0u, NumBufferedBytes());
 }
 
 TEST_P(QuicStreamSequencerTest, BasicHalfCloseOrdered) {
   InSequence s;
 
   EXPECT_CALL(stream_, OnDataAvailable())
       .WillOnce(testing::Invoke(
-          CreateFunctor(this, &QuicStreamSequencerTest::ConsumeData, 3)));
+          CreateFunctor(&QuicStreamSequencerTest::ConsumeData,
+                        base::Unretained(this), 3)));
   OnFinFrame(0, "abc");
 
   EXPECT_EQ(3u, QuicStreamSequencerPeer::GetCloseOffset(sequencer_.get()));
 }
 
 TEST_P(QuicStreamSequencerTest, BasicHalfCloseUnorderedWithFlush) {
   OnFinFrame(6, "");
   EXPECT_EQ(6u, QuicStreamSequencerPeer::GetCloseOffset(sequencer_.get()));
 
   OnFrame(3, "def");
   EXPECT_CALL(stream_, OnDataAvailable())
       .WillOnce(testing::Invoke(
-          CreateFunctor(this, &QuicStreamSequencerTest::ConsumeData, 6)));
+          CreateFunctor(&QuicStreamSequencerTest::ConsumeData,
+                        base::Unretained(this), 6)));
   EXPECT_FALSE(sequencer_->IsClosed());
   OnFrame(0, "abc");
   EXPECT_TRUE(sequencer_->IsClosed());
 }
 
 TEST_P(QuicStreamSequencerTest, BasicHalfUnordered) {
   OnFinFrame(3, "");
   EXPECT_EQ(3u, QuicStreamSequencerPeer::GetCloseOffset(sequencer_.get()));
 
   EXPECT_CALL(stream_, OnDataAvailable())
       .WillOnce(testing::Invoke(
-          CreateFunctor(this, &QuicStreamSequencerTest::ConsumeData, 3)));
+          CreateFunctor(&QuicStreamSequencerTest::ConsumeData,
+                        base::Unretained(this), 3)));
   EXPECT_FALSE(sequencer_->IsClosed());
   OnFrame(0, "abc");
   EXPECT_TRUE(sequencer_->IsClosed());
 }
 
 TEST_P(QuicStreamSequencerTest, TerminateWithReadv) {
   char buffer[3];
 
   OnFinFrame(3, "");
   EXPECT_EQ(3u, QuicStreamSequencerPeer::GetCloseOffset(sequencer_.get()));
@@ skipping 362 matching lines @@
   EXPECT_EQ(timestamp, t1);
   QuicStreamSequencerTest::ConsumeData(3);
   EXPECT_EQ(0u, NumBufferedBytes());
   EXPECT_EQ(6u, sequencer_->NumBytesConsumed());
   EXPECT_EQ(0u, sequencer_->NumBytesBuffered());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net