Make SpdyHeaderBlock non-copyable.

net/quic/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/quic_chromium_client_stream.h"
 
 #include <string>
 
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 21 matching lines @@
 namespace {
 
 const QuicStreamId kTestStreamId = 5u;
 
 class MockDelegate : public QuicChromiumClientStream::Delegate {
  public:
   MockDelegate() {}
 
   MOCK_METHOD0(OnSendData, int());
   MOCK_METHOD2(OnSendDataComplete, int(int, bool*));
-  MOCK_METHOD2(OnHeadersAvailable,
+  void OnHeadersAvailable(const SpdyHeaderBlock& headers,
+                          size_t frame_len) override {
+    headers_ = headers.Clone();
+    OnHeadersAvailableMock(headers, frame_len);
+  }
+  MOCK_METHOD2(OnHeadersAvailableMock,
                void(const SpdyHeaderBlock& headers, size_t frame_len));
   MOCK_METHOD2(OnDataReceived, int(const char*, int));
   MOCK_METHOD0(OnDataAvailable, void());
   MOCK_METHOD0(OnClose, void());
   MOCK_METHOD1(OnError, void(int));
   MOCK_METHOD0(HasSendHeadersComplete, bool());
 
+  SpdyHeaderBlock headers_;
+
  private:
   DISALLOW_COPY_AND_ASSIGN(MockDelegate);
 };
 
 class MockQuicClientSessionBase : public QuicClientSessionBase {
  public:
   explicit MockQuicClientSessionBase(QuicConnection* connection,
                                      QuicClientPushPromiseIndex* index);
   ~MockQuicClientSessionBase() override;
 
@@ skipping 25 matching lines @@
                void(QuicStreamId stream_id, SpdyPriority priority));
   MOCK_METHOD3(OnStreamHeadersComplete,
                void(QuicStreamId stream_id, bool fin, size_t frame_len));
   MOCK_METHOD2(OnPromiseHeaders,
                void(QuicStreamId stream_id, StringPiece headers_data));
   MOCK_METHOD3(OnPromiseHeadersComplete,
                void(QuicStreamId stream_id,
                     QuicStreamId promised_stream_id,
                     size_t frame_len));
   MOCK_METHOD0(IsCryptoHandshakeConfirmed, bool());
-  MOCK_METHOD5(WriteHeaders,
+  // Methods taking non-copyable types like SpdyHeaderBlock by value cannot be
+  // mocked directly.
+  size_t WriteHeaders(
+      QuicStreamId id,
+      SpdyHeaderBlock headers,
+      bool fin,
+      SpdyPriority priority,
+      QuicAckListenerInterface* ack_notifier_delegate) override {
+    return WriteHeadersMock(id, headers, fin, priority, ack_notifier_delegate);
+  }
+  MOCK_METHOD5(WriteHeadersMock,
                size_t(QuicStreamId id,
-                      SpdyHeaderBlock headers,
+                      const SpdyHeaderBlock& headers,
                       bool fin,
                       SpdyPriority priority,
                       QuicAckListenerInterface* ack_notifier_delegate));
   MOCK_METHOD1(OnHeadersHeadOfLineBlocking, void(QuicTime::Delta delta));
 
   using QuicSession::ActivateStream;
 
   // Returns a QuicConsumedData that indicates all of |data| (and |fin| if set)
   // has been consumed.
   static QuicConsumedData ConsumeAllData(
@@ skipping 103 matching lines @@
 
 TEST_P(QuicChromiumClientStreamTest, OnFinRead) {
   InitializeHeaders();
   std::string uncompressed_headers =
       SpdyUtils::SerializeUncompressedHeaders(headers_);
   QuicStreamOffset offset = 0;
   stream_->OnStreamHeaders(uncompressed_headers);
   stream_->OnStreamHeadersComplete(false, uncompressed_headers.length());
 
   EXPECT_CALL(delegate_,
-              OnHeadersAvailable(headers_, uncompressed_headers.length()));
+              OnHeadersAvailableMock(_, uncompressed_headers.length()));
   base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(headers_, delegate_.headers_);
   EXPECT_TRUE(stream_->decompressed_headers().empty());
 
   QuicStreamFrame frame2(kTestStreamId, true, offset, StringPiece());
   EXPECT_CALL(delegate_, OnClose());
   stream_->OnStreamFrame(frame2);
 }
 
 TEST_P(QuicChromiumClientStreamTest, OnDataAvailableBeforeHeaders) {
   EXPECT_CALL(delegate_, OnClose());
 
   EXPECT_CALL(delegate_, OnDataAvailable()).Times(0);
   stream_->OnDataAvailable();
 }
 
 TEST_P(QuicChromiumClientStreamTest, OnDataAvailable) {
   InitializeHeaders();
   std::string uncompressed_headers =
       SpdyUtils::SerializeUncompressedHeaders(headers_);
   stream_->OnStreamHeaders(uncompressed_headers);
   stream_->OnStreamHeadersComplete(false, uncompressed_headers.length());
 
   EXPECT_CALL(delegate_,
-              OnHeadersAvailable(headers_, uncompressed_headers.length()));
+              OnHeadersAvailableMock(_, uncompressed_headers.length()));
   base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(headers_, delegate_.headers_);
   EXPECT_TRUE(stream_->decompressed_headers().empty());
 
   const char data[] = "hello world!";
   stream_->OnStreamFrame(QuicStreamFrame(kTestStreamId, /*fin=*/false,
                                          /*offset=*/0, data));
 
   EXPECT_CALL(delegate_, OnDataAvailable())
       .WillOnce(testing::Invoke(
           CreateFunctor(&QuicChromiumClientStreamTest::ReadData,
                         base::Unretained(this),
@@ skipping 17 matching lines @@
 }
 
 TEST_P(QuicChromiumClientStreamTest, OnDataAvailableWithError) {
   InitializeHeaders();
   std::string uncompressed_headers =
       SpdyUtils::SerializeUncompressedHeaders(headers_);
   stream_->OnStreamHeaders(uncompressed_headers);
   stream_->OnStreamHeadersComplete(false, uncompressed_headers.length());
 
   EXPECT_CALL(delegate_,
-              OnHeadersAvailable(headers_, uncompressed_headers.length()));
+              OnHeadersAvailableMock(_, uncompressed_headers.length()));
   base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(headers_, delegate_.headers_);
   EXPECT_TRUE(stream_->decompressed_headers().empty());
 
   const char data[] = "hello world!";
   stream_->OnStreamFrame(QuicStreamFrame(kTestStreamId, /*fin=*/false,
                                          /*offset=*/0, data));
   EXPECT_CALL(delegate_, OnDataAvailable())
       .WillOnce(testing::Invoke(CreateFunctor(
           &QuicChromiumClientStream::Reset,
           base::Unretained(stream_), QUIC_STREAM_CANCELLED)));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_CALL(delegate_, OnClose());
 }
 
 TEST_P(QuicChromiumClientStreamTest, OnError) {
   EXPECT_CALL(delegate_, OnError(ERR_INTERNET_DISCONNECTED));
 
   stream_->OnError(ERR_INTERNET_DISCONNECTED);
   EXPECT_FALSE(stream_->GetDelegate());
 }
 
 TEST_P(QuicChromiumClientStreamTest, OnTrailers) {
   InitializeHeaders();
   std::string uncompressed_headers =
       SpdyUtils::SerializeUncompressedHeaders(headers_);
   stream_->OnStreamHeaders(uncompressed_headers);
   stream_->OnStreamHeadersComplete(false, uncompressed_headers.length());
 
   EXPECT_CALL(delegate_,
-              OnHeadersAvailable(headers_, uncompressed_headers.length()));
+              OnHeadersAvailableMock(_, uncompressed_headers.length()));
   base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(headers_, delegate_.headers_);
   EXPECT_TRUE(stream_->decompressed_headers().empty());
 
   const char data[] = "hello world!";
   stream_->OnStreamFrame(QuicStreamFrame(kTestStreamId, /*fin=*/false,
                                          /*offset=*/0, data));
 
   EXPECT_CALL(delegate_, OnDataAvailable())
       .WillOnce(testing::Invoke(CreateFunctor(
           &QuicChromiumClientStreamTest::ReadData, base::Unretained(this),
           StringPiece(data, arraysize(data) - 1))));
 
   SpdyHeaderBlock trailers;
   trailers["bar"] = "foo";
   trailers[kFinalOffsetHeaderKey] = base::IntToString(strlen(data));
   std::string uncompressed_trailers =
       SpdyUtils::SerializeUncompressedHeaders(trailers);
 
   stream_->OnStreamHeaders(uncompressed_trailers);
   stream_->OnStreamHeadersComplete(true, uncompressed_trailers.length());
 
-  SpdyHeaderBlock actual_trailers;
-
   base::RunLoop run_loop;
-  EXPECT_CALL(delegate_, OnHeadersAvailable(_, uncompressed_trailers.length()))
-      .WillOnce(testing::DoAll(
-          testing::SaveArg<0>(&actual_trailers),
-          testing::InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); })));
+  EXPECT_CALL(delegate_,
+              OnHeadersAvailableMock(_, uncompressed_trailers.length()))
+      .WillOnce(testing::InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
 
   run_loop.Run();
   // Make sure kFinalOffsetHeaderKey is gone from the delivered actual trailers.
   trailers.erase(kFinalOffsetHeaderKey);
-  EXPECT_EQ(trailers, actual_trailers);
+  EXPECT_EQ(trailers, delegate_.headers_);
   base::RunLoop().RunUntilIdle();
   EXPECT_CALL(delegate_, OnClose());
 }
 
 // Tests that trailers are marked as consumed only before delegate is to be
 // immediately notified about trailers.
 TEST_P(QuicChromiumClientStreamTest, MarkTrailersConsumedWhenNotifyDelegate) {
   InitializeHeaders();
   std::string uncompressed_headers =
       SpdyUtils::SerializeUncompressedHeaders(headers_);
   stream_->OnStreamHeaders(uncompressed_headers);
   stream_->OnStreamHeadersComplete(false, uncompressed_headers.length());
 
   EXPECT_CALL(delegate_,
-              OnHeadersAvailable(headers_, uncompressed_headers.length()));
+              OnHeadersAvailableMock(_, uncompressed_headers.length()));
   base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(headers_, delegate_.headers_);
   EXPECT_TRUE(stream_->decompressed_headers().empty());
 
   const char data[] = "hello world!";
   stream_->OnStreamFrame(QuicStreamFrame(kTestStreamId, /*fin=*/false,
                                          /*offset=*/0, data));
 
   base::RunLoop run_loop;
   EXPECT_CALL(delegate_, OnDataAvailable())
       .Times(1)
       .WillOnce(testing::DoAll(
@@ skipping 28 matching lines @@
       .WillOnce(testing::DoAll(
           testing::Invoke(CreateFunctor(&QuicChromiumClientStreamTest::ReadData,
                                         base::Unretained(this), StringPiece())),
           testing::InvokeWithoutArgs([&run_loop2]() { run_loop2.Quit(); })));
   run_loop2.Run();
   // Make sure that the stream is not closed, even though ReadData returns 0.
   EXPECT_FALSE(stream_->IsDoneReading());
 
   // The OnHeadersAvailable call should follow.
   base::RunLoop run_loop3;
-  SpdyHeaderBlock actual_trailers;
   EXPECT_CALL(delegate_,
-              OnHeadersAvailable(_, uncompressed_trailers.length()))
-      .WillOnce(testing::DoAll(
-          testing::SaveArg<0>(&actual_trailers),
-          testing::InvokeWithoutArgs([&run_loop3]() { run_loop3.Quit(); })));
+              OnHeadersAvailableMock(_, uncompressed_trailers.length()))
+      .WillOnce(
+          testing::InvokeWithoutArgs([&run_loop3]() { run_loop3.Quit(); }));
 
   run_loop3.Run();
   // Make sure the stream is properly closed since trailers and data are all
   // consumed.
   EXPECT_TRUE(stream_->IsDoneReading());
   // Make sure kFinalOffsetHeaderKey is gone from the delivered actual trailers.
   trailers.erase(kFinalOffsetHeaderKey);
-  EXPECT_EQ(trailers, actual_trailers);
+  EXPECT_EQ(trailers, delegate_.headers_);
 
   base::RunLoop().RunUntilIdle();
   EXPECT_CALL(delegate_, OnClose());
 }
 
 TEST_P(QuicChromiumClientStreamTest, WriteStreamData) {
   EXPECT_CALL(delegate_, OnClose());
 
   const char kData1[] = "hello world";
   const size_t kDataLen = arraysize(kData1);
@@ skipping 84 matching lines @@
   session_.ActivateStream(stream);
 
   InitializeHeaders();
   std::string uncompressed_headers =
       SpdyUtils::SerializeUncompressedHeaders(headers_);
   stream->OnStreamHeaders(uncompressed_headers);
   stream->OnStreamHeadersComplete(false, uncompressed_headers.length());
   EXPECT_TRUE(stream->decompressed_headers().empty());
 
   EXPECT_CALL(delegate_,
-              OnHeadersAvailable(headers_, uncompressed_headers.length()));
+              OnHeadersAvailableMock(_, uncompressed_headers.length()));
   stream->SetDelegate(&delegate_);
   base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(headers_, delegate_.headers_);
 
   // Times(2) because OnClose will be called for stream and stream_.
   EXPECT_CALL(delegate_, OnClose()).Times(2);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net