Clang format slam.

net/spdy/buffered_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_BUFFERED_SPDY_FRAMER_H_
 #define NET_SPDY_BUFFERED_SPDY_FRAMER_H_
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "net/base/net_export.h"
 #include "net/socket/next_proto.h"
 #include "net/spdy/spdy_framer.h"
 #include "net/spdy/spdy_header_block.h"
 #include "net/spdy/spdy_protocol.h"
 
 namespace net {
 
 // Returns the SPDY major version corresponding to the given NextProto
 // value, which must represent a SPDY-like protocol.
-NET_EXPORT_PRIVATE SpdyMajorVersion NextProtoToSpdyMajorVersion(
-    NextProto next_proto);
+NET_EXPORT_PRIVATE SpdyMajorVersion
+    NextProtoToSpdyMajorVersion(NextProto next_proto);
 
 class NET_EXPORT_PRIVATE BufferedSpdyFramerVisitorInterface {
  public:
   BufferedSpdyFramerVisitorInterface() {}
 
   // Called if an error is detected in the SpdyFrame protocol.
   virtual void OnError(SpdyFramer::SpdyError error_code) = 0;
 
   // Called if an error is detected in a SPDY stream.
   virtual void OnStreamError(SpdyStreamId stream_id,
@@ skipping 70 matching lines @@
  protected:
   virtual ~BufferedSpdyFramerVisitorInterface() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BufferedSpdyFramerVisitorInterface);
 };
 
 class NET_EXPORT_PRIVATE BufferedSpdyFramer
     : public SpdyFramerVisitorInterface {
  public:
-  BufferedSpdyFramer(SpdyMajorVersion version,
-                     bool enable_compression);
+  BufferedSpdyFramer(SpdyMajorVersion version, bool enable_compression);
   virtual ~BufferedSpdyFramer();
 
   // Sets callbacks to be called from the buffered spdy 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(BufferedSpdyFramerVisitorInterface* 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.
@@ skipping 10 matching lines @@
   virtual void OnSynReply(SpdyStreamId stream_id, bool fin) OVERRIDE;
   virtual void OnHeaders(SpdyStreamId stream_id, bool fin, bool end) OVERRIDE;
   virtual bool OnControlFrameHeaderData(SpdyStreamId stream_id,
                                         const char* header_data,
                                         size_t len) OVERRIDE;
   virtual void OnStreamFrameData(SpdyStreamId stream_id,
                                  const char* data,
                                  size_t len,
                                  bool fin) OVERRIDE;
   virtual void OnSettings(bool clear_persisted) OVERRIDE;
-  virtual void OnSetting(
-      SpdySettingsIds id, uint8 flags, uint32 value) OVERRIDE;
+  virtual void OnSetting(SpdySettingsIds id,
+                         uint8 flags,
+                         uint32 value) OVERRIDE;
   virtual void OnSettingsAck() OVERRIDE;
   virtual void OnSettingsEnd() OVERRIDE;
   virtual void OnPing(SpdyPingId unique_id, bool is_ack) OVERRIDE;
   virtual void OnRstStream(SpdyStreamId stream_id,
                            SpdyRstStreamStatus status) OVERRIDE;
   virtual void OnGoAway(SpdyStreamId last_accepted_stream_id,
                         SpdyGoAwayStatus status) OVERRIDE;
   virtual void OnWindowUpdate(SpdyStreamId stream_id,
                               uint32 delta_window_size) OVERRIDE;
   virtual void OnPushPromise(SpdyStreamId stream_id,
@@ skipping 17 matching lines @@
                              SpdyPriority priority,
                              SpdyControlFlags flags,
                              const SpdyHeaderBlock* headers);
   SpdyFrame* CreateSynReply(SpdyStreamId stream_id,
                             SpdyControlFlags flags,
                             const SpdyHeaderBlock* headers);
   SpdyFrame* CreateRstStream(SpdyStreamId stream_id,
                              SpdyRstStreamStatus status) const;
   SpdyFrame* CreateSettings(const SettingsMap& values) const;
   SpdyFrame* CreatePingFrame(uint32 unique_id, bool is_ack) const;
-  SpdyFrame* CreateGoAway(
-      SpdyStreamId last_accepted_stream_id,
-      SpdyGoAwayStatus status) const;
+  SpdyFrame* CreateGoAway(SpdyStreamId last_accepted_stream_id,
+                          SpdyGoAwayStatus status) const;
   SpdyFrame* CreateHeaders(SpdyStreamId stream_id,
                            SpdyControlFlags flags,
                            const SpdyHeaderBlock* headers);
-  SpdyFrame* CreateWindowUpdate(
-      SpdyStreamId stream_id,
-      uint32 delta_window_size) const;
+  SpdyFrame* CreateWindowUpdate(SpdyStreamId stream_id,
+                                uint32 delta_window_size) const;
   SpdyFrame* CreateDataFrame(SpdyStreamId stream_id,
                              const char* data,
                              uint32 len,
                              SpdyDataFlags flags);
 
   // Serialize a frame of unknown type.
   SpdySerializedFrame* SerializeFrame(const SpdyFrameIR& frame) {
     return spdy_framer_.SerializeFrame(frame);
   }
 
@@ skipping 53 matching lines @@
     bool unidirectional;
   };
   scoped_ptr<ControlFrameFields> control_frame_fields_;
 
   DISALLOW_COPY_AND_ASSIGN(BufferedSpdyFramer);
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_BUFFERED_SPDY_FRAMER_H_