s/SYN_STREAM/HEADERS/ in frame types, method names, comments.

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 319 matching lines @@
   // Construct a SPDY WINDOW_UPDATE frame.
   // Returns the constructed frame.  The caller takes ownership of the frame.
   SpdySerializedFrame ConstructSpdyWindowUpdate(SpdyStreamId stream_id,
                                                 uint32_t delta_window_size);
 
   // Construct a SPDY RST_STREAM frame.
   // Returns the constructed frame.  The caller takes ownership of the frame.
   SpdySerializedFrame ConstructSpdyRstStream(SpdyStreamId stream_id,
                                              SpdyRstStreamStatus status);
 
-  // Constructs a standard SPDY GET SYN frame for |url| with header compression.
+  // Constructs a standard SPDY GET HEADERS frame for |url| with header
+  // compression.
   // |extra_headers| are the extra header-value pairs, which typically
   // will vary the most between calls.
   // Returns a SpdySerializedFrame.
   SpdySerializedFrame ConstructSpdyGet(const char* const url,
                                        SpdyStreamId stream_id,
                                        RequestPriority request_priority);
 
-  // Constructs a standard SPDY GET SYN frame with header compression.
+  // Constructs a standard SPDY GET HEADERS frame with header compression.
   // |extra_headers| are the extra header-value pairs, which typically
   // will vary the most between calls.  If |direct| is false, the
   // the full url will be used instead of simply the path.
   // Returns a SpdySerializedFrame.
   SpdySerializedFrame ConstructSpdyGet(const char* const extra_headers[],
                                        int extra_header_count,
                                        int stream_id,
                                        RequestPriority request_priority,
                                        bool direct);
 
-  // Constructs a standard SPDY SYN_STREAM frame for a CONNECT request.
+  // Constructs a SPDY HEADERS frame for a CONNECT request.
   SpdySerializedFrame ConstructSpdyConnect(const char* const extra_headers[],
                                            int extra_header_count,
                                            int stream_id,
                                            RequestPriority priority,
                                            const HostPortPair& host_port_pair);
 
-  // Constructs a standard SPDY push SYN frame.
+  // Constructs a SPDY PUSH_PROMISE frame.
   // |extra_headers| are the extra header-value pairs, which typically
   // will vary the most between calls.
   // Returns a SpdySerializedFrame.
   SpdySerializedFrame ConstructSpdyPush(const char* const extra_headers[],
                                         int extra_header_count,
                                         int stream_id,
                                         int associated_stream_id,
                                         const char* url);
   SpdySerializedFrame ConstructSpdyPush(const char* const extra_headers[],
                                         int extra_header_count,
@@ skipping 12 matching lines @@
       const char* const extra_headers[],
       int extra_header_count);
 
   // Constructs a HEADERS frame with the request header compression context with
   // END_STREAM flag set to |fin|.
   SpdySerializedFrame ConstructSpdyResponseHeaders(int stream_id,
                                                    SpdyHeaderBlock headers,
                                                    bool fin);
 
   // Construct a HEADERS frame carrying exactly the given headers and priority.
-  SpdySerializedFrame ConstructSpdySyn(int stream_id,
-                                       SpdyHeaderBlock headers,
-                                       RequestPriority priority,
-                                       bool fin);
+  SpdySerializedFrame ConstructSpdyHeaders(int stream_id,
+                                           SpdyHeaderBlock headers,
+                                           RequestPriority priority,
+                                           bool fin);
 
   // Construct a reply HEADERS frame carrying exactly the given headers and the
   // default priority.
   SpdySerializedFrame ConstructSpdyReply(int stream_id,
                                          SpdyHeaderBlock headers);
 
-  // Constructs a standard SPDY SYN_REPLY frame to match the SPDY GET.
+  // Constructs a standard SPDY HEADERS 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);
+  SpdySerializedFrame ConstructSpdyGetReply(const char* const extra_headers[],
+                                            int extra_header_count,
+                                            int stream_id);
 
-  // Constructs a standard SPDY SYN_REPLY frame to match the SPDY GET.
+  // Constructs a standard SPDY HEADERS 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 ConstructSpdyGetSynReplyRedirect(int stream_id);
+  SpdySerializedFrame ConstructSpdyGetReplyRedirect(int stream_id);
 
-  // Constructs a standard SPDY SYN_REPLY frame with an Internal Server
+  // Constructs a standard SPDY HEADERS frame with an Internal Server
   // Error status code.
   // Returns a SpdySerializedFrame.
-  SpdySerializedFrame ConstructSpdySynReplyError(int stream_id);
+  SpdySerializedFrame ConstructSpdyReplyError(int stream_id);
 
-  // Constructs a standard SPDY SYN_REPLY frame with the specified status code.
+  // Constructs a standard SPDY HEADERS frame with the specified status code.
   // Returns a SpdySerializedFrame.
-  SpdySerializedFrame ConstructSpdySynReplyError(
+  SpdySerializedFrame ConstructSpdyReplyError(
       const char* const status,
       const char* const* const extra_headers,
       int extra_header_count,
       int stream_id);
 
-  // Constructs a standard SPDY POST SYN frame.
+  // Constructs a standard SPDY POST HEADERS frame.
   // |extra_headers| are the extra header-value pairs, which typically
   // will vary the most between calls.
   // Returns a SpdySerializedFrame.
   SpdySerializedFrame ConstructSpdyPost(const char* url,
                                         SpdyStreamId stream_id,
                                         int64_t content_length,
                                         RequestPriority priority,
                                         const char* const extra_headers[],
                                         int extra_header_count);
 
-  // Constructs a chunked transfer SPDY POST SYN frame.
+  // Constructs a chunked transfer SPDY POST HEADERS frame.
   // |extra_headers| are the extra header-value pairs, which typically
   // will vary the most between calls.
   // Returns a SpdySerializedFrame.
   SpdySerializedFrame ConstructChunkedSpdyPost(
       const char* const extra_headers[],
       int extra_header_count);
 
-  // Constructs a standard SPDY SYN_REPLY frame to match the SPDY POST.
+  // Constructs a standard SPDY HEADERS frame to match the SPDY POST.
   // |extra_headers| are the extra header-value pairs, which typically
   // will vary the most between calls.
   // Returns a SpdySerializedFrame.
-  SpdySerializedFrame ConstructSpdyPostSynReply(
-      const char* const extra_headers[],
-      int extra_header_count);
+  SpdySerializedFrame ConstructSpdyPostReply(const char* const extra_headers[],
+                                             int extra_header_count);
 
   // Constructs a single SPDY data frame with the contents "hello!"
   SpdySerializedFrame ConstructSpdyDataFrame(int stream_id, bool fin);
 
   // Constructs a single SPDY data frame with the given content.
   SpdySerializedFrame ConstructSpdyDataFrame(int stream_id,
                                              const char* data,
                                              uint32_t len,
                                              bool fin);
 
@@ skipping 10 matching lines @@
       int stream_id);
 
   // 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);
 
-  // Maps |priority| to SPDY priority, and sets it on |frame_ir|.
-  void SetPriority(RequestPriority priority, SpdySynStreamIR* frame_ir) const;
-
   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* GetPathKey() const;
 
  private:
   // |content_length| may be NULL, in which case the content-length
@@ skipping 13 matching lines @@
 
   GURL default_url_;
 
   // 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_