Clang format slam.

net/spdy/spdy_proxy_client_socket.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/spdy/spdy_proxy_client_socket.h"
 
 #include <algorithm>  // min
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 18 matching lines @@
     const std::string& user_agent,
     const HostPortPair& endpoint,
     const GURL& url,
     const HostPortPair& proxy_server,
     const BoundNetLog& source_net_log,
     HttpAuthCache* auth_cache,
     HttpAuthHandlerFactory* auth_handler_factory)
     : next_state_(STATE_DISCONNECTED),
       spdy_stream_(spdy_stream),
       endpoint_(endpoint),
-      auth_(
-          new HttpAuthController(HttpAuth::AUTH_PROXY,
-                                 GURL("https://" + proxy_server.ToString()),
-                                 auth_cache,
-                                 auth_handler_factory)),
+      auth_(new HttpAuthController(HttpAuth::AUTH_PROXY,
+                                   GURL("https://" + proxy_server.ToString()),
+                                   auth_cache,
+                                   auth_handler_factory)),
       user_buffer_len_(0),
       write_buffer_len_(0),
       was_ever_used_(false),
       redirect_has_load_timing_info_(false),
       weak_factory_(this),
       net_log_(BoundNetLog::Make(spdy_stream->net_log().net_log(),
                                  NetLog::SOURCE_PROXY_CLIENT_SOCKET)) {
   request_.method = "CONNECT";
   request_.url = url;
   if (!user_agent.empty())
@@ skipping 34 matching lines @@
 
 bool SpdyProxyClientSocket::IsUsingSpdy() const {
   return true;
 }
 
 NextProto SpdyProxyClientSocket::GetProtocolNegotiated() const {
   // Save the negotiated protocol
   SSLInfo ssl_info;
   bool was_npn_negotiated;
   NextProto protocol_negotiated;
-  spdy_stream_->GetSSLInfo(&ssl_info, &was_npn_negotiated,
-                           &protocol_negotiated);
+  spdy_stream_->GetSSLInfo(
+      &ssl_info, &was_npn_negotiated, &protocol_negotiated);
   return protocol_negotiated;
 }
 
 HttpStream* SpdyProxyClientSocket::CreateConnectResponseStream() {
   return new ProxyConnectRedirectHttpStream(
       redirect_has_load_timing_info_ ? &redirect_load_timing_info_ : NULL);
 }
 
 // Sends a SYN_STREAM frame to the proxy with a CONNECT request
 // for the specified endpoint.  Waits for the server to send back
@@ skipping 37 matching lines @@
     DCHECK(!spdy_stream_.get());
   }
 }
 
 bool SpdyProxyClientSocket::IsConnected() const {
   return next_state_ == STATE_OPEN;
 }
 
 bool SpdyProxyClientSocket::IsConnectedAndIdle() const {
   return IsConnected() && read_buffer_queue_.IsEmpty() &&
-      spdy_stream_->IsOpen();
+         spdy_stream_->IsOpen();
 }
 
 const BoundNetLog& SpdyProxyClientSocket::NetLog() const {
   return net_log_;
 }
 
 void SpdyProxyClientSocket::SetSubresourceSpeculation() {
   // TODO(rch): what should this implementation be?
 }
 
@@ skipping 13 matching lines @@
   return false;
 }
 
 NextProto SpdyProxyClientSocket::GetNegotiatedProtocol() const {
   return kProtoUnknown;
 }
 
 bool SpdyProxyClientSocket::GetSSLInfo(SSLInfo* ssl_info) {
   bool was_npn_negotiated;
   NextProto protocol_negotiated;
-  return spdy_stream_->GetSSLInfo(ssl_info, &was_npn_negotiated,
-                                  &protocol_negotiated);
+  return spdy_stream_->GetSSLInfo(
+      ssl_info, &was_npn_negotiated, &protocol_negotiated);
 }
 
