Make SpdyHeaderBlock non-copyable.

net/quic/quic_chromium_client_stream.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 <utility>
 
+#include "base/bind_helpers.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/quic/quic_chromium_client_session.h"
 #include "net/quic/quic_http_utils.h"
 #include "net/quic/quic_spdy_session.h"
 #include "net/quic/quic_write_blocked_list.h"
 #include "net/quic/spdy_utils.h"
@@ skipping 16 matching lines @@
   if (delegate_)
     delegate_->OnClose();
 }
 
 void QuicChromiumClientStream::OnStreamHeadersComplete(bool fin,
                                                        size_t frame_len) {
   QuicSpdyStream::OnStreamHeadersComplete(fin, frame_len);
   if (decompressed_headers().empty() && !decompressed_trailers().empty()) {
     DCHECK(trailers_decompressed());
     // The delegate will read the trailers via a posted task.
-    NotifyDelegateOfHeadersCompleteLater(received_trailers(), frame_len);
+    NotifyDelegateOfHeadersCompleteLater(received_trailers().Clone(),
+                                         frame_len);
   } else {
     DCHECK(!headers_delivered_);
     SpdyHeaderBlock headers;
     SpdyFramer framer(HTTP2);
     size_t headers_len = decompressed_headers().length();
     const char* header_data = decompressed_headers().data();
     if (!framer.ParseHeaderBlockInBuffer(header_data, headers_len, &headers)) {
       DLOG(WARNING) << "Invalid headers";
       Reset(QUIC_BAD_APPLICATION_PAYLOAD);
       return;
     }
     MarkHeadersConsumed(headers_len);
     session_->OnInitialHeadersComplete(id(), headers);
 
     // The delegate will read the headers via a posted task.
-    NotifyDelegateOfHeadersCompleteLater(headers, frame_len);
+    NotifyDelegateOfHeadersCompleteLater(std::move(headers), frame_len);
   }
 }
 
 void QuicChromiumClientStream::OnInitialHeadersComplete(
     bool fin,
     size_t frame_len,
     const QuicHeaderList& header_list) {
   QuicSpdyStream::OnInitialHeadersComplete(fin, frame_len, header_list);
 
   SpdyHeaderBlock header_block;
   int64_t length = -1;
   if (!SpdyUtils::CopyAndValidateHeaders(header_list, &length, &header_block)) {
     DLOG(ERROR) << "Failed to parse header list: " << header_list.DebugString();
     ConsumeHeaderList();
     Reset(QUIC_BAD_APPLICATION_PAYLOAD);
     return;
   }
 
   ConsumeHeaderList();
   session_->OnInitialHeadersComplete(id(), header_block);
 
   // The delegate will read the headers via a posted task.
-  NotifyDelegateOfHeadersCompleteLater(header_block, frame_len);
+  NotifyDelegateOfHeadersCompleteLater(std::move(header_block), frame_len);
 }
 
 void QuicChromiumClientStream::OnTrailingHeadersComplete(
     bool fin,
     size_t frame_len,
     const QuicHeaderList& header_list) {
   QuicSpdyStream::OnTrailingHeadersComplete(fin, frame_len, header_list);
-  NotifyDelegateOfHeadersCompleteLater(received_trailers(), frame_len);
+  NotifyDelegateOfHeadersCompleteLater(received_trailers().Clone(), frame_len);
 }
 
 void QuicChromiumClientStream::OnPromiseHeadersComplete(
     QuicStreamId promised_id,
     size_t frame_len) {
   size_t headers_len = decompressed_headers().length();
   SpdyHeaderBlock headers;
   SpdyFramer framer(HTTP2);
   if (!framer.ParseHeaderBlockInBuffer(decompressed_headers().data(),
                                        headers_len, &headers)) {
@@ skipping 135 matching lines @@
   bool can_write = session()->connection()->CanWrite(HAS_RETRANSMITTABLE_DATA);
   if (!can_write) {
     session()->MarkConnectionLevelWriteBlocked(id());
     DCHECK(callback_.is_null());
     callback_ = callback;
   }
   return can_write;
 }
 
 void QuicChromiumClientStream::NotifyDelegateOfHeadersCompleteLater(
-    const SpdyHeaderBlock& headers,
+    SpdyHeaderBlock headers,
     size_t frame_len) {
-  RunOrBuffer(
-      base::Bind(&QuicChromiumClientStream::NotifyDelegateOfHeadersComplete,
-                 weak_factory_.GetWeakPtr(), headers, frame_len));
+  RunOrBuffer(base::Bind(
+      &QuicChromiumClientStream::NotifyDelegateOfHeadersComplete,
+      weak_factory_.GetWeakPtr(), base::Passed(std::move(headers)), frame_len));
 }
 
 void QuicChromiumClientStream::NotifyDelegateOfHeadersComplete(
     SpdyHeaderBlock headers,
     size_t frame_len) {
   if (!delegate_)
     return;
   // Only mark trailers consumed when we are about to notify delegate.
   if (headers_delivered_) {
     MarkTrailersConsumed(decompressed_trailers().length());
@@ skipping 28 matching lines @@
   } else {
     delegate_tasks_.push_back(closure);
   }
 }
 
 void QuicChromiumClientStream::DisableConnectionMigration() {
   can_migrate_ = false;
 }
 
 }  // namespace net