Clang format slam.

net/websockets/websocket_job.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/websockets/websocket_job.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
@@ skipping 10 matching lines @@
 #include "net/websockets/websocket_handshake_handler.h"
 #include "net/websockets/websocket_net_log_params.h"
 #include "net/websockets/websocket_throttle.h"
 #include "url/gurl.h"
 
 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;
 }
 
 class WebSocketJobInitSingleton {
  private:
   friend struct base::DefaultLazyInstanceTraits<WebSocketJobInitSingleton>;
   WebSocketJobInitSingleton() {
     net::SocketStreamJob::RegisterProtocolFactory("ws", WebSocketJobFactory);
@@ skipping 50 matching lines @@
 }
 
 bool WebSocketJob::SendData(const char* data, int len) {
   switch (state_) {
     case INITIALIZED:
       return false;
 
     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:
       return false;
   }
   return false;
 }
 
 void WebSocketJob::Close() {
   if (state_ == CLOSED)
@@ skipping 25 matching lines @@
   if (socket_.get())
     socket_->DetachDelegate();
   socket_ = NULL;
   if (!callback_.is_null()) {
     waiting_ = false;
     callback_.Reset();
     Release();  // Balanced with OnStartOpenConnection().
   }
 }
 
-int WebSocketJob::OnStartOpenConnection(
-    SocketStream* socket, const CompletionCallback& callback) {
+int WebSocketJob::OnStartOpenConnection(SocketStream* socket,
+                                        const CompletionCallback& callback) {
   DCHECK(callback_.is_null());
   state_ = CONNECTING;
 
   addresses_ = socket->address_list();
   if (!WebSocketThrottle::GetInstance()->PutInQueue(this)) {
     return ERR_WS_THROTTLE_QUEUE_TOO_LARGE;
   }
 
   if (delegate_) {
     int result = delegate_->OnStartOpenConnection(socket, callback);
     DCHECK_EQ(OK, result);
   }
   if (waiting_) {
     // PutInQueue() may set |waiting_| true for throttling. In this case,
     // Wakeup() will be called later.
     callback_ = callback;
     AddRef();  // Balanced when callback_ is cleared.
     return ERR_IO_PENDING;
   }
   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_);
   if (delegate_)
     delegate_->OnConnected(socket, max_pending_send_allowed);
 }
 
 void WebSocketJob::OnSentData(SocketStream* socket, int amount_sent) {
   DCHECK_NE(INITIALIZED, state_);
   DCHECK_GT(amount_sent, 0);
   if (state_ == CLOSED)
     return;
   if (state_ == CONNECTING) {
     OnSentHandshakeRequest(socket, amount_sent);
     return;
   }
   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);
     if (current_send_buffer_->BytesRemaining() > 0)
       return;
 
     // We need to report amount_sent of original buffer size, instead of
     // amount sent to |socket|.
     amount_sent = current_send_buffer_->size();
     DCHECK_GT(amount_sent, 0);
     current_send_buffer_ = NULL;
     if (!weak_ptr_factory_for_send_pending_.HasWeakPtrs()) {
       base::MessageLoopForIO::current()->PostTask(
           FROM_HERE,
           base::Bind(&WebSocketJob::SendPending,
                      weak_ptr_factory_for_send_pending_.GetWeakPtr()));
     }
     delegate_->OnSentData(socket, 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;
   if (state_ == CONNECTING) {
     OnReceivedHandshakeResponse(socket, data, len);
     return;
   }
   DCHECK(state_ == OPEN || state_ == CLOSING);
   if (delegate_ && len > 0)
     delegate_->OnReceivedData(socket, data, len);
@@ skipping 11 matching lines @@
   socket_ = NULL;
   if (!callback_.is_null()) {
     waiting_ = false;
     callback_.Reset();
     Release();  // Balanced with OnStartOpenConnection().
   }
   if (delegate)
     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);
 }
 
 void WebSocketJob::OnError(const SocketStream* socket, int error) {
   if (delegate_ && error != ERR_PROTOCOL_SWITCHED)
     delegate_->OnError(socket, error);
 }
 
 void WebSocketJob::OnCreatedSpdyStream(int result) {
@@ skipping 22 matching lines @@
   if (delegate_)
     delegate_->OnSentData(socket_.get(), original_length);
 }
 
 void WebSocketJob::OnSpdyResponseHeadersUpdated(
     const SpdyHeaderBlock& response_headers) {
   DCHECK_NE(INITIALIZED, state_);
   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();
 }
 
 void WebSocketJob::OnSentSpdyData(size_t bytes_sent) {
   DCHECK_NE(INITIALIZED, state_);
   DCHECK_NE(CONNECTING, state_);
   if (state_ == CLOSED)
     return;
   if (!spdy_websocket_stream_.get())
@@ skipping 38 matching lines @@
     allow = false;
 
   if (socket_.get() && delegate_ && state_ == CONNECTING) {
     handshake_request_->RemoveHeaders(kCookieHeaders,
                                       arraysize(kCookieHeaders));
     if (allow && socket_->cookie_store()) {
       // Add cookies, including HttpOnly cookies.
       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 {
       DoSendData();
     }
   }
 }
 
 void WebSocketJob::LoadCookieCallback(const std::string& cookie) {
   if (!cookie.empty())
     // TODO(tyoshino): Sending cookie means that connection doesn't need
     // PRIVACY_MODE_ENABLED as cookies may be server-bound and channel id
     // wouldn't negatively affect privacy anyway. Need to restart connection
     // or refactor to determine cookie status prior to connecting.
     handshake_request_->AppendHeaderIfMissing("Cookie", cookie);
   DoSendData();
 }
 
 void WebSocketJob::DoSendData() {
   if (spdy_websocket_stream_.get()) {
     scoped_ptr<SpdyHeaderBlock> headers(new SpdyHeaderBlock);
     handshake_request_->GetRequestHeaderBlock(
         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());
   if (handshake_request_sent_ >= handshake_request_->raw_length()) {
     // handshake request has been sent.
     // notify original size of handshake request to delegate.
     // Reset the handshake_request_ first in case this object is deleted by the
     // delegate.
     size_t original_length = handshake_request_->original_length();
     handshake_request_.reset();
     if (delegate_)
       delegate_->OnSentData(socket, original_length);
   }
 }
 
-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
     // data, not handshake message.
     received_data_after_handshake_.insert(
         received_data_after_handshake_.end(), data, data + len);
     return;
   }
 
   size_t response_length = handshake_response_->ParseRawResponse(data, len);
@@ skipping 25 matching lines @@
   handshake_response_->GetHeaders(
       kSetCookieHeaders, arraysize(kSetCookieHeaders), &response_cookies_);
 
   // Now, loop over the response cookies, and attempt to persist each.
   SaveNextCookie();
 }
 
 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(),
                                   handshake_response.end());
   received_data.insert(received_data.end(),
                        received_data_after_handshake_.begin(),
                        received_data_after_handshake_.end());
   received_data_after_handshake_.clear();
 
   state_ = OPEN;