-int SpdyProxyClientSocket::Read(IOBuffer* buf, int buf_len,
+int SpdyProxyClientSocket::Read(IOBuffer* buf,
+                                int buf_len,
                                 const CompletionCallback& callback) {
   DCHECK(read_callback_.is_null());
   DCHECK(!user_buffer_.get());
 
   if (next_state_ == STATE_DISCONNECTED)
     return ERR_SOCKET_NOT_CONNECTED;
 
   if (next_state_ == STATE_CLOSED && read_buffer_queue_.IsEmpty()) {
     return 0;
   }
 
   DCHECK(next_state_ == STATE_OPEN || next_state_ == STATE_CLOSED);
   DCHECK(buf);
   size_t result = PopulateUserReadBuffer(buf->data(), buf_len);
   if (result == 0) {
     user_buffer_ = buf;
     user_buffer_len_ = static_cast<size_t>(buf_len);
     DCHECK(!callback.is_null());
     read_callback_ = callback;
     return ERR_IO_PENDING;
   }
   user_buffer_ = NULL;
   return result;
 }
 
 size_t SpdyProxyClientSocket::PopulateUserReadBuffer(char* data, size_t len) {
   return read_buffer_queue_.Dequeue(data, len);
 }
 
-int SpdyProxyClientSocket::Write(IOBuffer* buf, int buf_len,
+int SpdyProxyClientSocket::Write(IOBuffer* buf,
+                                 int buf_len,
                                  const CompletionCallback& callback) {
   DCHECK(write_callback_.is_null());
   if (next_state_ != STATE_OPEN)
     return ERR_SOCKET_NOT_CONNECTED;
 
   DCHECK(spdy_stream_.get());
   spdy_stream_->SendData(buf, buf_len, MORE_DATA_TO_SEND);
-  net_log_.AddByteTransferEvent(NetLog::TYPE_SOCKET_BYTES_SENT,
-                                buf_len, buf->data());
+  net_log_.AddByteTransferEvent(
+      NetLog::TYPE_SOCKET_BYTES_SENT, buf_len, buf->data());
   write_callback_ = callback;
   write_buffer_len_ = buf_len;
   return ERR_IO_PENDING;
 }
 
 int SpdyProxyClientSocket::SetReceiveBufferSize(int32 size) {
   // Since this StreamSocket sits on top of a shared SpdySession, it
   // is not safe for callers to change this underlying socket.
   return ERR_NOT_IMPLEMENTED;
 }
@@ skipping 98 matching lines @@
   next_state_ = STATE_SEND_REQUEST_COMPLETE;
 
   // Add Proxy-Authentication header if necessary.
   HttpRequestHeaders authorization_headers;
   if (auth_->HaveAuth()) {
     auth_->AddAuthorizationHeader(&authorization_headers);
   }
 
   std::string request_line;
   HttpRequestHeaders request_headers;
-  BuildTunnelRequest(request_, authorization_headers, endpoint_, &request_line,
+  BuildTunnelRequest(request_,
+                     authorization_headers,
+                     endpoint_,
+                     &request_line,
                      &request_headers);
 
-  net_log_.AddEvent(
-      NetLog::TYPE_HTTP_TRANSACTION_SEND_TUNNEL_HEADERS,
-      base::Bind(&HttpRequestHeaders::NetLogCallback,
-                 base::Unretained(&request_headers),
-                 &request_line));
+  net_log_.AddEvent(NetLog::TYPE_HTTP_TRANSACTION_SEND_TUNNEL_HEADERS,
+                    base::Bind(&HttpRequestHeaders::NetLogCallback,
+                               base::Unretained(&request_headers),
+                               &request_line));
 
   request_.extra_headers.MergeFrom(request_headers);
   scoped_ptr<SpdyHeaderBlock> headers(new SpdyHeaderBlock());
-  CreateSpdyHeadersFromHttpRequest(request_, request_headers, headers.get(),
-                                   spdy_stream_->GetProtocolVersion(), true);
+  CreateSpdyHeadersFromHttpRequest(request_,
+                                   request_headers,
+                                   headers.get(),
+                                   spdy_stream_->GetProtocolVersion(),
+                                   true);
   // Reset the URL to be the endpoint of the connection
   if (spdy_stream_->GetProtocolVersion() > 2) {
     (*headers)[":path"] = endpoint_.ToString();
     headers->erase(":scheme");
   } else {
     (*headers)["url"] = endpoint_.ToString();
     headers->erase("scheme");
   }
 
   return spdy_stream_->SendRequestHeaders(headers.Pass(), MORE_DATA_TO_SEND);
@@ skipping 94 matching lines @@
   if (!read_callback_.is_null()) {
     int rv = PopulateUserReadBuffer(user_buffer_->data(), user_buffer_len_);
     CompletionCallback c = read_callback_;
     read_callback_.Reset();
     user_buffer_ = NULL;
     user_buffer_len_ = 0;
     c.Run(rv);
   }
 }
 
-void SpdyProxyClientSocket::OnDataSent()  {
+void SpdyProxyClientSocket::OnDataSent() {
   DCHECK(!write_callback_.is_null());
 
   int rv = write_buffer_len_;
   write_buffer_len_ = 0;
 
   // Proxy write callbacks result in deep callback chains. Post to allow the
   // stream's write callback chain to unwind (see crbug.com/355511).
   base::MessageLoop::current()->PostTask(
-      FROM_HERE,
-      base::Bind(ResetAndReturn(&write_callback_), rv));
+      FROM_HERE, base::Bind(ResetAndReturn(&write_callback_), rv));
 }
 
-void SpdyProxyClientSocket::OnClose(int status)  {
+void SpdyProxyClientSocket::OnClose(int status) {
   was_ever_used_ = spdy_stream_->WasEverUsed();
   spdy_stream_.reset();
 
-  bool connecting = next_state_ != STATE_DISCONNECTED &&
-      next_state_ < STATE_OPEN;
+  bool connecting =
+      next_state_ != STATE_DISCONNECTED && next_state_ < STATE_OPEN;
   if (next_state_ == STATE_OPEN)
     next_state_ = STATE_CLOSED;
   else
     next_state_ = STATE_DISCONNECTED;
 
   base::WeakPtr<SpdyProxyClientSocket> weak_ptr = weak_factory_.GetWeakPtr();
   CompletionCallback write_callback = write_callback_;
   write_callback_.Reset();
   write_buffer_len_ = 0;
 
   // If we're in the middle of connecting, we need to make sure
   // we invoke the connect callback.
   if (connecting) {
     DCHECK(!read_callback_.is_null());
     CompletionCallback read_callback = read_callback_;
     read_callback_.Reset();
     read_callback.Run(status);
   } else if (!read_callback_.is_null()) {
     // If we have a read_callback_, the we need to make sure we call it back.
     OnDataReceived(scoped_ptr<SpdyBuffer>());
   }
   // This may have been deleted by read_callback_, so check first.
   if (weak_ptr.get() && !write_callback.is_null())
     write_callback.Run(ERR_CONNECTION_CLOSED);
 }
 
 }  // namespace net