Remove async functionality from net::CookiePolicy.

net/websockets/websocket_job.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Copyright (c) 2011 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/lazy_instance.h"
 #include "base/string_tokenizer.h"
 #include "googleurl/src/gurl.h"
@@ skipping 49 matching lines @@
 
 WebSocketJob::WebSocketJob(SocketStream::Delegate* delegate)
     : delegate_(delegate),
       state_(INITIALIZED),
       waiting_(false),
       callback_(NULL),
       handshake_request_(new WebSocketHandshakeRequestHandler),
       handshake_response_(new WebSocketHandshakeResponseHandler),
       handshake_request_sent_(0),
       response_cookies_save_index_(0),
-      ALLOW_THIS_IN_INITIALIZER_LIST(can_get_cookies_callback_(
-          this, &WebSocketJob::OnCanGetCookiesCompleted)),
-      ALLOW_THIS_IN_INITIALIZER_LIST(can_set_cookie_callback_(
-          this, &WebSocketJob::OnCanSetCookieCompleted)),
       send_frame_handler_(new WebSocketFrameHandler),
       receive_frame_handler_(new WebSocketFrameHandler) {
 }
 
 WebSocketJob::~WebSocketJob() {
   DCHECK_EQ(CLOSED, state_);
   DCHECK(!delegate_);
   DCHECK(!socket_.get());
 }
 
@@ skipping 189 matching lines @@
   if (!handshake_request_->ParseRequest(data, len))
     return false;
 
   // handshake message is completed.
   AddCookieHeaderAndSend();
   // Just buffered in |handshake_request_|.
   return true;
 }
 
 void WebSocketJob::AddCookieHeaderAndSend() {
-  AddRef();  // Balanced in OnCanGetCookiesCompleted
-
   int policy = OK;
   if (socket_->context()->cookie_policy()) {
     GURL url_for_cookies = GetURLForCookies();
     policy = socket_->context()->cookie_policy()->CanGetCookies(
         url_for_cookies,
-        url_for_cookies,
-        &can_get_cookies_callback_);
-    if (policy == ERR_IO_PENDING)
-      return;  // Wait for completion callback
+        url_for_cookies);
   }
+  DCHECK_NE(ERR_IO_PENDING, policy);
   OnCanGetCookiesCompleted(policy);
 }
 
 void WebSocketJob::OnCanGetCookiesCompleted(int policy) {
   if (socket_ && delegate_ && state_ == CONNECTING) {
     handshake_request_->RemoveHeaders(
         kCookieHeaders, arraysize(kCookieHeaders));
     if (policy == OK) {
       // Add cookies, including HttpOnly cookies.
       if (socket_->context()->cookie_store()) {
         CookieOptions cookie_options;
         cookie_options.set_include_httponly();
         std::string cookie =
             socket_->context()->cookie_store()->GetCookiesWithOptions(
                 GetURLForCookies(), cookie_options);
         if (!cookie.empty())
           handshake_request_->AppendHeaderIfMissing("Cookie", cookie);
       }
     }
 
     const std::string& handshake_request = handshake_request_->GetRawRequest();
     handshake_request_sent_ = 0;
     socket_->net_log()->AddEvent(
         NetLog::TYPE_WEB_SOCKET_SEND_REQUEST_HEADERS,
         make_scoped_refptr(
             new NetLogWebSocketHandshakeParameter(handshake_request)));
     socket_->SendData(handshake_request.data(),
                       handshake_request.size());
   }
-  Release();  // Balance AddRef taken in AddCookieHeaderAndSend
 }
 
 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.
@@ skipping 71 matching lines @@
       delegate_->OnReceivedData(
           socket_, received_data.data(), received_data.size());
 
     handshake_response_.reset();
 
     WebSocketThrottle::GetInstance()->RemoveFromQueue(this);
     WebSocketThrottle::GetInstance()->WakeupSocketIfNecessary();
     return;
   }
 
-  AddRef();  // Balanced in OnCanSetCookieCompleted
-
   int policy = OK;
   if (socket_->context()->cookie_policy()) {
     GURL url_for_cookies = GetURLForCookies();
     policy = socket_->context()->cookie_policy()->CanSetCookie(
         url_for_cookies,
         url_for_cookies,
-        response_cookies_[response_cookies_save_index_],
-        &can_set_cookie_callback_);
-    if (policy == ERR_IO_PENDING)
-      return;  // Wait for completion callback
+        response_cookies_[response_cookies_save_index_]);
   }
 
+  DCHECK_NE(ERR_IO_PENDING, policy);
   OnCanSetCookieCompleted(policy);
 }
 
 void WebSocketJob::OnCanSetCookieCompleted(int policy) {
   if (socket_ && delegate_ && state_ == CONNECTING) {
     if ((policy == OK || policy == OK_FOR_SESSION_ONLY) &&
         socket_->context()->cookie_store()) {
       CookieOptions options;
       options.set_include_httponly();
       if (policy == OK_FOR_SESSION_ONLY)
         options.set_force_session();
       GURL url_for_cookies = GetURLForCookies();
       socket_->context()->cookie_store()->SetCookieWithOptions(
           url_for_cookies, response_cookies_[response_cookies_save_index_],
           options);
     }
     response_cookies_save_index_++;
     SaveNextCookie();
   }
-  Release();  // Balance AddRef taken in SaveNextCookie
 }
 
 GURL WebSocketJob::GetURLForCookies() const {
   GURL url = socket_->url();
   std::string scheme = socket_->is_secure() ? "https" : "http";
   url_canon::Replacements<char> replacements;
   replacements.SetScheme(scheme.c_str(),
                          url_parse::Component(0, scheme.length()));
   return url.ReplaceComponents(replacements);
 }
@@ skipping 42 matching lines @@
       socket_->Close();
     return;
   }
   current_buffer_ = new DrainableIOBuffer(
       send_frame_handler_->GetCurrentBuffer(),
       send_frame_handler_->GetCurrentBufferSize());
   socket_->SendData(current_buffer_->data(), current_buffer_->BytesRemaining());
 }
 
 }  // namespace net