Clang format slam.

net/websockets/websocket_job.cc

Index: net/websockets/websocket_job.cc
diff --git a/net/websockets/websocket_job.cc b/net/websockets/websocket_job.cc
index cd8f09dd791a5b60dd6adfcfc2f948ec496456b1..f1bd52484a3fded29ff1e62d3ca395724bb2a187 100644
--- a/net/websockets/websocket_job.cc
+++ b/net/websockets/websocket_job.cc
@@ -28,16 +28,13 @@ static const int kMaxPendingSendAllowed = 32768;  // 32 kilobytes.
 namespace {
 
 // lower-case header names.
-const char* const kCookieHeaders[] = {
-  "cookie", "cookie2"
-};
-const char* const kSetCookieHeaders[] = {
-  "set-cookie", "set-cookie2"
-};
+const char* const kCookieHeaders[] = {"cookie", "cookie2"};
+const char* const kSetCookieHeaders[] = {"set-cookie", "set-cookie2"};
 
-net::SocketStreamJob* WebSocketJobFactory(
-    const GURL& url, net::SocketStream::Delegate* delegate,
-    net::URLRequestContext* context, net::CookieStore* cookie_store) {
+net::SocketStreamJob* WebSocketJobFactory(const GURL& url,
+                                          net::SocketStream::Delegate* delegate,
+                                          net::URLRequestContext* context,
+                                          net::CookieStore* cookie_store) {
   net::WebSocketJob* job = new net::WebSocketJob(delegate);
   job->InitSocketStream(new net::SocketStream(url, job, context, cookie_store));
   return job;
@@ -108,18 +105,17 @@ bool WebSocketJob::SendData(const char* data, int len) {
     case CONNECTING:
       return SendHandshakeRequest(data, len);
 
-    case OPEN:
-      {
-        scoped_refptr<IOBufferWithSize> buffer = new IOBufferWithSize(len);
-        memcpy(buffer->data(), data, len);
-        if (current_send_buffer_.get() || !send_buffer_queue_.empty()) {
-          send_buffer_queue_.push_back(buffer);
-          return true;
-        }
-        current_send_buffer_ = new DrainableIOBuffer(buffer.get(), len);
-        return SendDataInternal(current_send_buffer_->data(),
-                                current_send_buffer_->BytesRemaining());
+    case OPEN: {
+      scoped_refptr<IOBufferWithSize> buffer = new IOBufferWithSize(len);
+      memcpy(buffer->data(), data, len);
+      if (current_send_buffer_.get() || !send_buffer_queue_.empty()) {
+        send_buffer_queue_.push_back(buffer);
+        return true;
       }
+      current_send_buffer_ = new DrainableIOBuffer(buffer.get(), len);
+      return SendDataInternal(current_send_buffer_->data(),
+                              current_send_buffer_->BytesRemaining());
+    }
 
     case CLOSING:
     case CLOSED:
@@ -165,8 +161,8 @@ void WebSocketJob::DetachDelegate() {
   }
 }
 
-int WebSocketJob::OnStartOpenConnection(
-    SocketStream* socket, const CompletionCallback& callback) {
+int WebSocketJob::OnStartOpenConnection(SocketStream* socket,
+                                        const CompletionCallback& callback) {
   DCHECK(callback_.is_null());
   state_ = CONNECTING;
 
@@ -189,8 +185,8 @@ int WebSocketJob::OnStartOpenConnection(
   return TrySpdyStream();
 }
 
-void WebSocketJob::OnConnected(
-    SocketStream* socket, int max_pending_send_allowed) {
+void WebSocketJob::OnConnected(SocketStream* socket,
+                               int max_pending_send_allowed) {
   if (state_ == CLOSED)
     return;
   DCHECK_EQ(CONNECTING, state_);
@@ -210,8 +206,8 @@ void WebSocketJob::OnSentData(SocketStream* socket, int amount_sent) {
   if (delegate_) {
     DCHECK(state_ == OPEN || state_ == CLOSING);
     if (!current_send_buffer_.get()) {
-      VLOG(1)
-          << "OnSentData current_send_buffer=NULL amount_sent=" << amount_sent;
+      VLOG(1) << "OnSentData current_send_buffer=NULL amount_sent="
+              << amount_sent;
       return;
     }
     current_send_buffer_->DidConsume(amount_sent);
@@ -233,8 +229,9 @@ void WebSocketJob::OnSentData(SocketStream* socket, int amount_sent) {
   }
 }
 
-void WebSocketJob::OnReceivedData(
-    SocketStream* socket, const char* data, int len) {
+void WebSocketJob::OnReceivedData(SocketStream* socket,
+                                  const char* data,
+                                  int len) {
   DCHECK_NE(INITIALIZED, state_);
   if (state_ == CLOSED)
     return;
@@ -266,14 +263,15 @@ void WebSocketJob::OnClose(SocketStream* socket) {
     delegate->OnClose(socket);
 }
 
-void WebSocketJob::OnAuthRequired(
-    SocketStream* socket, AuthChallengeInfo* auth_info) {
+void WebSocketJob::OnAuthRequired(SocketStream* socket,
+                                  AuthChallengeInfo* auth_info) {
   if (delegate_)
     delegate_->OnAuthRequired(socket, auth_info);
 }
 
-void WebSocketJob::OnSSLCertificateError(
-    SocketStream* socket, const SSLInfo& ssl_info, bool fatal) {
+void WebSocketJob::OnSSLCertificateError(SocketStream* socket,
+                                         const SSLInfo& ssl_info,
+                                         bool fatal) {
   if (delegate_)
     delegate_->OnSSLCertificateError(socket, ssl_info, fatal);
 }
@@ -316,9 +314,8 @@ void WebSocketJob::OnSpdyResponseHeadersUpdated(
   if (state_ != CONNECTING)
     return;
   // TODO(toyoshim): Fallback to non-spdy connection?
-  handshake_response_->ParseResponseHeaderBlock(response_headers,
-                                                challenge_,
-                                                spdy_protocol_version_);
+  handshake_response_->ParseResponseHeaderBlock(
+      response_headers, challenge_, spdy_protocol_version_);
 
   SaveCookiesAndNotifyHeadersComplete();
 }
@@ -377,7 +374,8 @@ void WebSocketJob::AddCookieHeaderAndSend() {
       CookieOptions cookie_options;
       cookie_options.set_include_httponly();
       socket_->cookie_store()->GetCookiesWithOptionsAsync(
-          GetURLForCookies(), cookie_options,
+          GetURLForCookies(),
+          cookie_options,
           base::Bind(&WebSocketJob::LoadCookieCallback,
                      weak_ptr_factory_.GetWeakPtr()));
     } else {
@@ -403,21 +401,19 @@ void WebSocketJob::DoSendData() {
         socket_->url(), headers.get(), &challenge_, spdy_protocol_version_);
     spdy_websocket_stream_->SendRequest(headers.Pass());
   } else {
-    const std::string& handshake_request =
-        handshake_request_->GetRawRequest();
+    const std::string& handshake_request = handshake_request_->GetRawRequest();
     handshake_request_sent_ = 0;
     socket_->net_log()->AddEvent(
         NetLog::TYPE_WEB_SOCKET_SEND_REQUEST_HEADERS,
         base::Bind(&NetLogWebSocketHandshakeCallback, &handshake_request));
-    socket_->SendData(handshake_request.data(),
-                      handshake_request.size());
+    socket_->SendData(handshake_request.data(), handshake_request.size());
   }
   // Just buffered in |handshake_request_|.
   started_to_send_handshake_request_ = true;
 }
 
-void WebSocketJob::OnSentHandshakeRequest(
-    SocketStream* socket, int amount_sent) {
+void WebSocketJob::OnSentHandshakeRequest(SocketStream* socket,
+                                          int amount_sent) {
   DCHECK_EQ(state_, CONNECTING);
   handshake_request_sent_ += amount_sent;
   DCHECK_LE(handshake_request_sent_, handshake_request_->raw_length());
@@ -433,8 +429,9 @@ void WebSocketJob::OnSentHandshakeRequest(
   }
 }
 
-void WebSocketJob::OnReceivedHandshakeResponse(
-    SocketStream* socket, const char* data, int len) {
+void WebSocketJob::OnReceivedHandshakeResponse(SocketStream* socket,
+                                               const char* data,
+                                               int len) {
   DCHECK_EQ(state_, CONNECTING);
   if (handshake_response_->HasResponse()) {
     // If we already has handshake response, received data should be frame
@@ -480,8 +477,8 @@ void WebSocketJob::SaveCookiesAndNotifyHeadersComplete() {
 void WebSocketJob::NotifyHeadersComplete() {
   // Remove cookie headers, with malformed headers preserved.
   // Actual handshake should be done in Blink.
-  handshake_response_->RemoveHeaders(
-      kSetCookieHeaders, arraysize(kSetCookieHeaders));
+  handshake_response_->RemoveHeaders(kSetCookieHeaders,
+                                     arraysize(kSetCookieHeaders));
   std::string handshake_response = handshake_response_->GetResponse();
   handshake_response_.reset();
   std::vector<char> received_data(handshake_response.begin(),
@@ -530,7 +527,9 @@ void WebSocketJob::SaveNextCookie() {
 
       callback_pending_ = true;
       socket_->cookie_store()->SetCookieWithOptionsAsync(
-          url_for_cookies, cookie, options,
+          url_for_cookies,
+          cookie,
+          options,
           base::Bind(&WebSocketJob::OnCookieSaved,
                      weak_ptr_factory_.GetWeakPtr()));
     }
@@ -593,7 +592,8 @@ int WebSocketJob::TrySpdyStream() {
   SpdySessionPool* spdy_pool = session->spdy_session_pool();
   PrivacyMode privacy_mode = socket_->privacy_mode();
   const SpdySessionKey key(HostPortPair::FromURL(socket_->url()),
-                           socket_->proxy_server(), privacy_mode);
+                           socket_->proxy_server(),
+                           privacy_mode);
   // Forbid wss downgrade to SPDY without SSL.
   // TODO(toyoshim): Does it realize the same policy with HTTP?
   base::WeakPtr<SpdySession> spdy_session =