Clang format slam.

net/socket/socket_test_util.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_SOCKET_TEST_UTIL_H_
 #define NET_SOCKET_SOCKET_TEST_UTIL_H_
 
 #include <cstring>
 #include <deque>
 #include <string>
@@ skipping 34 matching lines @@
   // MockRead.  The other members of that MockRead are ignored.
   ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ = -10000,
 };
 
 class AsyncSocket;
 class MockClientSocket;
 class ServerBoundCertService;
 class SSLClientSocket;
 class StreamSocket;
 
-enum IoMode {
-  ASYNC,
-  SYNCHRONOUS
-};
+enum IoMode { ASYNC, SYNCHRONOUS };
 
 struct MockConnect {
   // Asynchronous connection success.
   // Creates a MockConnect with |mode| ASYC, |result| OK, and
   // |peer_addr| 192.0.2.33.
   MockConnect();
   // Creates a MockConnect with the specified mode and result, with
   // |peer_addr| 192.0.2.33.
   MockConnect(IoMode io_mode, int r);
   MockConnect(IoMode io_mode, int r, IPEndPoint addr);
   ~MockConnect();
 
   IoMode mode;
   int result;
   IPEndPoint peer_addr;
 };
 
 // MockRead and MockWrite shares the same interface and members, but we'd like
 // to have distinct types because we don't want to have them used
 // interchangably. To do this, a struct template is defined, and MockRead and
 // MockWrite are instantiated by using this template. Template parameter |type|
 // is not used in the struct definition (it purely exists for creating a new
 // type).
 //
 // |data| in MockRead and MockWrite has different meanings: |data| in MockRead
 // is the data returned from the socket when MockTCPClientSocket::Read() is
 // attempted, while |data| in MockWrite is the expected data that should be
 // given in MockTCPClientSocket::Write().
-enum MockReadWriteType {
-  MOCK_READ,
-  MOCK_WRITE
-};
+enum MockReadWriteType { MOCK_READ, MOCK_WRITE };
 
 template <MockReadWriteType type>
 struct MockReadWrite {
   // Flag to indicate that the message loop should be terminated.
-  enum {
-    STOPLOOP = 1 << 31
-  };
+  enum { STOPLOOP = 1 << 31 };
 
   // Default
   MockReadWrite()
       : mode(SYNCHRONOUS),
         result(0),
         data(NULL),
         data_len(0),
         sequence_number(0),
         time_stamp(base::Time::Now()) {}
 
@@ skipping 575 matching lines @@
   virtual void Disconnect() OVERRIDE;
   virtual bool IsConnected() const OVERRIDE;
   virtual bool IsConnectedAndIdle() const OVERRIDE;
   virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE;
   virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE;
   virtual const BoundNetLog& NetLog() const OVERRIDE;
   virtual void SetSubresourceSpeculation() OVERRIDE {}
   virtual void SetOmniboxSpeculation() OVERRIDE {}
 
   // SSLClientSocket implementation.
-  virtual void GetSSLCertRequestInfo(SSLCertRequestInfo* cert_request_info)
-      OVERRIDE;
+  virtual void GetSSLCertRequestInfo(
+      SSLCertRequestInfo* cert_request_info) OVERRIDE;
   virtual int ExportKeyingMaterial(const base::StringPiece& label,
                                    bool has_context,
                                    const base::StringPiece& context,
                                    unsigned char* out,
                                    unsigned int outlen) OVERRIDE;
   virtual int GetTLSUniqueChannelBinding(std::string* out) OVERRIDE;
   virtual NextProtoStatus GetNextProto(std::string* proto,
                                        std::string* server_protos) OVERRIDE;
   virtual ServerBoundCertService* GetServerBoundCertService() const OVERRIDE;
 
@@ skipping 237 matching lines @@
   virtual int Connect(const CompletionCallback& callback) OVERRIDE;
   virtual void Disconnect() OVERRIDE;
   virtual bool IsConnected() const OVERRIDE;
   virtual bool WasEverUsed() const OVERRIDE;
   virtual bool UsingTCPFastOpen() const OVERRIDE;
   virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE;
   virtual bool WasNpnNegotiated() const OVERRIDE;
   virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE;
 
   // SSLClientSocket implementation.
-  virtual void GetSSLCertRequestInfo(SSLCertRequestInfo* cert_request_info)
-      OVERRIDE;
+  virtual void GetSSLCertRequestInfo(
+      SSLCertRequestInfo* cert_request_info) OVERRIDE;
   virtual NextProtoStatus GetNextProto(std::string* proto,
                                        std::string* server_protos) OVERRIDE;
   virtual bool set_was_npn_negotiated(bool negotiated) OVERRIDE;
   virtual void set_protocol_negotiated(NextProto protocol_negotiated) OVERRIDE;
   virtual NextProto GetNegotiatedProtocol() const OVERRIDE;
 
   // This MockSocket does not implement the manual async IO feature.
   virtual void OnReadComplete(const MockRead& data) OVERRIDE;
   virtual void OnConnectComplete(const MockConnect& data) OVERRIDE;
 
@@ skipping 37 matching lines @@
   virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE;
   virtual const BoundNetLog& NetLog() const OVERRIDE;
 
   // DatagramClientSocket implementation.
   virtual int Connect(const IPEndPoint& address) OVERRIDE;
 
   // AsyncSocket implementation.
   virtual void OnReadComplete(const MockRead& data) OVERRIDE;
   virtual void OnConnectComplete(const MockConnect& data) OVERRIDE;
 
-  void set_source_port(int port) { source_port_ = port;}
+  void set_source_port(int port) { source_port_ = port; }
 
  private:
   int CompleteRead();
 
   void RunCallbackAsync(const CompletionCallback& callback, int result);
   void RunCallback(const CompletionCallback& callback, int result);
 
   bool connected_;
   SocketDataProvider* data_;
   int read_offset_;
@@ skipping 262 matching lines @@
 
 extern const char kSOCKS5OkRequest[];
 extern const int kSOCKS5OkRequestLength;
 
 extern const char kSOCKS5OkResponse[];
 extern const int kSOCKS5OkResponseLength;
 
 }  // namespace net
 
 #endif  // NET_SOCKET_SOCKET_TEST_UTIL_H_