@@ skipping 28 matching lines @@
            response_cookies_save_index_ < response_cookies_.size()) {
       std::string cookie = response_cookies_[response_cookies_save_index_];
       response_cookies_save_index_++;
 
       if (!delegate_->CanSetCookie(
               socket_.get(), url_for_cookies, cookie, &options))
         continue;
 
       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()));
     }
   }
 
   save_next_cookie_running_ = false;
 
   if (callback_pending_)
     return;
 
@@ skipping 42 matching lines @@
   HttpTransactionFactory* factory =
       socket_->context()->http_transaction_factory();
   if (!factory)
     return OK;
   scoped_refptr<HttpNetworkSession> session = factory->GetSession();
   if (!session.get())
     return OK;
   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 =
       spdy_pool->FindAvailableSession(key, *socket_->net_log());
   if (!spdy_session)
     return OK;
 
   SSLInfo ssl_info;
   bool was_npn_negotiated;
   NextProto protocol_negotiated = kProtoUnknown;
@@ skipping 87 matching lines @@
 
   scoped_refptr<IOBufferWithSize> next_buffer = send_buffer_queue_.front();
   send_buffer_queue_.pop_front();
   current_send_buffer_ =
       new DrainableIOBuffer(next_buffer.get(), next_buffer->size());
   SendDataInternal(current_send_buffer_->data(),
                    current_send_buffer_->BytesRemaining());
 }
 
 }  // namespace net