Clang format slam.

net/socket_stream/socket_stream.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_SOCKET_STREAM_SOCKET_STREAM_H_
 #define NET_SOCKET_STREAM_SOCKET_STREAM_H_
 
 #include <deque>
 #include <map>
 #include <string>
@@ skipping 54 matching lines @@
 
     // Called when a socket stream has been connected.  The socket stream is
     // allowed to buffer pending send data at most |max_pending_send_allowed|
     // bytes.  A client of the socket stream should keep track of how much
     // pending send data it has and must not call SendData() if the pending
     // data goes over |max_pending_send_allowed| bytes.
     virtual void OnConnected(SocketStream* socket,
                              int max_pending_send_allowed) = 0;
 
     // Called when |amount_sent| bytes of data are sent.
-    virtual void OnSentData(SocketStream* socket,
-                            int amount_sent) = 0;
+    virtual void OnSentData(SocketStream* socket, int amount_sent) = 0;
 
     // Called when |len| bytes of |data| are received.
     virtual void OnReceivedData(SocketStream* socket,
-                                const char* data, int len) = 0;
+                                const char* data,
+                                int len) = 0;
 
     // Called when the socket stream has been closed.
     virtual void OnClose(SocketStream* socket) = 0;
 
     // Called when proxy authentication required.
     // The delegate should call RestartWithAuth() if credential for |auth_info|
     // is found in password database, or call Close() to close the connection.
     virtual void OnAuthRequired(SocketStream* socket,
                                 AuthChallengeInfo* auth_info);
 
@@ skipping 17 matching lines @@
     // cookie.
     virtual bool CanSetCookie(SocketStream* request,
                               const GURL& url,
                               const std::string& cookie_line,
                               CookieOptions* options);
 
    protected:
     virtual ~Delegate() {}
   };
 
-  SocketStream(const GURL& url, Delegate* delegate, URLRequestContext* context,
+  SocketStream(const GURL& url,
+               Delegate* delegate,
+               URLRequestContext* context,
                CookieStore* cookie_store);
 
   // The user data allows the clients to associate data with this job.
   // Multiple user data values can be stored under different keys.
   // This job will TAKE OWNERSHIP of the given data pointer, and will
   // delete the object if it is changed or the job is destroyed.
   UserData* GetUserData(const void* key) const;
   void SetUserData(const void* key, UserData* data);
 
   const GURL& url() const { return url_; }
@@ skipping 63 matching lines @@
 
  private:
   FRIEND_TEST_ALL_PREFIXES(SocketStreamTest, IOPending);
   FRIEND_TEST_ALL_PREFIXES(SocketStreamTest, SwitchAfterPending);
   FRIEND_TEST_ALL_PREFIXES(SocketStreamTest,
                            NullContextSocketStreamShouldNotCrash);
 
   friend class WebSocketThrottleTest;
 
   typedef std::map<const void*, linked_ptr<UserData> > UserDataMap;
-  typedef std::deque< scoped_refptr<IOBufferWithSize> > PendingDataQueue;
+  typedef std::deque<scoped_refptr<IOBufferWithSize> > PendingDataQueue;
 
   class RequestHeaders : public IOBuffer {
    public:
     RequestHeaders() : IOBuffer() {}
 
     void SetDataOffset(size_t offset) {
       data_ = const_cast<char*>(headers_.data()) + offset;
     }
 
     std::string headers_;
 
-    private:
-     virtual ~RequestHeaders();
+   private:
+    virtual ~RequestHeaders();
   };
 
   class ResponseHeaders : public IOBuffer {
    public:
     ResponseHeaders();
 
     void SetDataOffset(size_t offset) { data_ = headers_.get() + offset; }
     char* headers() const { return headers_.get(); }
     void Reset() { headers_.reset(); }
     void Realloc(size_t new_size);
 
    private:
-     virtual ~ResponseHeaders();
+    virtual ~ResponseHeaders();
 
     scoped_ptr<char, base::FreeDeleter> headers_;
   };
 
   enum State {
     STATE_NONE,
     STATE_BEFORE_CONNECT,
     STATE_BEFORE_CONNECT_COMPLETE,
     STATE_RESOLVE_PROXY,
     STATE_RESOLVE_PROXY_COMPLETE,
@@ skipping 19 matching lines @@
     STATE_SSL_CONNECT_COMPLETE,
     STATE_SSL_HANDLE_CERT_ERROR,
     STATE_SSL_HANDLE_CERT_ERROR_COMPLETE,
     STATE_READ_WRITE,
     STATE_AUTH_REQUIRED,
     STATE_CLOSE,
   };
 
   enum ProxyMode {
     kDirectConnection,  // If using a direct connection
-    kTunnelProxy,  // If using a tunnel (CONNECT method as HTTPS)
-    kSOCKSProxy,  // If using a SOCKS proxy
+    kTunnelProxy,       // If using a tunnel (CONNECT method as HTTPS)
+    kSOCKSProxy,        // If using a SOCKS proxy
   };
 
   // Use the same number as HttpNetworkTransaction::kMaxHeaderBufSize.
   enum { kMaxTunnelResponseHeadersSize = 32768 };  // 32 kilobytes.
 
   // Used for WebSocketThrottleTest.
   void set_addresses(const AddressList& addresses);
 
   void DoClose();
 
@@ skipping 115 matching lines @@
 
   // Cookie store to use for this socket stream.
   scoped_refptr<CookieStore> cookie_store_;
 
   DISALLOW_COPY_AND_ASSIGN(SocketStream);
 };
 
 }  // namespace net
 
 #endif  // NET_SOCKET_STREAM_SOCKET_STREAM_H_