Remove async functionality from net::CookiePolicy.

net/url_request/url_request_http_job.cc

 // 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/url_request/url_request_http_job.h"
 
 #include "base/base_switches.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
@@ skipping 188 matching lines @@
   return new URLRequestHttpJob(request);
 }
 
 
 URLRequestHttpJob::URLRequestHttpJob(URLRequest* request)
     : URLRequestJob(request),
       response_info_(NULL),
       response_cookies_save_index_(0),
       proxy_auth_state_(AUTH_STATE_DONT_NEED_AUTH),
       server_auth_state_(AUTH_STATE_DONT_NEED_AUTH),
-      ALLOW_THIS_IN_INITIALIZER_LIST(can_get_cookies_callback_(
-          this, &URLRequestHttpJob::OnCanGetCookiesCompleted)),
-      ALLOW_THIS_IN_INITIALIZER_LIST(can_set_cookie_callback_(
-          this, &URLRequestHttpJob::OnCanSetCookieCompleted)),
       ALLOW_THIS_IN_INITIALIZER_LIST(start_callback_(
           this, &URLRequestHttpJob::OnStartCompleted)),
       ALLOW_THIS_IN_INITIALIZER_LIST(read_callback_(
           this, &URLRequestHttpJob::OnReadCompleted)),
       read_in_progress_(false),
       transaction_(NULL),
       throttling_entry_(URLRequestThrottlerManager::GetInstance()->
           RegisterRequestUrl(request->url())),
       sdch_dictionary_advertised_(false),
       sdch_test_activated_(false),
@@ skipping 184 matching lines @@
         HttpRequestHeaders::kAcceptCharset,
         context->accept_charset());
   }
 }
 
 void URLRequestHttpJob::AddCookieHeaderAndStart() {
   // No matter what, we want to report our status as IO pending since we will
   // be notifying our consumer asynchronously via OnStartCompleted.
   SetStatus(URLRequestStatus(URLRequestStatus::IO_PENDING, 0));
 
-  AddRef();  // Balanced in OnCanGetCookiesCompleted
-
   int policy = OK;
 
   if (request_info_.load_flags & LOAD_DO_NOT_SEND_COOKIES) {
     policy = ERR_FAILED;
   } else if (request_->context()->cookie_policy()) {
     policy = request_->context()->cookie_policy()->CanGetCookies(
         request_->url(),
-        request_->first_party_for_cookies(),
-        &can_get_cookies_callback_);
-    if (policy == ERR_IO_PENDING)
-      return;  // Wait for completion callback
+        request_->first_party_for_cookies());
   }
 
   OnCanGetCookiesCompleted(policy);
 }
 
 void URLRequestHttpJob::SaveCookiesAndNotifyHeadersComplete() {
   DCHECK(transaction_.get());
 
   const HttpResponseInfo* response_info = transaction_->GetResponseInfo();
   DCHECK(response_info);
@@ skipping 13 matching lines @@
     response_cookies_save_index_ = 0;
     SetStatus(URLRequestStatus());  // Clear the IO_PENDING status
     NotifyHeadersComplete();
     return;
   }
 
   // No matter what, we want to report our status as IO pending since we will
   // be notifying our consumer asynchronously via OnStartCompleted.
   SetStatus(URLRequestStatus(URLRequestStatus::IO_PENDING, 0));
 
-  AddRef();  // Balanced in OnCanSetCookieCompleted
-
   int policy = OK;
 
   if (request_info_.load_flags & LOAD_DO_NOT_SAVE_COOKIES) {
     policy = ERR_FAILED;
   } else if (request_->context()->cookie_policy()) {
     policy = request_->context()->cookie_policy()->CanSetCookie(
         request_->url(),
         request_->first_party_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_]);
   }
 
   OnCanSetCookieCompleted(policy);
 }
 
 void URLRequestHttpJob::FetchResponseCookies(
     const HttpResponseInfo* response_info,
     std::vector<std::string>* cookies) {
   std::string name = "Set-Cookie";
   std::string value;
@@ skipping 112 matching lines @@
         }
       }
     }
     // We may have been canceled within OnGetCookies.
     if (GetStatus().is_success()) {
       StartTransaction();
     } else {
       NotifyCanceled();
     }
   }
-  Release();  // Balance AddRef taken in AddCookieHeaderAndStart
 }
 
 void URLRequestHttpJob::OnCanSetCookieCompleted(int policy) {
   // If the request was destroyed, then there is no more work to do.
   if (request_ && request_->delegate()) {
     if (request_->context()->cookie_store()) {
       if (policy == ERR_ACCESS_DENIED) {
         CookieOptions options;
         options.set_include_httponly();
         request_->delegate()->OnSetCookie(
@@ skipping 18 matching lines @@
       }
     }
     response_cookies_save_index_++;
     // We may have been canceled within OnSetCookie.
     if (GetStatus().is_success()) {
       SaveNextCookie();
     } else {
       NotifyCanceled();
     }
   }
-  Release();  // Balance AddRef taken in SaveNextCookie
 }
 
 void URLRequestHttpJob::OnStartCompleted(int result) {
   RecordTimer();
 
   // If the request was destroyed, then there is no more work to do.
   if (!request_ || !request_->delegate())
     return;
 
   // If the transaction was destroyed, then the job was cancelled, and
@@ skipping 695 matching lines @@
 }
 
 bool URLRequestHttpJob::IsCompressibleContent() const {
   std::string mime_type;
   return GetMimeType(&mime_type) &&
       (IsSupportedJavascriptMimeType(mime_type.c_str()) ||
        IsSupportedNonImageMimeType(mime_type.c_str()));
 }
 
 }  // namespace net