Clang format slam.

net/socket/ssl_server_socket_unittest.cc

 // 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.
 
 // This test suite uses SSLClientSocket to test the implementation of
 // SSLServerSocket. In order to establish connections between the sockets
 // we need two additional classes:
 // 1. FakeSocket
 //    Connects SSL socket to FakeDataChannel. This class is just a stub.
 //
@@ skipping 40 matching lines @@
 namespace net {
 
 namespace {
 
 class FakeDataChannel {
  public:
   FakeDataChannel()
       : read_buf_len_(0),
         closed_(false),
         write_called_after_close_(false),
-        weak_factory_(this) {
-  }
+        weak_factory_(this) {}
 
   int Read(IOBuffer* buf, int buf_len, const CompletionCallback& callback) {
     if (closed_)
       return 0;
     if (data_.empty()) {
       read_callback_ = callback;
       read_buf_ = buf;
       read_buf_len_ = buf_len;
       return net::ERR_IO_PENDING;
     }
     return PropogateData(buf, buf_len);
   }
 
   int Write(IOBuffer* buf, int buf_len, const CompletionCallback& callback) {
     if (closed_) {
       if (write_called_after_close_)
         return net::ERR_CONNECTION_RESET;
       write_called_after_close_ = true;
       write_callback_ = callback;
       base::MessageLoop::current()->PostTask(
-          FROM_HERE, base::Bind(&FakeDataChannel::DoWriteCallback,
-                                weak_factory_.GetWeakPtr()));
+          FROM_HERE,
+          base::Bind(&FakeDataChannel::DoWriteCallback,
+                     weak_factory_.GetWeakPtr()));
       return net::ERR_IO_PENDING;
     }
     data_.push(new net::DrainableIOBuffer(buf, buf_len));
     base::MessageLoop::current()->PostTask(
-        FROM_HERE, base::Bind(&FakeDataChannel::DoReadCallback,
-                              weak_factory_.GetWeakPtr()));
+        FROM_HERE,
+        base::Bind(&FakeDataChannel::DoReadCallback,
+                   weak_factory_.GetWeakPtr()));
     return buf_len;
   }
 
   // Closes the FakeDataChannel. After Close() is called, Read() returns 0,
   // indicating EOF, and Write() fails with ERR_CONNECTION_RESET. Note that
   // after the FakeDataChannel is closed, the first Write() call completes
   // asynchronously, which is necessary to reproduce bug 127822.
-  void Close() {
-    closed_ = true;
-  }
+  void Close() { closed_ = true; }
 
  private:
   void DoReadCallback() {
     if (read_callback_.is_null() || data_.empty())
       return;
 
     int copied = PropogateData(read_buf_, read_buf_len_);
     CompletionCallback callback = read_callback_;
     read_callback_.Reset();
     read_buf_ = NULL;
@@ skipping 39 matching lines @@
 
   base::WeakPtrFactory<FakeDataChannel> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeDataChannel);
 };
 
 class FakeSocket : public StreamSocket {
  public:
   FakeSocket(FakeDataChannel* incoming_channel,
              FakeDataChannel* outgoing_channel)
-      : incoming_(incoming_channel),
-        outgoing_(outgoing_channel) {
-  }
+      : incoming_(incoming_channel), outgoing_(outgoing_channel) {}
 
-  virtual ~FakeSocket() {
-  }
+  virtual ~FakeSocket() {}
 
-  virtual int Read(IOBuffer* buf, int buf_len,
+  virtual int Read(IOBuffer* buf,
+                   int buf_len,
                    const CompletionCallback& callback) OVERRIDE {
     // Read random number of bytes.
     buf_len = rand() % buf_len + 1;
     return incoming_->Read(buf, buf_len, callback);
   }
 
-  virtual int Write(IOBuffer* buf, int buf_len,
+  virtual int Write(IOBuffer* buf,
+                    int buf_len,
                     const CompletionCallback& callback) OVERRIDE {
     // Write random number of bytes.
     buf_len = rand() % buf_len + 1;
     return outgoing_->Write(buf, buf_len, callback);
   }
 
-  virtual int SetReceiveBufferSize(int32 size) OVERRIDE {
-    return net::OK;
-  }
+  virtual int SetReceiveBufferSize(int32 size) OVERRIDE { return net::OK; }
 
-  virtual int SetSendBufferSize(int32 size) OVERRIDE {
-    return net::OK;
-  }
+  virtual int SetSendBufferSize(int32 size) OVERRIDE { return net::OK; }
 
   virtual int Connect(const CompletionCallback& callback) OVERRIDE {
     return net::OK;
   }
 
   virtual void Disconnect() OVERRIDE {
     incoming_->Close();
     outgoing_->Close();
   }
 
-  virtual bool IsConnected() const OVERRIDE {
-    return true;
-  }
+  virtual bool IsConnected() const OVERRIDE { return true; }
 
-  virtual bool IsConnectedAndIdle() const OVERRIDE {
-    return true;
-  }
+  virtual bool IsConnectedAndIdle() const OVERRIDE { return true; }
 
   virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE {
-      net::IPAddressNumber ip_address(net::kIPv4AddressSize);
+    net::IPAddressNumber ip_address(net::kIPv4AddressSize);
     *address = net::IPEndPoint(ip_address, 0 /*port*/);
     return net::OK;
   }
 
   virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE {
     net::IPAddressNumber ip_address(4);
     *address = net::IPEndPoint(ip_address, 0);
     return net::OK;
   }
 
-  virtual const BoundNetLog& NetLog() const OVERRIDE {
-    return net_log_;
-  }
+  virtual const BoundNetLog& NetLog() const OVERRIDE { return net_log_; }
 
   virtual void SetSubresourceSpeculation() OVERRIDE {}
   virtual void SetOmniboxSpeculation() OVERRIDE {}
 
-  virtual bool WasEverUsed() const OVERRIDE {
-    return true;
-  }
+  virtual bool WasEverUsed() const OVERRIDE { return true; }
 
-  virtual bool UsingTCPFastOpen() const OVERRIDE {
-    return false;
-  }
+  virtual bool UsingTCPFastOpen() const OVERRIDE { return false; }
 
-
-  virtual bool WasNpnNegotiated() const OVERRIDE {
-    return false;
-  }
+  virtual bool WasNpnNegotiated() const OVERRIDE { return false; }
 
   virtual NextProto GetNegotiatedProtocol() const OVERRIDE {
     return kProtoUnknown;
   }
 
-  virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE {
-    return false;
-  }
+  virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE { return false; }
 
  private:
   net::BoundNetLog net_log_;
   FakeDataChannel* incoming_;
   FakeDataChannel* outgoing_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeSocket);
 };
 
 }  // namespace
