Make SpdyHeaderBlock non-copyable.

net/spdy/spdy_framer_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/spdy/spdy_framer.h"
 
 #include <stdlib.h>
 #include <string.h>
 
 #include <algorithm>
@@ skipping 74 matching lines @@
     SpdyHeadersHandlerInterface* OnHeaderFrameStart(
         SpdyStreamId stream_id) override {
       if (headers_handler_ == nullptr) {
         headers_handler_.reset(new TestHeadersHandler);
       }
       return headers_handler_.get();
     }
 
     void OnHeaderFrameEnd(SpdyStreamId stream_id, bool end_headers) override {
       CHECK(!finished_);
-      frame_->set_header_block(headers_handler_->decoded_block());
+      frame_->set_header_block(headers_handler_->decoded_block().Clone());
       finished_ = true;
       if (end_headers) {
         headers_handler_.reset();
       }
     }
 
     void OnSynStream(SpdyStreamId stream_id,
                      SpdyStreamId associated_stream_id,
                      SpdyPriority priority,
                      bool fin,
@@ skipping 381 matching lines @@
   SpdyHeadersHandlerInterface* OnHeaderFrameStart(
       SpdyStreamId stream_id) override {
     if (headers_handler_ == nullptr) {
       headers_handler_.reset(new TestHeadersHandler);
     }
     return headers_handler_.get();
   }
 
   void OnHeaderFrameEnd(SpdyStreamId stream_id, bool end_headers) override {
     CHECK(headers_handler_ != nullptr);
-    headers_ = headers_handler_->decoded_block();
+    headers_ = headers_handler_->decoded_block().Clone();
     header_bytes_received_ = headers_handler_->header_bytes_parsed();
     if (end_headers) {
       headers_handler_.reset();
     }
   }
 
   bool OnControlFrameHeaderData(SpdyStreamId stream_id,
                                 const char* header_data,
                                 size_t len) override {
     VLOG(1) << "OnControlFrameHeaderData(" << stream_id << ", data, " << len
@@ skipping 1443 matching lines @@
   const char kHeader2[] = "header2";
   const char kHeader3[] = "header3";
   const char kValue1[] = "value1";
   const char kValue2[] = "value2";
   const char kValue3[] = "value3";
 
   // SYN_STREAM #1
   SpdyHeaderBlock block;
   block[kHeader1] = kValue1;
   block[kHeader2] = kValue2;
-  SpdySynStreamIR syn_ir_1(1, block);
+  SpdySynStreamIR syn_ir_1(1, block.Clone());
   SpdySerializedFrame syn_frame_1(send_framer.SerializeFrame(syn_ir_1));
 
   // SYN_STREAM #2
   block[kHeader3] = kValue3;
   SpdySynStreamIR syn_stream(3, std::move(block));
   SpdySerializedFrame syn_frame_2(send_framer.SerializeSynStream(syn_stream));
 
   // Decompress SYN_STREAM #1
   SpdySerializedFrame decompressed(
       SpdyFramerTestUtil::DecompressFrame(&recv_framer, syn_frame_1));
@@ skipping 1990 matching lines @@
 TEST_P(SpdyFramerTest, ReadCompressedSynStreamHeaderBlock) {
   if (!IsSpdy3()) {
     return;
   }
 
   SpdyFramer framer(spdy_version_);
   SpdySynStreamIR syn_stream(1);
   syn_stream.set_priority(1);
   syn_stream.SetHeader("aa", "vv");
   syn_stream.SetHeader("bb", "ww");
-  SpdyHeaderBlock headers = syn_stream.header_block();
   SpdySerializedFrame control_frame(framer.SerializeSynStream(syn_stream));
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = true;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.data()),
       control_frame.size());
   EXPECT_EQ(1, visitor.syn_frame_count_);
-  EXPECT_EQ(headers, visitor.headers_);
+  EXPECT_EQ(syn_stream.header_block(), visitor.headers_);
 }
 
 TEST_P(SpdyFramerTest, ReadCompressedSynReplyHeaderBlock) {
   if (!IsSpdy3()) {
     return;
   }
 
   SpdyFramer framer(spdy_version_);
   SpdySynReplyIR syn_reply(1);
   syn_reply.SetHeader("alpha", "beta");
   syn_reply.SetHeader("gamma", "delta");
-  SpdyHeaderBlock headers = syn_reply.header_block();
   SpdySerializedFrame control_frame(framer.SerializeSynReply(syn_reply));
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = true;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.data()),
       control_frame.size());
   EXPECT_EQ(1, visitor.syn_reply_frame_count_);
   EXPECT_EQ(0, visitor.headers_frame_count_);
