Reduce SpdyHeaderBlock copies with move semantics in shared code.

net/quic/quic_spdy_stream.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_spdy_stream.h"
 
+#include <utility>
+
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "net/quic/quic_bug_tracker.h"
 #include "net/quic/quic_spdy_session.h"
 #include "net/quic/quic_utils.h"
 #include "net/quic/quic_write_blocked_list.h"
 #include "net/quic/spdy_utils.h"
 
 using base::StringPiece;
 using net::SpdyPriority;
@@ skipping 44 matching lines @@
       write_side_closed() && !rst_sent()) {
     DCHECK(fin_sent());
     // Tell the peer to stop sending further data.
     DVLOG(1) << ENDPOINT << "Send QUIC_STREAM_NO_ERROR on stream " << id();
     Reset(QUIC_STREAM_NO_ERROR);
   }
   ReliableQuicStream::StopReading();
 }
 
 size_t QuicSpdyStream::WriteHeaders(
-    const SpdyHeaderBlock& header_block,
+    SpdyHeaderBlock header_block,
     bool fin,
     QuicAckListenerInterface* ack_notifier_delegate) {
   size_t bytes_written = spdy_session_->WriteHeaders(
-      id(), header_block, fin, priority_, ack_notifier_delegate);
+      id(), std::move(header_block), fin, priority_, ack_notifier_delegate);
   if (fin) {
     // TODO(rch): Add test to ensure fin_sent_ is set whenever a fin is sent.
     set_fin_sent(true);
     CloseWriteSide();
   }
   return bytes_written;
 }
 
 void QuicSpdyStream::WriteOrBufferBody(
     const string& data,
     bool fin,
     QuicAckListenerInterface* ack_notifier_delegate) {
   WriteOrBufferData(data, fin, ack_notifier_delegate);
 }
 
 size_t QuicSpdyStream::WriteTrailers(
-    const SpdyHeaderBlock& trailer_block,
+    SpdyHeaderBlock trailer_block,
     QuicAckListenerInterface* ack_notifier_delegate) {
   if (fin_sent()) {
     QUIC_BUG << "Trailers cannot be sent after a FIN.";
     return 0;
   }
 
   // The header block must contain the final offset for this stream, as the
   // trailers may be processed out of order at the peer.
   DVLOG(1) << "Inserting trailer: (" << kFinalOffsetHeaderKey << ", "
            << stream_bytes_written() + queued_data_bytes() << ")";
-  SpdyHeaderBlock trailer_block_with_offset(trailer_block);
-  trailer_block_with_offset.insert(std::make_pair(
+  trailer_block.insert(std::make_pair(
       kFinalOffsetHeaderKey,
       base::IntToString(stream_bytes_written() + queued_data_bytes())));
 
   // Write the trailing headers with a FIN, and close stream for writing:
   // trailers are the last thing to be sent on a stream.
   const bool kFin = true;
   size_t bytes_written = spdy_session_->WriteHeaders(
-      id(), trailer_block_with_offset, kFin, priority_, ack_notifier_delegate);
+      id(), std::move(trailer_block), kFin, priority_, ack_notifier_delegate);
   set_fin_sent(kFin);
 
   // Trailers are the last thing to be sent on a stream, but if there is still
   // queued data then CloseWriteSide() will cause it never to be sent.
   if (queued_data_bytes() == 0) {
     CloseWriteSide();
   }
 
   return bytes_written;
 }
@@ skipping 149 matching lines @@
   }
   if (!fin) {
     DLOG(ERROR) << "Trailers must have FIN set, on stream: " << id();
     session()->connection()->CloseConnection(
         QUIC_INVALID_HEADERS_STREAM_DATA, "Fin missing from trailers",
         ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
     return;
   }
 
   size_t final_byte_offset = 0;
-  SpdyHeaderBlock trailers;
   if (!SpdyUtils::ParseTrailers(decompressed_trailers().data(),
                                 decompressed_trailers().length(),
                                 &final_byte_offset, &received_trailers_)) {
     DLOG(ERROR) << "Trailers are malformed: " << id();
     session()->connection()->CloseConnection(
         QUIC_INVALID_HEADERS_STREAM_DATA, "Trailers are malformed",
         ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
     return;
   }
 
@@ skipping 99 matching lines @@
 
 SpdyPriority QuicSpdyStream::priority() const {
   return priority_;
 }
 
 void QuicSpdyStream::ClearSession() {
   spdy_session_ = nullptr;
 }
 
 }  // namespace net