Make SpdyHeaderBlock non-copyable.

net/quic/bidirectional_stream_quic_impl_unittest.cc

 // Copyright 2016 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/bidirectional_stream_quic_impl.h"
 
 #include <utility>
 
 #include "base/callback_helpers.h"
 #include "base/memory/ptr_util.h"
@@ skipping 72 matching lines @@
     EXPECT_EQ(send_request_headers_automatically_, request_headers_sent);
     CHECK(!not_expect_callback_);
     is_ready_ = true;
     loop_->Quit();
   }
 
   void OnHeadersReceived(const SpdyHeaderBlock& response_headers) override {
     CHECK(!on_failed_called_);
     CHECK(!not_expect_callback_);
 
-    response_headers_ = response_headers;
+    response_headers_ = response_headers.Clone();
     loop_->Quit();
   }
 
   void OnDataRead(int bytes_read) override {
     CHECK(!on_failed_called_);
     CHECK(!not_expect_callback_);
     CHECK(!callback_.is_null());
 
     ++on_data_read_count_;
     CHECK_GE(bytes_read, OK);
     data_received_.append(read_buf_->data(), bytes_read);
     base::ResetAndReturn(&callback_).Run(bytes_read);
   }
 
   void OnDataSent() override {
     CHECK(!on_failed_called_);
     CHECK(!not_expect_callback_);
 
     ++on_data_sent_count_;
     loop_->Quit();
   }
 
   void OnTrailersReceived(const SpdyHeaderBlock& trailers) override {
     CHECK(!on_failed_called_);
     CHECK(!not_expect_callback_);
 
-    trailers_ = trailers;
+    trailers_ = trailers.Clone();
     loop_->Quit();
   }
 
   void OnFailed(int error) override {
     CHECK(!on_failed_called_);
     CHECK(!not_expect_callback_);
     CHECK_EQ(OK, error_);
     CHECK_NE(OK, error);
 
     on_failed_called_ = true;
@@ skipping 355 matching lines @@
       size_t* spdy_headers_frame_length,
       QuicStreamOffset* offset) {
     return server_maker_.MakeResponseHeadersPacket(
         packet_number, stream_id_, !kIncludeVersion, fin,
         std::move(response_headers), spdy_headers_frame_length, offset);
   }
 
   std::unique_ptr<QuicReceivedPacket> ConstructResponseTrailersPacket(
       QuicPacketNumber packet_number,
       bool fin,
-      const SpdyHeaderBlock& trailers,
+      SpdyHeaderBlock trailers,
       size_t* spdy_headers_frame_length,
       QuicStreamOffset* offset) {
     return server_maker_.MakeResponseHeadersPacket(
-        packet_number, stream_id_, !kIncludeVersion, fin, trailers,
+        packet_number, stream_id_, !kIncludeVersion, fin, std::move(trailers),
         spdy_headers_frame_length, offset);
   }
 
   std::unique_ptr<QuicReceivedPacket> ConstructClientRstStreamPacket(
       QuicPacketNumber packet_number) {
     return ConstructRstStreamCancelledPacket(packet_number, 0, &client_maker_);
   }
 
   std::unique_ptr<QuicReceivedPacket> ConstructServerRstStreamPacket(
       QuicPacketNumber packet_number) {
@@ skipping 141 matching lines @@
   EXPECT_EQ(std::string(kResponseBody), delegate->data_received());
   TestCompletionCallback cb2;
   EXPECT_EQ(ERR_IO_PENDING, delegate->ReadData(cb2.callback()));
 
   SpdyHeaderBlock trailers;
   size_t spdy_trailers_frame_length;
   trailers["foo"] = "bar";
   trailers[kFinalOffsetHeaderKey] = base::IntToString(strlen(kResponseBody));
   // Server sends trailers.
   ProcessPacket(ConstructResponseTrailersPacket(
-      4, kFin, trailers, &spdy_trailers_frame_length, &offset));
+      4, kFin, trailers.Clone(), &spdy_trailers_frame_length, &offset));
 
   delegate->WaitUntilNextCallback();  // OnTrailersReceived
   EXPECT_EQ(OK, cb2.WaitForResult());
   trailers.erase(kFinalOffsetHeaderKey);
   EXPECT_EQ(trailers, delegate->trailers());
 
   EXPECT_EQ(OK, delegate->ReadData(cb2.callback()));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(2, delegate->on_data_read_count());