-  EXPECT_EQ(headers, visitor.headers_);
+  EXPECT_EQ(syn_reply.header_block(), visitor.headers_);
 }
 
 TEST_P(SpdyFramerTest, ReadCompressedHeadersHeaderBlock) {
   SpdyFramer framer(spdy_version_);
   SpdyHeadersIR headers_ir(1);
   headers_ir.SetHeader("alpha", "beta");
   headers_ir.SetHeader("gamma", "delta");
-  SpdyHeaderBlock headers = headers_ir.header_block();
   SpdySerializedFrame control_frame(framer.SerializeHeaders(headers_ir));
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = true;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.data()),
       control_frame.size());
   EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_EQ(0, visitor.control_frame_header_data_count_);
   EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_);
   EXPECT_EQ(0, visitor.end_of_stream_count_);
-  EXPECT_EQ(headers, visitor.headers_);
+  EXPECT_EQ(headers_ir.header_block(), visitor.headers_);
 }
 
 TEST_P(SpdyFramerTest, ReadCompressedHeadersHeaderBlockWithHalfClose) {
   SpdyFramer framer(spdy_version_);
   SpdyHeadersIR headers_ir(1);
   headers_ir.set_fin(true);
   headers_ir.SetHeader("alpha", "beta");
   headers_ir.SetHeader("gamma", "delta");
-  SpdyHeaderBlock headers = headers_ir.header_block();
   SpdySerializedFrame control_frame(framer.SerializeHeaders(headers_ir));
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = true;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.data()),
       control_frame.size());
   EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_EQ(0, visitor.control_frame_header_data_count_);
   EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_);
   EXPECT_EQ(1, visitor.end_of_stream_count_);
-  EXPECT_EQ(headers, visitor.headers_);
+  EXPECT_EQ(headers_ir.header_block(), visitor.headers_);
 }
 
 TEST_P(SpdyFramerTest, ControlFrameAtMaxSizeLimit) {
   if (!IsSpdy3()) {
     // TODO(jgraettinger): This test setup doesn't work with HPACK.
     return;
   }
 
   // First find the size of the header value in order to just reach the control
   // frame max size.
@@ skipping 562 matching lines @@
 
 TEST_P(SpdyFramerTest, ReadCompressedPushPromise) {
   if (!IsHttp2()) {
     return;
   }
 
   SpdyFramer framer(spdy_version_);
   SpdyPushPromiseIR push_promise(42, 57);
   push_promise.SetHeader("foo", "bar");
   push_promise.SetHeader("bar", "foofoo");
-  SpdyHeaderBlock headers = push_promise.header_block();
   SpdySerializedFrame frame(framer.SerializePushPromise(push_promise));
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = true;
   visitor.SimulateInFramer(reinterpret_cast<unsigned char*>(frame.data()),
                            frame.size());
   EXPECT_EQ(42u, visitor.last_push_promise_stream_);
   EXPECT_EQ(57u, visitor.last_push_promise_promised_stream_);
-  EXPECT_EQ(headers, visitor.headers_);
+  EXPECT_EQ(push_promise.header_block(), visitor.headers_);
 }
 
 TEST_P(SpdyFramerTest, ReadHeadersWithContinuation) {
   if (!IsHttp2()) {
     return;
   }
 
   // frame-format off
   const unsigned char kInput[] = {
       0x00, 0x00, 0x14,                       // Length: 20
@@ skipping 1713 matching lines @@
 
     EXPECT_EQ(1, visitor->data_frame_count_);
     EXPECT_EQ(strlen(four_score), static_cast<unsigned>(visitor->data_bytes_));
     EXPECT_EQ(0, visitor->headers_frame_count_);
   }
 }
 
 }  // namespace test
 
 }  // namespace net