@@ skipping 82 matching lines @@
     // Certificate provided by the host doesn't need authority.
     net::SSLConfig::CertAndStatus cert_and_status;
     cert_and_status.cert_status = CERT_STATUS_AUTHORITY_INVALID;
     cert_and_status.der_cert = cert_der;
     ssl_config.allowed_bad_certs.push_back(cert_and_status);
 
     net::HostPortPair host_and_pair("unittest", 0);
     net::SSLClientSocketContext context;
     context.cert_verifier = cert_verifier_.get();
     context.transport_security_state = transport_security_state_.get();
-    client_socket_ =
-        socket_factory_->CreateSSLClientSocket(
-            client_connection.Pass(), host_and_pair, ssl_config, context);
+    client_socket_ = socket_factory_->CreateSSLClientSocket(
+        client_connection.Pass(), host_and_pair, ssl_config, context);
     server_socket_ = net::CreateSSLServerSocket(
-        server_socket.Pass(),
-        cert.get(), private_key.get(), net::SSLConfig());
+        server_socket.Pass(), cert.get(), private_key.get(), net::SSLConfig());
   }
 
   FakeDataChannel channel_1_;
   FakeDataChannel channel_2_;
   scoped_ptr<net::SSLClientSocket> client_socket_;
   scoped_ptr<net::SSLServerSocket> server_socket_;
   net::ClientSocketFactory* socket_factory_;
   scoped_ptr<net::MockCertVerifier> cert_verifier_;
   scoped_ptr<net::TransportSecurityState> transport_security_state_;
 };
