Clang format slam.

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 <string>
 #include <vector>
 
@@ skipping 28 matching lines @@
 class SpdySession;
 class SpdySessionKey;
 class SpdySessionPool;
 class SpdyStream;
 class SpdyStreamRequest;
 
 // Default upload data used by both, mock objects and framer when creating
 // data frames.
 const char kDefaultURL[] = "http://www.google.com";
 const char kUploadData[] = "hello!";
-const int kUploadDataSize = arraysize(kUploadData)-1;
+const int kUploadDataSize = arraysize(kUploadData) - 1;
 
 // SpdyNextProtos returns a vector of next protocols for negotiating
 // SPDY.
 std::vector<NextProto> SpdyNextProtos();
 
 // Chop a frame into an array of MockWrites.
 // |data| is the frame to chop.
 // |length| is the length of the frame to chop.
 // |num_chunks| is the number of chunks to create.
 MockWrite* ChopWriteFrame(const char* data, int length, int num_chunks);
@@ skipping 34 matching lines @@
 // Create a MockRead from the given SpdyFrame.
 MockRead CreateMockRead(const SpdyFrame& resp);
 
 // Create a MockRead from the given SpdyFrame and sequence number.
 MockRead CreateMockRead(const SpdyFrame& resp, int seq);
 
 MockRead CreateMockRead(const SpdyFrame& resp, int seq, IoMode mode);
 
 // Combines the given SpdyFrames into the given char array and returns
 // the total length.
