Make SpdyHeaderBlock non-copyable.

net/spdy/bidirectional_stream_spdy_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/spdy/bidirectional_stream_spdy_impl.h"
 
 #include <memory>
 #include <string>
 
 #include "base/macros.h"
@@ skipping 45 matching lines @@
 
   ~TestDelegateBase() override {}
 
   void OnStreamReady(bool request_headers_sent) override {
     CHECK(!on_failed_called_);
   }
 
   void OnHeadersReceived(const SpdyHeaderBlock& response_headers) override {
     CHECK(!on_failed_called_);
     CHECK(!not_expect_callback_);
-    response_headers_ = response_headers;
+    response_headers_ = response_headers.Clone();
     if (!do_not_start_read_)
       StartOrContinueReading();
   }
 
   void OnDataRead(int bytes_read) override {
     CHECK(!on_failed_called_);
     CHECK(!not_expect_callback_);
     on_data_read_count_++;
     CHECK_GE(bytes_read, OK);
     bytes_read_ += bytes_read;
     data_received_.append(read_buf_->data(), bytes_read);
     if (!do_not_start_read_)
       StartOrContinueReading();
   }
 
   void OnDataSent() override {
     CHECK(!on_failed_called_);
     CHECK(!not_expect_callback_);
     on_data_sent_count_++;
   }
 
   void OnTrailersReceived(const SpdyHeaderBlock& trailers) override {
     CHECK(!on_failed_called_);
-    trailers_ = trailers;
+    trailers_ = trailers.Clone();
     if (run_until_completion_)
       loop_->Quit();
   }
 
   void OnFailed(int error) override {
     CHECK(!on_failed_called_);
     CHECK(!not_expect_callback_);
     CHECK_NE(OK, error);
     error_ = error;
     on_failed_called_ = true;
@@ skipping 55 matching lines @@
   int64_t GetTotalReceivedBytes() const {
     return stream_->GetTotalReceivedBytes();
   }
 
   int64_t GetTotalSentBytes() const { return stream_->GetTotalSentBytes(); }
 
   // Const getters for internal states.
   const std::string& data_received() const { return data_received_; }
   int bytes_read() const { return bytes_read_; }
   int error() const { return error_; }
-  const SpdyHeaderBlock response_headers() const { return response_headers_; }
-  const SpdyHeaderBlock trailers() const { return trailers_; }
+  const SpdyHeaderBlock& response_headers() const { return response_headers_; }
+  const SpdyHeaderBlock& trailers() const { return trailers_; }
   int on_data_read_count() const { return on_data_read_count_; }
   int on_data_sent_count() const { return on_data_sent_count_; }
   bool on_failed_called() const { return on_failed_called_; }
 
   // Sets whether the delegate should automatically start reading.
   void set_do_not_start_read(bool do_not_start_read) {
     do_not_start_read_ = do_not_start_read;
   }
 
   // Cancels |stream_|.
@@ skipping 186 matching lines @@
   EXPECT_FALSE(delegate->on_failed_called());
 
   EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
   EXPECT_EQ(0, delegate->on_data_read_count());
   EXPECT_EQ(kProtoHTTP2, delegate->GetProtocol());
   EXPECT_EQ(0, delegate->GetTotalSentBytes());
   EXPECT_EQ(0, delegate->GetTotalReceivedBytes());
 }
 
 }  // namespace net