Make SpdyHeaderBlock non-copyable.

net/quic/quic_headers_stream_test.cc

 // Copyright 2013 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_headers_stream.h"
 
 #include <string>
 
 #include "base/strings/string_number_conversions.h"
 #include "net/quic/quic_utils.h"
@@ skipping 215 matching lines @@
   }
 
   void WriteHeadersAndCheckData(QuicStreamId stream_id,
                                 bool fin,
                                 SpdyPriority priority,
                                 SpdyFrameType type) {
     // Write the headers and capture the outgoing data
     EXPECT_CALL(session_, WritevData(headers_stream_, kHeadersStreamId, _, _,
                                      false, nullptr))
         .WillOnce(WithArgs<2>(Invoke(this, &QuicHeadersStreamTest::SaveIov)));
-    headers_stream_->WriteHeaders(stream_id, headers_, fin, priority, nullptr);
+    headers_stream_->WriteHeaders(stream_id, headers_.Clone(), fin, priority,
+                                  nullptr);
 
     // Parse the outgoing data and check that it matches was was written.
     if (type == SYN_STREAM) {
       EXPECT_CALL(visitor_,
                   OnHeaders(stream_id, kHasPriority,
                             Spdy3PriorityToHttp2Weight(priority),
                             /*parent_stream_id=*/0,
                             /*exclusive=*/false, fin, kFrameComplete));
     } else {
       EXPECT_CALL(visitor_,
@@ skipping 85 matching lines @@
 
 TEST_P(QuicHeadersStreamTest, WritePushPromises) {
   for (QuicStreamId stream_id = kClientDataStreamId1;
        stream_id < kClientDataStreamId3; stream_id += 2) {
     QuicStreamId promised_stream_id = NextPromisedStreamId();
     if (perspective() == Perspective::IS_SERVER) {
       // Write the headers and capture the outgoing data
       EXPECT_CALL(session_, WritevData(headers_stream_, kHeadersStreamId, _, _,
                                        false, nullptr))
           .WillOnce(WithArgs<2>(Invoke(this, &QuicHeadersStreamTest::SaveIov)));
-      headers_stream_->WritePushPromise(stream_id, promised_stream_id, headers_,
-                                        nullptr);
+      headers_stream_->WritePushPromise(stream_id, promised_stream_id,
+                                        headers_.Clone(), nullptr);
 
       // Parse the outgoing data and check that it matches was was written.
       EXPECT_CALL(visitor_,
                   OnPushPromise(stream_id, promised_stream_id, kFrameComplete));
       headers_handler_.reset(new TestHeadersHandler);
       EXPECT_CALL(visitor_, OnHeaderFrameStart(stream_id))
           .WillOnce(Return(headers_handler_.get()));
       EXPECT_CALL(visitor_, OnHeaderFrameEnd(stream_id, true)).Times(1);
       framer_->ProcessInput(saved_data_.data(), saved_data_.length());
       EXPECT_FALSE(framer_->HasError())
           << SpdyFramer::ErrorCodeToString(framer_->error_code());
       CheckHeaders();
       saved_data_.clear();
     } else {
-      EXPECT_DFATAL(headers_stream_->WritePushPromise(
-                        stream_id, promised_stream_id, headers_, nullptr),
-                    "Client shouldn't send PUSH_PROMISE");
+      EXPECT_DFATAL(
+          headers_stream_->WritePushPromise(stream_id, promised_stream_id,
+                                            headers_.Clone(), nullptr),
+          "Client shouldn't send PUSH_PROMISE");
     }
   }
 }
 
 TEST_P(QuicHeadersStreamTest, ProcessRawData) {
   for (QuicStreamId stream_id = kClientDataStreamId1;
        stream_id < kClientDataStreamId3; stream_id += 2) {
     for (bool fin : {false, true}) {
       for (SpdyPriority priority = 0; priority < 7; ++priority) {
         // Replace with "WriteHeadersAndSaveData"
         SpdySerializedFrame frame;
         if (perspective() == Perspective::IS_SERVER) {
-          SpdyHeadersIR headers_frame(stream_id, headers_);
+          SpdyHeadersIR headers_frame(stream_id, headers_.Clone());
           headers_frame.set_fin(fin);
           headers_frame.set_has_priority(true);
           headers_frame.set_weight(Spdy3PriorityToHttp2Weight(0));
           frame = framer_->SerializeFrame(headers_frame);
           EXPECT_CALL(session_, OnStreamHeadersPriority(stream_id, 0));
         } else {
-          SpdyHeadersIR headers_frame(stream_id, headers_);
+          SpdyHeadersIR headers_frame(stream_id, headers_.Clone());
           headers_frame.set_fin(fin);
           frame = framer_->SerializeFrame(headers_frame);
         }
         EXPECT_CALL(session_,
                     OnStreamHeaderList(stream_id, fin, frame.size(), _))
             .WillOnce(Invoke(this, &QuicHeadersStreamTest::SaveHeaderList));
         stream_frame_.data_buffer = frame.data();
         stream_frame_.data_length = frame.size();
         headers_stream_->OnStreamFrame(stream_frame_);
         stream_frame_.offset += frame.size();
         CheckHeaders();
       }
     }
   }
 }
 
 TEST_P(QuicHeadersStreamTest, ProcessPushPromise) {
   if (perspective() == Perspective::IS_SERVER)
     return;
   for (QuicStreamId stream_id = kClientDataStreamId1;
        stream_id < kClientDataStreamId3; stream_id += 2) {
     QuicStreamId promised_stream_id = NextPromisedStreamId();
-    SpdyPushPromiseIR push_promise(stream_id, promised_stream_id, headers_);
+    SpdyPushPromiseIR push_promise(stream_id, promised_stream_id,
+                                   headers_.Clone());
     SpdySerializedFrame frame(framer_->SerializeFrame(push_promise));
     if (perspective() == Perspective::IS_SERVER) {
       EXPECT_CALL(*connection_,
                   CloseConnection(QUIC_INVALID_HEADERS_STREAM_DATA,
                                   "PUSH_PROMISE not supported.", _))
           .WillRepeatedly(InvokeWithoutArgs(
               this, &QuicHeadersStreamTest::TearDownLocalConnectionState));
     } else {
       EXPECT_CALL(session_, OnPromiseHeaderList(stream_id, promised_stream_id,
                                                 frame.size(), _))
@@ skipping 15 matching lines @@
     return;
   }
   EXPECT_CALL(session_, OnHeadersHeadOfLineBlocking(_)).Times(0);
   testing::InSequence seq;
   bool fin = true;
   for (int stream_num = 0; stream_num < 10; stream_num++) {
     QuicStreamId stream_id = QuicClientDataStreamId(stream_num);
     // Replace with "WriteHeadersAndSaveData"
     SpdySerializedFrame frame;
     if (perspective() == Perspective::IS_SERVER) {
-      SpdyHeadersIR headers_frame(stream_id, headers_);
+      SpdyHeadersIR headers_frame(stream_id, headers_.Clone());
       headers_frame.set_fin(fin);
       headers_frame.set_has_priority(true);
       headers_frame.set_weight(Spdy3PriorityToHttp2Weight(0));
       frame = framer_->SerializeFrame(headers_frame);
       EXPECT_CALL(session_, OnStreamHeadersPriority(stream_id, 0));
     } else {
-      SpdyHeadersIR headers_frame(stream_id, headers_);
+      SpdyHeadersIR headers_frame(stream_id, headers_.Clone());
       headers_frame.set_fin(fin);
       frame = framer_->SerializeFrame(headers_frame);
     }
     EXPECT_CALL(session_, OnStreamHeaderList(stream_id, fin, frame.size(), _))
         .Times(1);
     stream_frame_.data_buffer = frame.data();
     stream_frame_.data_length = frame.size();
     headers_stream_->OnStreamFrame(stream_frame_);
     connection_->AdvanceTime(QuicTime::Delta::FromMilliseconds(1));
     stream_frame_.offset += frame.size();
   }
 }
 
 TEST_P(QuicHeadersStreamTest, NonEmptyHeaderHOLBlockedTime) {
   if (!FLAGS_quic_measure_headers_hol_blocking_time) {
     return;
   }
   QuicStreamId stream_id;
   bool fin = true;
   QuicStreamFrame stream_frames[10];
   SpdySerializedFrame frames[10];
   // First create all the frames in order
   {
     InSequence seq;
     for (int stream_num = 0; stream_num < 10; ++stream_num) {
       stream_id = QuicClientDataStreamId(stream_num);
       if (perspective() == Perspective::IS_SERVER) {
-        SpdyHeadersIR headers_frame(stream_id, headers_);
+        SpdyHeadersIR headers_frame(stream_id, headers_.Clone());
         headers_frame.set_fin(fin);
         headers_frame.set_has_priority(true);
         headers_frame.set_weight(Spdy3PriorityToHttp2Weight(0));
         frames[stream_num] = framer_->SerializeFrame(headers_frame);
         EXPECT_CALL(session_, OnStreamHeadersPriority(stream_id, 0)).Times(1);
       } else {
-        SpdyHeadersIR headers_frame(stream_id, headers_);
+        SpdyHeadersIR headers_frame(stream_id, headers_.Clone());
         headers_frame.set_fin(fin);
         frames[stream_num] = framer_->SerializeFrame(headers_frame);
       }
       stream_frames[stream_num].stream_id = stream_frame_.stream_id;
       stream_frames[stream_num].offset = stream_frame_.offset;
       stream_frames[stream_num].data_buffer = frames[stream_num].data();
       stream_frames[stream_num].data_length = frames[stream_num].size();
       DVLOG(1) << "make frame for stream " << stream_num << " offset "
                << stream_frames[stream_num].offset;
       stream_frame_.offset += frames[stream_num].size();
@@ skipping 19 matching lines @@
   headers_["key0"] = string(1 << 13, '.');
   headers_["key1"] = string(1 << 13, '.');
   headers_["key2"] = string(1 << 13, '.');
   for (QuicStreamId stream_id = kClientDataStreamId1;
        stream_id < kClientDataStreamId3; stream_id += 2) {
     for (bool fin : {false, true}) {
       for (SpdyPriority priority = 0; priority < 7; ++priority) {
         // Replace with "WriteHeadersAndSaveData"
         SpdySerializedFrame frame;
         if (perspective() == Perspective::IS_SERVER) {
-          SpdyHeadersIR headers_frame(stream_id, headers_);
+          SpdyHeadersIR headers_frame(stream_id, headers_.Clone());
           headers_frame.set_fin(fin);
           headers_frame.set_has_priority(true);
           headers_frame.set_weight(Spdy3PriorityToHttp2Weight(0));
           frame = framer_->SerializeFrame(headers_frame);
           EXPECT_CALL(session_, OnStreamHeadersPriority(stream_id, 0));
         } else {
-          SpdyHeadersIR headers_frame(stream_id, headers_);
+          SpdyHeadersIR headers_frame(stream_id, headers_.Clone());
           headers_frame.set_fin(fin);
           frame = framer_->SerializeFrame(headers_frame);
         }
         EXPECT_CALL(session_,
                     OnStreamHeaderList(stream_id, fin, frame.size(), _))
             .WillOnce(Invoke(this, &QuicHeadersStreamTest::SaveHeaderList));
         stream_frame_.data_buffer = frame.data();
         stream_frame_.data_length = frame.size();
         headers_stream_->OnStreamFrame(stream_frame_);
         stream_frame_.offset += frame.size();
@@ skipping 177 matching lines @@
           .Times(4);
     }
   }
   for (QuicStreamId stream_id = kClientDataStreamId1;
        stream_id < kClientDataStreamId3; stream_id += 2) {
     for (bool fin : {false, true}) {
       for (SpdyPriority priority = 0; priority < 7; ++priority) {
         // Replace with "WriteHeadersAndSaveData"
         SpdySerializedFrame frame;
         if (perspective() == Perspective::IS_SERVER) {
-          SpdyHeadersIR headers_frame(stream_id, headers_);
+          SpdyHeadersIR headers_frame(stream_id, headers_.Clone());
           headers_frame.set_fin(fin);
           headers_frame.set_has_priority(true);
           headers_frame.set_weight(Spdy3PriorityToHttp2Weight(0));
           frame = framer_->SerializeFrame(headers_frame);
           EXPECT_CALL(session_, OnStreamHeadersPriority(stream_id, 0));
         } else {
-          SpdyHeadersIR headers_frame(stream_id, headers_);
+          SpdyHeadersIR headers_frame(stream_id, headers_.Clone());
           headers_frame.set_fin(fin);
           frame = framer_->SerializeFrame(headers_frame);
         }
         EXPECT_CALL(session_,
                     OnStreamHeaderList(stream_id, fin, frame.size(), _))
             .WillOnce(Invoke(this, &QuicHeadersStreamTest::SaveHeaderList));
         stream_frame_.data_buffer = frame.data();
         stream_frame_.data_length = frame.size();
         connection_->AdvanceTime(QuicTime::Delta::FromMilliseconds(1));
         headers_stream_->OnStreamFrame(stream_frame_);
@@ skipping 36 matching lines @@
           connection_->AdvanceTime(QuicTime::Delta::FromMilliseconds(1));
         }
       }
     }
   }
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net