-int CombineFrames(const SpdyFrame** frames, int num_frames,
-                  char* buff, int buff_len);
+int CombineFrames(const SpdyFrame** frames,
+                  int num_frames,
+                  char* buff,
+                  int buff_len);
 
 // Returns the SpdyPriority embedded in the given frame.  Returns true
 // and fills in |priority| on success.
 bool GetSpdyPriority(SpdyMajorVersion version,
                      const SpdyFrame& frame,
                      SpdyPriority* priority);
 
 // Tries to create a stream in |session| synchronously. Returns NULL
 // on failure.
 base::WeakPtr<SpdyStream> CreateStreamSynchronously(
@@ skipping 193 matching lines @@
   scoped_ptr<SpdyHeaderBlock> ConstructPostHeaderBlock(
       base::StringPiece url,
       int64 content_length) const;
   scoped_ptr<SpdyHeaderBlock> ConstructPutHeaderBlock(
       base::StringPiece url,
       int64 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.
-  SpdyFrame* ConstructSpdyFrame(
-      const SpdyHeaderInfo& header_info,
-      scoped_ptr<SpdyHeaderBlock> headers) const;
+  SpdyFrame* ConstructSpdyFrame(const SpdyHeaderInfo& header_info,
+                                scoped_ptr<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.)
   SpdyFrame* ConstructSpdyFrame(const SpdyHeaderInfo& header_info,
                                 const char* const extra_headers[],
                                 int extra_header_count,
                                 const char* const tail_headers[],
                                 int tail_header_count) const;
 
   // Construct a generic SpdyControlFrame.
-  SpdyFrame* ConstructSpdyControlFrame(
-      scoped_ptr<SpdyHeaderBlock> headers,
-      bool compressed,
-      SpdyStreamId stream_id,
-      RequestPriority request_priority,
-      SpdyFrameType type,
-      SpdyControlFlags flags,
-      SpdyStreamId associated_stream_id) const;
+  SpdyFrame* ConstructSpdyControlFrame(scoped_ptr<SpdyHeaderBlock> headers,
+                                       bool compressed,
+                                       SpdyStreamId stream_id,
+                                       RequestPriority request_priority,
+                                       SpdyFrameType type,
+                                       SpdyControlFlags flags,
+                                       SpdyStreamId associated_stream_id) const;
 
   // Construct a generic SpdyControlFrame.
   //
   // Warning: extra_header_count is the number of header-value pairs in
   // extra_headers (so half the number of elements), but tail_headers_size is
   // the actual number of elements (both keys and values) in tail_headers.
   // TODO(ttuttle): Fix this inconsistency.
-  SpdyFrame* ConstructSpdyControlFrame(
-      const char* const extra_headers[],
-      int extra_header_count,
-      bool compressed,
-      SpdyStreamId stream_id,
-      RequestPriority request_priority,
-      SpdyFrameType type,
-      SpdyControlFlags flags,
-      const char* const* tail_headers,
-      int tail_headers_size,
-      SpdyStreamId associated_stream_id) const;
+  SpdyFrame* ConstructSpdyControlFrame(const char* const extra_headers[],
+                                       int extra_header_count,
+                                       bool compressed,
+                                       SpdyStreamId stream_id,
+                                       RequestPriority request_priority,
+                                       SpdyFrameType type,
+                                       SpdyControlFlags flags,
+                                       const char* const* tail_headers,
+                                       int tail_headers_size,
+                                       SpdyStreamId associated_stream_id) const;
 
   // Construct an expected SPDY reply string from the given headers.
   std::string ConstructSpdyReplyString(const SpdyHeaderBlock& headers) const;
 
   // Construct an expected SPDY SETTINGS frame.
   // |settings| are the settings to set.
   // Returns the constructed frame.  The caller takes ownership of the frame.
   SpdyFrame* ConstructSpdySettings(const SettingsMap& settings) const;
 
   // Construct a SPDY PING frame.
   // Returns the constructed frame.  The caller takes ownership of the frame.
   SpdyFrame* ConstructSpdyPing(uint32 ping_id, bool is_ack) const;
 
   // Construct a SPDY GOAWAY frame with last_good_stream_id = 0.
   // Returns the constructed frame.  The caller takes ownership of the frame.
   SpdyFrame* ConstructSpdyGoAway() const;
 
   // Construct a SPDY GOAWAY frame with the specified last_good_stream_id.
   // Returns the constructed frame.  The caller takes ownership of the frame.
   SpdyFrame* ConstructSpdyGoAway(SpdyStreamId last_good_stream_id) const;
 
   // Construct a SPDY WINDOW_UPDATE frame.
   // Returns the constructed frame.  The caller takes ownership of the frame.
-  SpdyFrame* ConstructSpdyWindowUpdate(
-      SpdyStreamId stream_id,
-      uint32 delta_window_size) const;
+  SpdyFrame* ConstructSpdyWindowUpdate(SpdyStreamId stream_id,
+                                       uint32 delta_window_size) const;
 
   // Construct a SPDY RST_STREAM frame.
   // Returns the constructed frame.  The caller takes ownership of the frame.
   SpdyFrame* ConstructSpdyRstStream(SpdyStreamId stream_id,
                                     SpdyRstStreamStatus status) const;
 
   // Constructs a standard SPDY GET SYN frame, optionally compressed
   // for the url |url|.
   // |extra_headers| are the extra header-value pairs, which typically
   // will vary the most between calls.
@@ skipping 92 matching lines @@
                                       int extra_header_count);
 
   // Constructs a standard SPDY SYN_REPLY frame to match the SPDY POST.
   // |extra_headers| are the extra header-value pairs, which typically
   // will vary the most between calls.
   // Returns a SpdyFrame.
   SpdyFrame* ConstructSpdyPostSynReply(const char* const extra_headers[],
                                        int extra_header_count);
 
   // Constructs a single SPDY data frame with the contents "hello!"
-  SpdyFrame* ConstructSpdyBodyFrame(int stream_id,
-                                    bool fin);
+  SpdyFrame* ConstructSpdyBodyFrame(int stream_id, bool fin);
 
   // Constructs a single SPDY data frame with the given content.
-  SpdyFrame* ConstructSpdyBodyFrame(int stream_id, const char* data,
-                                    uint32 len, bool fin);
+  SpdyFrame* ConstructSpdyBodyFrame(int stream_id,
+                                    const char* data,
+                                    uint32 len,
+                                    bool fin);
 
   // Wraps |frame| in the payload of a data frame in stream |stream_id|.
   SpdyFrame* ConstructWrappedSpdyFrame(const scoped_ptr<SpdyFrame>& frame,
                                        int stream_id);
 
   const SpdyHeaderInfo MakeSpdyHeader(SpdyFrameType type);
 
   // For versions below SPDY4, adds the version HTTP/1.1 header.
   void MaybeAddVersionHeader(SpdyFrameWithNameValueBlockIR* frame_ir) 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 is_spdy2() const { return protocol_ < kProtoSPDY3; }
   bool include_version_header() const { return protocol_ < kProtoSPDY4; }
   scoped_ptr<SpdyFramer> CreateFramer(bool compressed) const;
 
   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.
-  scoped_ptr<SpdyHeaderBlock> ConstructHeaderBlock(
-      base::StringPiece method,
-      base::StringPiece url,
-      int64* content_length) const;
+  scoped_ptr<SpdyHeaderBlock> ConstructHeaderBlock(base::StringPiece method,
+                                                   base::StringPiece url,
+                                                   int64* content_length) const;
 
   const NextProto protocol_;
   const SpdyMajorVersion spdy_version_;
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_TEST_UTIL_COMMON_H_