Clang format slam.

net/spdy/spdy_framer.h

 // 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.
 
 #ifndef NET_SPDY_SPDY_FRAMER_H_
 #define NET_SPDY_SPDY_FRAMER_H_
 
 #include <list>
 #include <map>
 #include <string>
@@ skipping 289 matching lines @@
     SPDY_CONTROL_PAYLOAD_TOO_LARGE,    // Control frame payload was too large.
     SPDY_ZLIB_INIT_FAILURE,            // The Zlib library could not initialize.
     SPDY_UNSUPPORTED_VERSION,          // Control frame has unsupported version.
     SPDY_DECOMPRESS_FAILURE,           // There was an error decompressing.
     SPDY_COMPRESS_FAILURE,             // There was an error compressing.
     SPDY_GOAWAY_FRAME_CORRUPT,         // GOAWAY frame could not be parsed.
     SPDY_RST_STREAM_FRAME_CORRUPT,     // RST_STREAM frame could not be parsed.
     SPDY_INVALID_DATA_FRAME_FLAGS,     // Data frame has invalid flags.
     SPDY_INVALID_CONTROL_FRAME_FLAGS,  // Control frame has invalid flags.
     SPDY_UNEXPECTED_FRAME,             // Frame received out of order.
-
-    LAST_ERROR,  // Must be the last entry in the enum.
+    LAST_ERROR,                        // Must be the last entry in the enum.
   };
 
   // Constant for invalid (or unknown) stream IDs.
   static const SpdyStreamId kInvalidStream;
 
   // The maximum size of header data chunks delivered to the framer visitor
   // through OnControlFrameHeaderData. (It is exposed here for unit test
   // purposes.)
   static const size_t kHeaderDataChunkMaxSize;
 
   // Serializes a SpdyHeaderBlock.
   static void WriteHeaderBlock(SpdyFrameBuilder* frame,
                                const SpdyMajorVersion spdy_version,
                                const SpdyHeaderBlock* headers);
 
   // Retrieve serialized length of SpdyHeaderBlock.
   // TODO(hkhalil): Remove, or move to quic code.
-  static size_t GetSerializedLength(
-      const SpdyMajorVersion spdy_version,
-      const SpdyHeaderBlock* headers);
+  static size_t GetSerializedLength(const SpdyMajorVersion spdy_version,
+                                    const SpdyHeaderBlock* headers);
 
   // Create a new Framer, provided a SPDY version.
   explicit SpdyFramer(SpdyMajorVersion version);
   virtual ~SpdyFramer();
 
   // Set callbacks to be called from the framer.  A visitor must be set, or
   // else the framer will likely crash.  It is acceptable for the visitor
   // to do nothing.  If this is called multiple times, only the last visitor
   // will be used.
-  void set_visitor(SpdyFramerVisitorInterface* visitor) {
-    visitor_ = visitor;
-  }
+  void set_visitor(SpdyFramerVisitorInterface* visitor) { visitor_ = visitor; }
 
   // Set debug callbacks to be called from the framer. The debug visitor is
   // completely optional and need not be set in order for normal operation.
   // If this is called multiple times, only the last visitor will be used.
   void set_debug_visitor(SpdyFramerDebugVisitorInterface* debug_visitor) {
     debug_visitor_ = debug_visitor;
   }
 
   // Pass data into the framer for parsing.
   // Returns the number of bytes consumed. It is safe to pass more bytes in
   // than may be consumed.
   size_t ProcessInput(const char* data, size_t len);
 
   // Resets the framer state after a frame has been successfully decoded.
   // TODO(mbelshe): can we make this private?
   void Reset();
 
   // Check the state of the framer.
   SpdyError error_code() const { return error_code_; }
   SpdyState state() const { return state_; }
   bool HasError() const { return state_ == SPDY_ERROR; }
 
   // Given a buffer containing a decompressed header block in SPDY
   // serialized format, parse out a SpdyHeaderBlock, putting the results
   // in the given header block.
   // Returns number of bytes consumed if successfully parsed, 0 otherwise.
   size_t ParseHeaderBlockInBuffer(const char* header_data,
-                                size_t header_length,
-                                SpdyHeaderBlock* block) const;
+                                  size_t header_length,
+                                  SpdyHeaderBlock* block) const;
 
   // Serialize a data frame.
   SpdySerializedFrame* SerializeData(const SpdyDataIR& data) const;
   // Serializes the data frame header and optionally padding length fields,
   // excluding actual data payload and padding.
   SpdySerializedFrame* SerializeDataFrameHeaderWithPaddingLengthField(
       const SpdyDataIR& data) const;
 
   // Serializes a SYN_STREAM frame.
   SpdySerializedFrame* SerializeSynStream(const SpdySynStreamIR& syn_stream);