@@ skipping 103 matching lines @@
   delegate->SendvData({buf3, buf4, buf5},
                       {buf3->size(), buf4->size(), buf5->size()}, kFin);
   delegate->WaitUntilNextCallback();  // OnDataSent
 
   size_t spdy_trailers_frame_length;
   SpdyHeaderBlock trailers;
   trailers["foo"] = "bar";
   trailers[kFinalOffsetHeaderKey] = base::IntToString(strlen(kResponseBody));
   // Server sends trailers.
   ProcessPacket(ConstructResponseTrailersPacket(
-      4, kFin, trailers, &spdy_trailers_frame_length, &offset));
+      4, kFin, trailers.Clone(), &spdy_trailers_frame_length, &offset));
 
   delegate->WaitUntilNextCallback();  // OnTrailersReceived
   trailers.erase(kFinalOffsetHeaderKey);
   EXPECT_EQ(trailers, delegate->trailers());
   EXPECT_EQ(OK, delegate->ReadData(cb.callback()));
 
   EXPECT_EQ(1, delegate->on_data_read_count());
   EXPECT_EQ(2, delegate->on_data_sent_count());
   EXPECT_EQ(kProtoQUIC1SPDY3, delegate->GetProtocol());
   EXPECT_EQ(
@@ skipping 75 matching lines @@
 
   delegate->SendData(buf2, buf2->size(), true);
   delegate->WaitUntilNextCallback();  // OnDataSent
 
   size_t spdy_trailers_frame_length;
   SpdyHeaderBlock trailers;
   trailers["foo"] = "bar";
   trailers[kFinalOffsetHeaderKey] = base::IntToString(strlen(kResponseBody));
   // Server sends trailers.
   ProcessPacket(ConstructResponseTrailersPacket(
-      4, kFin, trailers, &spdy_trailers_frame_length, &offset));
+      4, kFin, trailers.Clone(), &spdy_trailers_frame_length, &offset));
 
   delegate->WaitUntilNextCallback();  // OnTrailersReceived
   trailers.erase(kFinalOffsetHeaderKey);
   EXPECT_EQ(trailers, delegate->trailers());
   EXPECT_EQ(OK, delegate->ReadData(cb.callback()));
 
   EXPECT_EQ(1, delegate->on_data_read_count());
   EXPECT_EQ(2, delegate->on_data_sent_count());
   EXPECT_EQ(kProtoQUIC1SPDY3, delegate->GetProtocol());
   EXPECT_EQ(static_cast<int64_t>(spdy_request_headers_frame_length +
@@ skipping 82 matching lines @@
   delegate->SendvData({buf3, buf4, buf5},
                       {buf3->size(), buf4->size(), buf5->size()}, kFin);
   delegate->WaitUntilNextCallback();  // OnDataSent
 
   size_t spdy_trailers_frame_length;
   SpdyHeaderBlock trailers;
   trailers["foo"] = "bar";
   trailers[kFinalOffsetHeaderKey] = base::IntToString(strlen(kResponseBody));
   // Server sends trailers.
   ProcessPacket(ConstructResponseTrailersPacket(
-      4, kFin, trailers, &spdy_trailers_frame_length, &offset));
+      4, kFin, trailers.Clone(), &spdy_trailers_frame_length, &offset));
 
   delegate->WaitUntilNextCallback();  // OnTrailersReceived
   trailers.erase(kFinalOffsetHeaderKey);
   EXPECT_EQ(trailers, delegate->trailers());
   EXPECT_EQ(OK, delegate->ReadData(cb.callback()));
 
   EXPECT_EQ(1, delegate->on_data_read_count());
   EXPECT_EQ(2, delegate->on_data_sent_count());
   EXPECT_EQ(kProtoQUIC1SPDY3, delegate->GetProtocol());
   EXPECT_EQ(
@@ skipping 59 matching lines @@
       ConstructServerDataPacket(3, !kIncludeVersion, !kFin, 0, kResponseBody));
 
   EXPECT_EQ(static_cast<int>(strlen(kResponseBody)), cb.WaitForResult());
 
   size_t spdy_trailers_frame_length;
   SpdyHeaderBlock trailers;
   trailers["foo"] = "bar";
   trailers[kFinalOffsetHeaderKey] = base::IntToString(strlen(kResponseBody));
   // Server sends trailers.
   ProcessPacket(ConstructResponseTrailersPacket(
-      4, kFin, trailers, &spdy_trailers_frame_length, &offset));
+      4, kFin, trailers.Clone(), &spdy_trailers_frame_length, &offset));
 
   delegate->WaitUntilNextCallback();  // OnTrailersReceived
   trailers.erase(kFinalOffsetHeaderKey);
   EXPECT_EQ(trailers, delegate->trailers());
   EXPECT_EQ(OK, delegate->ReadData(cb.callback()));
 
   EXPECT_EQ(1, delegate->on_data_read_count());
   EXPECT_EQ(1, delegate->on_data_sent_count());
   EXPECT_EQ(kProtoQUIC1SPDY3, delegate->GetProtocol());
   EXPECT_EQ(static_cast<int64_t>(spdy_request_headers_frame_length +
@@ skipping 56 matching lines @@
       ConstructServerDataPacket(3, !kIncludeVersion, !kFin, 0, kResponseBody));
 
   EXPECT_EQ(static_cast<int>(strlen(kResponseBody)), cb.WaitForResult());
 
   size_t spdy_trailers_frame_length;
   SpdyHeaderBlock trailers;
   trailers["foo"] = "bar";
   trailers[kFinalOffsetHeaderKey] = base::IntToString(strlen(kResponseBody));
   // Server sends trailers.
   ProcessPacket(ConstructResponseTrailersPacket(
-      4, kFin, trailers, &spdy_trailers_frame_length, &offset));
+      4, kFin, trailers.Clone(), &spdy_trailers_frame_length, &offset));
 
   delegate->WaitUntilNextCallback();  // OnTrailersReceived
   trailers.erase(kFinalOffsetHeaderKey);
   EXPECT_EQ(trailers, delegate->trailers());
   EXPECT_EQ(OK, delegate->ReadData(cb.callback()));
 
   EXPECT_EQ(1, delegate->on_data_read_count());
   EXPECT_EQ(1, delegate->on_data_sent_count());
   EXPECT_EQ(kProtoQUIC1SPDY3, delegate->GetProtocol());
   EXPECT_EQ(static_cast<int64_t>(spdy_request_headers_frame_length +
@@ skipping 498 matching lines @@
 
   EXPECT_EQ(static_cast<int64_t>(strlen(kResponseBody)), cb.WaitForResult());
   EXPECT_EQ(std::string(kResponseBody), delegate->data_received());
 
   size_t spdy_trailers_frame_length;
   SpdyHeaderBlock trailers;
   trailers["foo"] = "bar";
   trailers[kFinalOffsetHeaderKey] = base::IntToString(strlen(kResponseBody));
   // Server sends trailers.
   ProcessPacket(ConstructResponseTrailersPacket(
-      4, kFin, trailers, &spdy_trailers_frame_length, &offset));
+      4, kFin, trailers.Clone(), &spdy_trailers_frame_length, &offset));
 
   delegate->WaitUntilNextCallback();  // OnTrailersReceived
   trailers.erase(kFinalOffsetHeaderKey);
   EXPECT_EQ(trailers, delegate->trailers());
 
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(1, delegate->on_data_read_count());
   EXPECT_EQ(0, delegate->on_data_sent_count());
 }
 
 }  // namespace test
 
 }  // namespace net