Clang format slam.

net/tools/quic/test_tools/quic_test_client.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.
 
 #include "net/tools/quic/test_tools/quic_test_client.h"
 
 #include "base/time/time.h"
 #include "net/base/completion_callback.h"
 #include "net/base/net_errors.h"
 #include "net/cert/cert_verify_result.h"
@@ skipping 56 matching lines @@
   }
 
   const string& common_name() const { return common_name_; }
 
  private:
   string common_name_;
 };
 
 }  // anonymous namespace
 
-BalsaHeaders* MungeHeaders(const BalsaHeaders* const_headers,
-                           bool secure) {
+BalsaHeaders* MungeHeaders(const BalsaHeaders* const_headers, bool secure) {
   StringPiece uri = const_headers->request_uri();
   if (uri.empty()) {
     return NULL;
   }
   if (const_headers->request_method() == "CONNECT") {
     return NULL;
   }
   BalsaHeaders* headers = new BalsaHeaders;
   headers->CopyFrom(*const_headers);
-  if (!uri.starts_with("https://") &&
-      !uri.starts_with("http://")) {
+  if (!uri.starts_with("https://") && !uri.starts_with("http://")) {
     // If we have a relative URL, set some defaults.
-    string full_uri = secure ? "https://www.google.com" :
-                               "http://www.google.com";
+    string full_uri =
+        secure ? "https://www.google.com" : "http://www.google.com";
     full_uri.append(uri.as_string());
     headers->SetRequestUri(full_uri);
   }
   return headers;
 }
 
 MockableQuicClient::MockableQuicClient(
     IPEndPoint server_address,
     const QuicServerId& server_id,
     const QuicVersionVector& supported_versions,
     uint32 initial_flow_control_window)
     : QuicClient(server_address,
                  server_id,
                  supported_versions,
                  false,
                  initial_flow_control_window),
       override_connection_id_(0),
-      test_writer_(NULL) {}
+      test_writer_(NULL) {
+}
 
 MockableQuicClient::MockableQuicClient(
     IPEndPoint server_address,
     const QuicServerId& server_id,
     const QuicConfig& config,
     const QuicVersionVector& supported_versions,
     uint32 initial_flow_control_window)
     : QuicClient(server_address,
                  server_id,
                  config,
                  supported_versions,
                  initial_flow_control_window),
       override_connection_id_(0),
-      test_writer_(NULL) {}
+      test_writer_(NULL) {
+}
 
 MockableQuicClient::~MockableQuicClient() {
   if (connected()) {
     Disconnect();
   }
 }
 
 QuicPacketWriter* MockableQuicClient::CreateQuicPacketWriter() {
   QuicPacketWriter* writer = QuicClient::CreateQuicPacketWriter();
   if (!test_writer_) {
     return writer;
   }
   test_writer_->set_writer(writer);
   return test_writer_;
 }
 
 QuicConnectionId MockableQuicClient::GenerateConnectionId() {
   return override_connection_id_ ? override_connection_id_
-      : QuicClient::GenerateConnectionId();
+                                 : QuicClient::GenerateConnectionId();
 }
 
 // Takes ownership of writer.
 void MockableQuicClient::UseWriter(QuicPacketWriterWrapper* writer) {
   CHECK(test_writer_ == NULL);
   test_writer_ = writer;
 }
 
 void MockableQuicClient::UseConnectionId(QuicConnectionId connection_id) {
   override_connection_id_ = connection_id;
@@ skipping 69 matching lines @@
   if (on) {
     proof_verifier_ = new RecordingProofVerifier;
     client_->SetProofVerifier(proof_verifier_);
   } else {
     proof_verifier_ = NULL;
     client_->SetProofVerifier(NULL);
   }
 }
 
 ssize_t QuicTestClient::SendRequest(const string& uri) {
-  HTTPMessage message(HttpConstants::HTTP_1_1,
-                      HttpConstants::GET,
-                      uri);
+  HTTPMessage message(HttpConstants::HTTP_1_1, HttpConstants::GET, uri);
   return SendMessage(message);
 }
 
 ssize_t QuicTestClient::SendMessage(const HTTPMessage& message) {
   stream_ = NULL;  // Always force creation of a stream for SendMessage.
 
   // If we're not connected, try to find an sni hostname.
   if (!connected()) {
     GURL url(message.headers()->request_uri().as_string());
     if (!url.host().empty()) {
-      client_->set_server_id(
-          QuicServerId(url.host(),
-                       url.EffectiveIntPort(),
-                       url.SchemeIs("https"),
-                       PRIVACY_MODE_DISABLED));
+      client_->set_server_id(QuicServerId(url.host(),
+                                          url.EffectiveIntPort(),
+                                          url.SchemeIs("https"),
+                                          PRIVACY_MODE_DISABLED));
     }
   }
 
   QuicSpdyClientStream* stream = GetOrCreateStream();
-  if (!stream) { return 0; }
+  if (!stream) {
+    return 0;
+  }
 
-  scoped_ptr<BalsaHeaders> munged_headers(MungeHeaders(message.headers(),
-                                          secure_));
+  scoped_ptr<BalsaHeaders> munged_headers(
+      MungeHeaders(message.headers(), secure_));
   ssize_t ret = GetOrCreateStream()->SendRequest(
       munged_headers.get() ? *munged_headers.get() : *message.headers(),
       message.body(),
       message.has_complete_message());
   WaitForWriteToFlush();
   return ret;
 }
 
 ssize_t QuicTestClient::SendData(string data, bool last_data) {
   QuicSpdyClientStream* stream = GetOrCreateStream();
-  if (!stream) { return 0; }
+  if (!stream) {
+    return 0;
+  }
   GetOrCreateStream()->SendBody(data, last_data);
   WaitForWriteToFlush();
   return data.length();
 }
 
 QuicPacketCreator::Options* QuicTestClient::options() {
   return client_->options();
 }
 
 bool QuicTestClient::response_complete() const {
@@ skipping 58 matching lines @@
     reinterpret_cast<QuicSpdyClientStream*>(stream_)->set_priority(priority_);
   }
 
   return stream_;
 }
 
 QuicErrorCode QuicTestClient::connection_error() {
   return client()->session()->error();
 }
 
-MockableQuicClient* QuicTestClient::client() { return client_.get(); }
+MockableQuicClient* QuicTestClient::client() {
+  return client_.get();
+}
 
 const string& QuicTestClient::cert_common_name() const {
   return reinterpret_cast<RecordingProofVerifier*>(proof_verifier_)
       ->common_name();
 }
 
 QuicTagValueMap QuicTestClient::GetServerConfig() const {
   QuicCryptoClientConfig* config =
       QuicClientPeer::GetCryptoConfig(client_.get());
   QuicCryptoClientConfig::CachedState* state =
@@ skipping 45 matching lines @@
   response_header_size_ = 0;
   response_body_size_ = 0;
 }
 
 void QuicTestClient::WaitForResponseForMs(int timeout_ms) {
   int64 timeout_us = timeout_ms * base::Time::kMicrosecondsPerMillisecond;
   int64 old_timeout_us = client()->epoll_server()->timeout_in_us();
   if (timeout_us > 0) {
     client()->epoll_server()->set_timeout_in_us(timeout_us);
   }
-  const QuicClock* clock =
-      QuicConnectionPeer::GetHelper(client()->session()->connection())->
-          GetClock();
-  QuicTime end_waiting_time = clock->Now().Add(
-      QuicTime::Delta::FromMicroseconds(timeout_us));
+  const QuicClock* clock = QuicConnectionPeer::GetHelper(
+                               client()->session()->connection())->GetClock();
+  QuicTime end_waiting_time =
+      clock->Now().Add(QuicTime::Delta::FromMicroseconds(timeout_us));
   while (stream_ != NULL &&
          !client_->session()->IsClosedStream(stream_->id()) &&
          (timeout_us < 0 || clock->Now() < end_waiting_time)) {
     client_->WaitForEvents();
   }
   if (timeout_us > 0) {
     client()->epoll_server()->set_timeout_in_us(old_timeout_us);
   }
 }
 
 void QuicTestClient::WaitForInitialResponseForMs(int timeout_ms) {
   int64 timeout_us = timeout_ms * base::Time::kMicrosecondsPerMillisecond;
   int64 old_timeout_us = client()->epoll_server()->timeout_in_us();
   if (timeout_us > 0) {
     client()->epoll_server()->set_timeout_in_us(timeout_us);
   }
-  const QuicClock* clock =
-      QuicConnectionPeer::GetHelper(client()->session()->connection())->
-          GetClock();
-  QuicTime end_waiting_time = clock->Now().Add(
-      QuicTime::Delta::FromMicroseconds(timeout_us));
+  const QuicClock* clock = QuicConnectionPeer::GetHelper(
+                               client()->session()->connection())->GetClock();
+  QuicTime end_waiting_time =
+      clock->Now().Add(QuicTime::Delta::FromMicroseconds(timeout_us));
   while (stream_ != NULL &&
          !client_->session()->IsClosedStream(stream_->id()) &&
          stream_->stream_bytes_read() == 0 &&
          (timeout_us < 0 || clock->Now() < end_waiting_time)) {
     client_->WaitForEvents();
   }
   if (timeout_us > 0) {
     client()->epoll_server()->set_timeout_in_us(old_timeout_us);
   }
 }
 
-ssize_t QuicTestClient::Send(const void *buffer, size_t size) {
+ssize_t QuicTestClient::Send(const void* buffer, size_t size) {
   return SendData(string(static_cast<const char*>(buffer), size), false);
 }
 
 bool QuicTestClient::response_headers_complete() const {
   if (stream_ != NULL) {
     return stream_->headers_decompressed();
   } else {
     return response_headers_complete_;
   }
 }
@@ skipping 40 matching lines @@
 
 void QuicTestClient::UseWriter(QuicPacketWriterWrapper* writer) {
   client_->UseWriter(writer);
 }
 
 void QuicTestClient::UseConnectionId(QuicConnectionId connection_id) {
   DCHECK(!connected());
   client_->UseConnectionId(connection_id);
 }
 
-ssize_t QuicTestClient::SendAndWaitForResponse(const void *buffer,
+ssize_t QuicTestClient::SendAndWaitForResponse(const void* buffer,
                                                size_t size) {
   LOG(DFATAL) << "Not implemented";
   return 0;
 }
 
 void QuicTestClient::Bind(IPEndPoint* local_address) {
   DLOG(WARNING) << "Bind will be done during connect";
 }
 
 string QuicTestClient::SerializeMessage(const HTTPMessage& message) {
@@ skipping 21 matching lines @@
 
 void QuicTestClient::WaitForWriteToFlush() {
   while (connected() && client()->session()->HasDataToWrite()) {
     client_->WaitForEvents();
   }
 }
 
 }  // namespace test
 }  // namespace tools
 }  // namespace net