Reduce SpdyHeaderBlock copies with move semantics in shared code.

net/tools/quic/quic_simple_server_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/tools/quic/quic_simple_server_stream.h"
 
 #include <list>
+#include <utility>
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_split.h"
 #include "net/quic/quic_bug_tracker.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/quic_spdy_stream.h"
 #include "net/quic/spdy_utils.h"
@@ skipping 186 matching lines @@
   DVLOG(1) << "Sending response for stream " << id();
   SendHeadersAndBodyAndTrailers(response->headers(), response->body(),
                                 response->trailers());
 }
 
 void QuicSimpleServerStream::SendNotFoundResponse() {
   DVLOG(1) << "Sending not found response for stream " << id();
   SpdyHeaderBlock headers;
   headers[":status"] = "404";
   headers["content-length"] = base::IntToString(strlen(kNotFoundResponseBody));
-  SendHeadersAndBody(headers, kNotFoundResponseBody);
+  SendHeadersAndBody(std::move(headers), kNotFoundResponseBody);
 }
 
 void QuicSimpleServerStream::SendErrorResponse() {
   DVLOG(1) << "Sending error response for stream " << id();
   SpdyHeaderBlock headers;
   headers[":status"] = "500";
   headers["content-length"] = base::UintToString(strlen(kErrorResponseBody));
-  SendHeadersAndBody(headers, kErrorResponseBody);
+  SendHeadersAndBody(std::move(headers), kErrorResponseBody);
 }
 
 void QuicSimpleServerStream::SendHeadersAndBody(
-    const SpdyHeaderBlock& response_headers,
+    SpdyHeaderBlock response_headers,
     StringPiece body) {
-  SendHeadersAndBodyAndTrailers(response_headers, body, SpdyHeaderBlock());
+  SendHeadersAndBodyAndTrailers(std::move(response_headers), body,
+                                SpdyHeaderBlock());
 }
 
 void QuicSimpleServerStream::SendHeadersAndBodyAndTrailers(
-    const SpdyHeaderBlock& response_headers,
+    SpdyHeaderBlock response_headers,
     StringPiece body,
-    const SpdyHeaderBlock& response_trailers) {
+    SpdyHeaderBlock response_trailers) {
   // This server only supports SPDY and HTTP, and neither handles bidirectional
   // streaming.
   if (!reading_stopped()) {
     StopReading();
   }
 
   // Send the headers, with a FIN if there's nothing else to send.
   bool send_fin = (body.empty() && response_trailers.empty());
   DVLOG(1) << "Writing headers (fin = " << send_fin
            << ") : " << response_headers.DebugString();
-  WriteHeaders(response_headers, send_fin, nullptr);
+  WriteHeaders(std::move(response_headers), send_fin, nullptr);
   if (send_fin) {
     // Nothing else to send.
     return;
   }
 
   // Send the body, with a FIN if there's nothing else to send.
   send_fin = response_trailers.empty();
   DVLOG(1) << "Writing body (fin = " << send_fin
            << ") with size: " << body.size();
   WriteOrBufferData(body, send_fin, nullptr);
   if (send_fin) {
     // Nothing else to send.
     return;
   }
 
   // Send the trailers. A FIN is always sent with trailers.
   DVLOG(1) << "Writing trailers (fin = true): "
            << response_trailers.DebugString();
-  WriteTrailers(response_trailers, nullptr);
+  WriteTrailers(std::move(response_trailers), nullptr);
 }
 
 const char* const QuicSimpleServerStream::kErrorResponseBody = "bad";
 const char* const QuicSimpleServerStream::kNotFoundResponseBody =
     "file not found";
 
 }  // namespace net