@@ skipping 63 matching lines @@
   // using zlib anyway.
 
   // Compresses a SpdyFrame.
   // On success, returns a new SpdyFrame with the payload compressed.
   // Compression state is maintained as part of the SpdyFramer.
   // Returned frame must be freed with "delete".
   // On failure, returns NULL.
   SpdyFrame* CompressFrame(const SpdyFrame& frame);
 
   // For ease of testing and experimentation we can tweak compression on/off.
-  void set_enable_compression(bool value) {
-    enable_compression_ = value;
-  }
+  void set_enable_compression(bool value) { enable_compression_ = value; }
 
   // Used only in log messages.
   void set_display_protocol(const std::string& protocol) {
     display_protocol_ = protocol;
   }
 
   // Returns the (minimum) size of frames (sans variable-length portions).
   size_t GetDataFrameMinimumSize() const;
   size_t GetControlFrameHeaderSize() const;
   size_t GetSynStreamMinimumSize() const;
@@ skipping 37 matching lines @@
 
   SpdyPriority GetLowestPriority() const {
     return spdy_version_ < SPDY3 ? 3 : 7;
   }
 
   SpdyPriority GetHighestPriority() const { return 0; }
 
   // Deliver the given control frame's compressed headers block to the visitor
   // in decompressed form, in chunks. Returns true if the visitor has
   // accepted all of the chunks.
-  bool IncrementallyDecompressControlFrameHeaderData(
-      SpdyStreamId stream_id,
-      const char* data,
-      size_t len);
+  bool IncrementallyDecompressControlFrameHeaderData(SpdyStreamId stream_id,
+                                                     const char* data,
+                                                     size_t len);
 
  protected:
   // TODO(jgraettinger): Switch to test peer pattern.
   FRIEND_TEST_ALL_PREFIXES(SpdyFramerTest, BasicCompression);
   FRIEND_TEST_ALL_PREFIXES(SpdyFramerTest, ControlFrameSizesAreValidated);
   FRIEND_TEST_ALL_PREFIXES(SpdyFramerTest, HeaderCompression);
   FRIEND_TEST_ALL_PREFIXES(SpdyFramerTest, DecompressUncompressedFrame);
   FRIEND_TEST_ALL_PREFIXES(SpdyFramerTest, ExpandBuffer_HeapSmash);
   FRIEND_TEST_ALL_PREFIXES(SpdyFramerTest, HugeHeaderBlock);
   FRIEND_TEST_ALL_PREFIXES(SpdyFramerTest, UnclosedStreamDataCompressors);
   FRIEND_TEST_ALL_PREFIXES(SpdyFramerTest,
                            UnclosedStreamDataCompressorsOneByteAtATime);
   FRIEND_TEST_ALL_PREFIXES(SpdyFramerTest,
                            UncompressLargerThanFrameBufferInitialSize);
   FRIEND_TEST_ALL_PREFIXES(SpdyFramerTest, ReadLargeSettingsFrame);
