Reduce SpdyHeaderBlock copies with move semantics.

net/spdy/spdy_test_util_common.h

 // Copyright (c) 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.
 
 #ifndef NET_SPDY_SPDY_TEST_UTIL_COMMON_H_
 #define NET_SPDY_SPDY_TEST_UTIL_COMMON_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 278 matching lines @@
 
 class SpdyTestUtil {
  public:
   explicit SpdyTestUtil(NextProto protocol, bool dependency_priorities);
   ~SpdyTestUtil();
 
   // Add the appropriate headers to put |url| into |block|.
   void AddUrlToHeaderBlock(base::StringPiece url,
                            SpdyHeaderBlock* headers) const;
 
-  std::unique_ptr<SpdyHeaderBlock> ConstructGetHeaderBlock(
-      base::StringPiece url) const;
-  std::unique_ptr<SpdyHeaderBlock> ConstructGetHeaderBlockForProxy(
-      base::StringPiece url) const;
-  std::unique_ptr<SpdyHeaderBlock> ConstructHeadHeaderBlock(
-      base::StringPiece url,
-      int64_t content_length) const;
-  std::unique_ptr<SpdyHeaderBlock> ConstructPostHeaderBlock(
-      base::StringPiece url,
-      int64_t content_length) const;
-  std::unique_ptr<SpdyHeaderBlock> ConstructPutHeaderBlock(
-      base::StringPiece url,
-      int64_t content_length) const;
+  SpdyHeaderBlock ConstructGetHeaderBlock(base::StringPiece url) const;
+  SpdyHeaderBlock ConstructGetHeaderBlockForProxy(base::StringPiece url) const;
+  SpdyHeaderBlock ConstructHeadHeaderBlock(base::StringPiece url,
+                                           int64_t content_length) const;
+  SpdyHeaderBlock ConstructPostHeaderBlock(base::StringPiece url,
+                                           int64_t content_length) const;
+  SpdyHeaderBlock ConstructPutHeaderBlock(base::StringPiece url,
+                                          int64_t content_length) const;
 
   // Construct a SPDY frame.  If it is a SYN_STREAM or SYN_REPLY frame (as
   // specified in header_info.kind), the provided headers are included in the
   // frame.
-  SpdySerializedFrame* ConstructSpdyFrame(
-      const SpdyHeaderInfo& header_info,
-      std::unique_ptr<SpdyHeaderBlock> headers) const;
+  SpdySerializedFrame* ConstructSpdyFrame(const SpdyHeaderInfo& header_info,
+                                          SpdyHeaderBlock headers) const;
 
   // Construct a SPDY frame.  If it is a SYN_STREAM or SYN_REPLY frame (as
   // specified in header_info.kind), the headers provided in extra_headers and
   // (if non-NULL) tail_headers are concatenated and included in the frame.
   // (extra_headers must always be non-NULL.)
   SpdySerializedFrame* ConstructSpdyFrame(const SpdyHeaderInfo& header_info,
                                           const char* const extra_headers[],
                                           int extra_header_count,
                                           const char* const tail_headers[],
                                           int tail_header_count) const;
@@ skipping 75 matching lines @@
                                          int associated_stream_id,
                                          const char* url);
   SpdySerializedFrame* ConstructSpdyPush(const char* const extra_headers[],
                                          int extra_header_count,
                                          int stream_id,
                                          int associated_stream_id,
                                          const char* url,
                                          const char* status,
                                          const char* location);
 
-  SpdySerializedFrame* ConstructInitialSpdyPushFrame(
-      std::unique_ptr<SpdyHeaderBlock> headers,
-      int stream_id,
-      int associated_stream_id);
+  SpdySerializedFrame* ConstructInitialSpdyPushFrame(SpdyHeaderBlock headers,
+                                                     int stream_id,
+                                                     int associated_stream_id);
 
   SpdySerializedFrame* ConstructSpdyPushHeaders(
       int stream_id,
       const char* const extra_headers[],
       int extra_header_count);
 
   // Constructs a SPDY header frame with the request header compression context
   // with END_STREAM flag set to |fin|.
