Reduce SpdyHeaderBlock copies with move semantics.

net/spdy/buffered_spdy_framer.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/buffered_spdy_framer.h"
 
+#include <utility>
+
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 
 namespace net {
 
 namespace {
 
 // GOAWAY frame debug data is only buffered up to this many bytes.
 size_t kGoAwayDebugDataMaxSize = 1024;
 
@@ skipping 352 matching lines @@
   return spdy_framer_.HasError();
 }
 
 // TODO(jgraettinger): Eliminate uses of this method (prefer
 // SpdySynStreamIR).
 SpdySerializedFrame* BufferedSpdyFramer::CreateSynStream(
     SpdyStreamId stream_id,
     SpdyStreamId associated_stream_id,
     SpdyPriority priority,
     SpdyControlFlags flags,
-    const SpdyHeaderBlock* headers) {
-  SpdySynStreamIR syn_stream(stream_id);
+    SpdyHeaderBlock headers) {
+  SpdySynStreamIR syn_stream(stream_id, std::move(headers));
   syn_stream.set_associated_to_stream_id(associated_stream_id);
   syn_stream.set_priority(priority);
   syn_stream.set_fin((flags & CONTROL_FLAG_FIN) != 0);
   syn_stream.set_unidirectional((flags & CONTROL_FLAG_UNIDIRECTIONAL) != 0);
-  // TODO(hkhalil): Avoid copy here.
-  syn_stream.set_header_block(*headers);
   return new SpdySerializedFrame(spdy_framer_.SerializeSynStream(syn_stream));
 }
 
 // TODO(jgraettinger): Eliminate uses of this method (prefer
 // SpdySynReplyIR).
 SpdySerializedFrame* BufferedSpdyFramer::CreateSynReply(
     SpdyStreamId stream_id,
     SpdyControlFlags flags,
-    const SpdyHeaderBlock* headers) {
-  SpdySynReplyIR syn_reply(stream_id);
+    SpdyHeaderBlock headers) {
+  SpdySynReplyIR syn_reply(stream_id, std::move(headers));
   syn_reply.set_fin(flags & CONTROL_FLAG_FIN);
-  // TODO(hkhalil): Avoid copy here.
-  syn_reply.set_header_block(*headers);
   return new SpdySerializedFrame(spdy_framer_.SerializeSynReply(syn_reply));
 }
 
 // TODO(jgraettinger): Eliminate uses of this method (prefer
 // SpdyRstStreamIR).
 SpdySerializedFrame* BufferedSpdyFramer::CreateRstStream(
     SpdyStreamId stream_id,
     SpdyRstStreamStatus status) const {
   SpdyRstStreamIR rst_ir(stream_id, status);
   return new SpdySerializedFrame(spdy_framer_.SerializeRstStream(rst_ir));
@@ skipping 31 matching lines @@
     base::StringPiece debug_data) const {
   SpdyGoAwayIR go_ir(last_accepted_stream_id, status, debug_data);
   return new SpdySerializedFrame(spdy_framer_.SerializeGoAway(go_ir));
 }
 
 // TODO(jgraettinger): Eliminate uses of this method (prefer SpdyHeadersIR).
 SpdySerializedFrame* BufferedSpdyFramer::CreateHeaders(
     SpdyStreamId stream_id,
     SpdyControlFlags flags,
     int weight,
-    const SpdyHeaderBlock* headers) {
-  SpdyHeadersIR headers_ir(stream_id);
+    SpdyHeaderBlock headers) {
+  SpdyHeadersIR headers_ir(stream_id, std::move(headers));
   headers_ir.set_fin((flags & CONTROL_FLAG_FIN) != 0);
   if (flags & HEADERS_FLAG_PRIORITY) {
     headers_ir.set_has_priority(true);
     headers_ir.set_weight(weight);
   }
-  headers_ir.set_header_block(*headers);
   return new SpdySerializedFrame(spdy_framer_.SerializeHeaders(headers_ir));
 }
 
 // TODO(jgraettinger): Eliminate uses of this method (prefer
 // SpdyWindowUpdateIR).
 SpdySerializedFrame* BufferedSpdyFramer::CreateWindowUpdate(
     SpdyStreamId stream_id,
     uint32_t delta_window_size) const {
   SpdyWindowUpdateIR update_ir(stream_id, delta_window_size);
   return new SpdySerializedFrame(spdy_framer_.SerializeWindowUpdate(update_ir));
 }
 
 // TODO(jgraettinger): Eliminate uses of this method (prefer SpdyDataIR).
 SpdySerializedFrame* BufferedSpdyFramer::CreateDataFrame(SpdyStreamId stream_id,
                                                          const char* data,
                                                          uint32_t len,
                                                          SpdyDataFlags flags) {
   SpdyDataIR data_ir(stream_id,
                      base::StringPiece(data, len));
   data_ir.set_fin((flags & DATA_FLAG_FIN) != 0);
   return new SpdySerializedFrame(spdy_framer_.SerializeData(data_ir));
 }
 
 // TODO(jgraettinger): Eliminate uses of this method (prefer SpdyPushPromiseIR).
 SpdySerializedFrame* BufferedSpdyFramer::CreatePushPromise(
     SpdyStreamId stream_id,
     SpdyStreamId promised_stream_id,
-    const SpdyHeaderBlock* headers) {
-  SpdyPushPromiseIR push_promise_ir(stream_id, promised_stream_id);
-  push_promise_ir.set_header_block(*headers);
+    SpdyHeaderBlock headers) {
+  SpdyPushPromiseIR push_promise_ir(stream_id, promised_stream_id,
+                                    std::move(headers));
   return new SpdySerializedFrame(
       spdy_framer_.SerializePushPromise(push_promise_ir));
 }
 
 SpdyPriority BufferedSpdyFramer::GetHighestPriority() const {
   return spdy_framer_.GetHighestPriority();
 }
 
 void BufferedSpdyFramer::InitHeaderStreaming(SpdyStreamId stream_id) {
   header_buffer_.clear();
   header_buffer_valid_ = true;
   header_stream_id_ = stream_id;
   DCHECK_NE(header_stream_id_, SpdyFramer::kInvalidStream);
 }
 
 }  // namespace net