-  FRIEND_TEST_ALL_PREFIXES(SpdyFramerTest,
-                           ReadLargeSettingsFrameInSmallChunks);
+  FRIEND_TEST_ALL_PREFIXES(SpdyFramerTest, ReadLargeSettingsFrameInSmallChunks);
   FRIEND_TEST_ALL_PREFIXES(SpdyFramerTest, ControlFrameAtMaxSizeLimit);
   FRIEND_TEST_ALL_PREFIXES(SpdyFramerTest, ControlFrameTooLarge);
   FRIEND_TEST_ALL_PREFIXES(SpdyFramerTest,
                            TooLargeHeadersFrameUsesContinuation);
   FRIEND_TEST_ALL_PREFIXES(SpdyFramerTest,
                            TooLargePushPromiseFrameUsesContinuation);
   friend class net::HttpNetworkLayer;  // This is temporary for the server.
   friend class net::HttpNetworkTransactionTest;
   friend class net::HttpProxyClientSocketPoolTest;
   friend class net::SpdyHttpStreamTest;
@@ skipping 59 matching lines @@
   bool IncrementallyDeliverControlFrameHeaderData(SpdyStreamId stream_id,
                                                   const char* data,
                                                   size_t len);
 
   // Utility to copy the given data block to the current frame buffer, up
   // to the given maximum number of bytes, and update the buffer
   // data (pointer and length). Returns the number of bytes
   // read, and:
   //   *data is advanced the number of bytes read.
   //   *len is reduced by the number of bytes read.
-  size_t UpdateCurrentFrameBuffer(const char** data, size_t* len,
+  size_t UpdateCurrentFrameBuffer(const char** data,
+                                  size_t* len,
                                   size_t max_bytes);
 
-  void WriteHeaderBlockToZ(const SpdyHeaderBlock* headers,
-                           z_stream* out) const;
+  void WriteHeaderBlockToZ(const SpdyHeaderBlock* headers, z_stream* out) const;
 
   void SerializeNameValueBlockWithoutCompression(
       SpdyFrameBuilder* builder,
       const SpdyNameValueBlock& name_value_block) const;
 
   // Compresses automatically according to enable_compression_.
-  void SerializeNameValueBlock(
-      SpdyFrameBuilder* builder,
-      const SpdyFrameWithNameValueBlockIR& frame);
+  void SerializeNameValueBlock(SpdyFrameBuilder* builder,
+                               const SpdyFrameWithNameValueBlockIR& frame);
 
   // Set the error code and moves the framer into the error state.
   void set_error(SpdyError error);
 
   // The maximum size of the control frames that we support.
   // This limit is arbitrary. We can enforce it here or at the application
   // layer. We chose the framing layer, but this can be changed (or removed)
   // if necessary later down the line.
   size_t GetControlFrameBufferMaxSize() const {
     // The theoretical maximum for SPDY3 and earlier is (2^24 - 1) +
     // 8, since the length field does not count the size of the
     // header.
     if (spdy_version_ == SPDY2) {
       return 64 * 1024;
     }
     if (spdy_version_ == SPDY3) {
       return 16 * 1024 * 1024;
     }
     // Absolute maximum size of HTTP2 frame payload (section 4.2 "Frame size").
-    return (1<<14) - 1;
+    return (1 << 14) - 1;
   }
 
   // The size of the control frame buffer.
   // Since this is only used for control frame headers, the maximum control
   // frame header size (SYN_STREAM) is sufficient; all remaining control
   // frame data is streamed to the visitor.
   static const size_t kControlFrameBufferSize;
 
   SpdyState state_;
   SpdyState previous_state_;
@@ skipping 76 matching lines @@
   // If a HEADERS frame is followed by a CONTINUATION frame, the FIN/END_STREAM
   // flag is still carried in the HEADERS frame. If it's set, flip this so that
   // we know to terminate the stream when the entire header block has been
   // processed.
   bool end_stream_when_done_;
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_FRAMER_H_