-  SpdySerializedFrame* ConstructSpdyResponseHeaders(
-      int stream_id,
-      const SpdyHeaderBlock& headers,
-      bool fin);
+  SpdySerializedFrame* ConstructSpdyResponseHeaders(int stream_id,
+                                                    SpdyHeaderBlock headers,
+                                                    bool fin);
 
   // Construct a SPDY syn (HEADERS or SYN_STREAM, depending on protocol
   // version) carrying exactly the given headers and priority.
   SpdySerializedFrame* ConstructSpdySyn(int stream_id,
-                                        const SpdyHeaderBlock& headers,
+                                        SpdyHeaderBlock headers,
                                         RequestPriority priority,
                                         bool fin);
 
   // Construct a SPDY reply (HEADERS or SYN_REPLY, depending on protocol
   // version) carrying exactly the given headers, and the default priority
   // (or no priority, depending on protocol version).
   SpdySerializedFrame* ConstructSpdyReply(int stream_id,
-                                          const SpdyHeaderBlock& headers);
+                                          SpdyHeaderBlock headers);
 
   // Constructs a standard SPDY SYN_REPLY frame to match the SPDY GET.
   // |extra_headers| are the extra header-value pairs, which typically
   // will vary the most between calls.
   // Returns a SpdySerializedFrame.
   SpdySerializedFrame* ConstructSpdyGetSynReply(
       const char* const extra_headers[],
       int extra_header_count,
       int stream_id);
 
@@ skipping 66 matching lines @@
 
   // Serialize a SpdyFrameIR with |headerless_spdy_framer_|.
   SpdySerializedFrame SerializeFrame(const SpdyFrameIR& frame_ir);
 
   // Called when necessary (when it will affect stream dependency specification
   // when setting dependencies based on priorioties) to notify the utility
   // class of stream destruction.
   void UpdateWithStreamDestruction(int stream_id);
 
   // For versions below SPDY4, adds the version HTTP/1.1 header.
-  void MaybeAddVersionHeader(SpdyFrameWithHeaderBlockIR* frame_ir) const;
   void MaybeAddVersionHeader(SpdyHeaderBlock* block) const;
 
   // Maps |priority| to SPDY version priority, and sets it on |frame_ir|.
   void SetPriority(RequestPriority priority, SpdySynStreamIR* frame_ir) const;
 
   NextProto protocol() const { return protocol_; }
   SpdyMajorVersion spdy_version() const { return spdy_version_; }
   bool include_version_header() const { return protocol_ < kProtoHTTP2; }
 
   const GURL& default_url() const { return default_url_; }
   void set_default_url(const GURL& url) { default_url_ = url; }
 
   const char* GetMethodKey() const;
   const char* GetStatusKey() const;
   const char* GetHostKey() const;
   const char* GetSchemeKey() const;
   const char* GetVersionKey() const;
   const char* GetPathKey() const;
 
  private:
   // |content_length| may be NULL, in which case the content-length
   // header will be omitted.
-  std::unique_ptr<SpdyHeaderBlock> ConstructHeaderBlock(
-      base::StringPiece method,
-      base::StringPiece url,
-      int64_t* content_length) const;
+  SpdyHeaderBlock ConstructHeaderBlock(base::StringPiece method,
+                                       base::StringPiece url,
+                                       int64_t* content_length) const;
 
   const NextProto protocol_;
   const SpdyMajorVersion spdy_version_;
 
   // Multiple SpdyFramers are required to keep track of header compression
   // state.
   // Use to serialize frames (request or response) without headers.
   SpdyFramer headerless_spdy_framer_;
   // Use to serialize request frames with headers.
   SpdyFramer request_spdy_framer_;
   // Use to serialize response frames with headers.
   SpdyFramer response_spdy_framer_;
 
   GURL default_url_;
   bool dependency_priorities_;
 
   // Track a FIFO list of the stream_id of all created requests by priority.
   std::map<int, std::vector<int>> priority_to_stream_id_list_;
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_TEST_UTIL_COMMON_H_