Less indentation in WebSocketJob::SaveNextCookie() for readability

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 456 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 WebKit.
+  // Actual handshake should be done in Blink.
   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;
 
   DCHECK(!received_data.empty());
@@ skipping 10 matching lines @@
 void WebSocketJob::SaveNextCookie() {
   if (response_cookies_save_index_ == response_cookies_.size()) {
     response_cookies_.clear();
     response_cookies_save_index_ = 0;
 
     NotifyHeadersComplete();
 
     return;
   }
 
-  bool allow = true;
+  if (!socket_ || !delegate_ || state_ != CONNECTING)
+    return;
+
   CookieOptions options;
   GURL url = GetURLForCookies();
   std::string cookie = response_cookies_[response_cookies_save_index_];
-  if (delegate_ && !delegate_->CanSetCookie(socket_, url, cookie, &options))
-    allow = false;
+  response_cookies_save_index_++;
 
-  if (socket_ && delegate_ && state_ == CONNECTING) {
-    response_cookies_save_index_++;
-    if (allow && socket_->context()->cookie_store()) {
-      options.set_include_httponly();
-      socket_->context()->cookie_store()->SetCookieWithOptionsAsync(
-          url, cookie, options,
-          base::Bind(&WebSocketJob::SaveCookieCallback,
-                     weak_ptr_factory_.GetWeakPtr()));
-    } else {
-      SaveNextCookie();
-    }
+  // TODO(tyoshino): Use loop. See URLRequestHttpJob::SaveNextCookie().
+  if (delegate_->CanSetCookie(socket_, url, cookie, &options) &&
+      socket_->context()->cookie_store()) {
+    options.set_include_httponly();
+    socket_->context()->cookie_store()->SetCookieWithOptionsAsync(
+        url, cookie, options,
+        base::Bind(&WebSocketJob::SaveCookieCallback,
+                   weak_ptr_factory_.GetWeakPtr()));
+  } else {
+    SaveNextCookie();
   }
 }
 
 void WebSocketJob::SaveCookieCallback(bool cookie_status) {
   SaveNextCookie();
 }
 
 GURL WebSocketJob::GetURLForCookies() const {
   GURL url = socket_->url();
   std::string scheme = socket_->is_secure() ? "https" : "http";
@@ skipping 125 matching lines @@
 
   scoped_refptr<IOBufferWithSize> next_buffer = send_buffer_queue_.front();
   send_buffer_queue_.pop_front();
   current_send_buffer_ = new DrainableIOBuffer(next_buffer,
                                                next_buffer->size());
   SendDataInternal(current_send_buffer_->data(),
                    current_send_buffer_->BytesRemaining());
 }
 
 }  // namespace net