@@ skipping 51 matching lines @@
 
   client_ret = connect_callback.GetResult(client_ret);
   ASSERT_EQ(net::OK, client_ret);
   server_ret = handshake_callback.GetResult(server_ret);
   ASSERT_EQ(net::OK, server_ret);
 
   const int kReadBufSize = 1024;
   scoped_refptr<net::StringIOBuffer> write_buf =
       new net::StringIOBuffer("testing123");
   scoped_refptr<net::DrainableIOBuffer> read_buf =
-      new net::DrainableIOBuffer(new net::IOBuffer(kReadBufSize),
-                                 kReadBufSize);
+      new net::DrainableIOBuffer(new net::IOBuffer(kReadBufSize), kReadBufSize);
 
   // Write then read.
   TestCompletionCallback write_callback;
   TestCompletionCallback read_callback;
   server_ret = server_socket_->Write(
       write_buf.get(), write_buf->size(), write_callback.callback());
   EXPECT_TRUE(server_ret > 0 || server_ret == net::ERR_IO_PENDING);
   client_ret = client_socket_->Read(
       read_buf.get(), read_buf->BytesRemaining(), read_callback.callback());
   EXPECT_TRUE(client_ret > 0 || client_ret == net::ERR_IO_PENDING);
@@ skipping 86 matching lines @@
 
   // The client writes some data. This should not cause an infinite loop.
   client_ret = client_socket_->Write(
       write_buf.get(), write_buf->size(), write_callback.callback());
   EXPECT_TRUE(client_ret > 0 || client_ret == net::ERR_IO_PENDING);
 
   client_ret = write_callback.GetResult(client_ret);
   EXPECT_GT(client_ret, 0);
 
   base::MessageLoop::current()->PostDelayedTask(
-      FROM_HERE, base::MessageLoop::QuitClosure(),
+      FROM_HERE,
+      base::MessageLoop::QuitClosure(),
       base::TimeDelta::FromMilliseconds(10));
   base::MessageLoop::current()->Run();
 }
 
 // This test executes ExportKeyingMaterial() on the client and server sockets,
 // after connecting them, and verifies that the results match.
 // This test will fail if False Start is enabled (see crbug.com/90208).
 TEST_F(SSLServerSocketTest, ExportKeyingMaterial) {
   Initialize();
 
@@ skipping 10 matching lines @@
     ASSERT_EQ(net::OK, connect_callback.WaitForResult());
   }
   if (server_ret == net::ERR_IO_PENDING) {
     ASSERT_EQ(net::OK, handshake_callback.WaitForResult());
   }
 
   const int kKeyingMaterialSize = 32;
   const char* kKeyingLabel = "EXPERIMENTAL-server-socket-test";
   const char* kKeyingContext = "";
   unsigned char server_out[kKeyingMaterialSize];
-  int rv = server_socket_->ExportKeyingMaterial(kKeyingLabel,
-                                                false, kKeyingContext,
-                                                server_out, sizeof(server_out));
+  int rv = server_socket_->ExportKeyingMaterial(
+      kKeyingLabel, false, kKeyingContext, server_out, sizeof(server_out));
   ASSERT_EQ(net::OK, rv);
 
   unsigned char client_out[kKeyingMaterialSize];
-  rv = client_socket_->ExportKeyingMaterial(kKeyingLabel,
-                                            false, kKeyingContext,
-                                            client_out, sizeof(client_out));
+  rv = client_socket_->ExportKeyingMaterial(
+      kKeyingLabel, false, kKeyingContext, client_out, sizeof(client_out));
   ASSERT_EQ(net::OK, rv);
   EXPECT_EQ(0, memcmp(server_out, client_out, sizeof(server_out)));
 
   const char* kKeyingLabelBad = "EXPERIMENTAL-server-socket-test-bad";
   unsigned char client_bad[kKeyingMaterialSize];
-  rv = client_socket_->ExportKeyingMaterial(kKeyingLabelBad,
-                                            false, kKeyingContext,
-                                            client_bad, sizeof(client_bad));
+  rv = client_socket_->ExportKeyingMaterial(
+      kKeyingLabelBad, false, kKeyingContext, client_bad, sizeof(client_bad));
   ASSERT_EQ(rv, net::OK);
   EXPECT_NE(0, memcmp(server_out, client_bad, sizeof(server_out)));
 }
 #endif
 
 }  // namespace net