More progress towards removing content settings code from the content layer. We can't use Cookie...

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"
 #include "base/file_version_info.h"
 #include "base/message_loop.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/rand_util.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "net/base/cert_status_flags.h"
-#include "net/base/cookie_policy.h"
 #include "net/base/cookie_store.h"
 #include "net/base/filter.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/load_flags.h"
 #include "net/base/mime_util.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/base/sdch_manager.h"
 #include "net/base/ssl_cert_request_info.h"
 #include "net/base/ssl_config_service.h"
@@ skipping 390 matching lines @@
           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));
 
-  int policy = OK;
+  // If the request was destroyed, then there is no more work to do.
+  if (!request_)
+    return;
 
-  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());
+  bool allow = true;
+  if (request_info_.load_flags & LOAD_DO_NOT_SEND_COOKIES ||
+      (request_->delegate() &&
+       !request_->delegate()->CanGetCookies(request_))) {
+    allow = false;
   }
 
-  OnCanGetCookiesCompleted(policy);
+  OnCanGetCookiesCompleted(allow);
 }
 
 void URLRequestHttpJob::SaveCookiesAndNotifyHeadersComplete() {
   DCHECK(transaction_.get());
 
   const HttpResponseInfo* response_info = transaction_->GetResponseInfo();
   DCHECK(response_info);
 
   response_cookies_.clear();
   response_cookies_save_index_ = 0;
@@ skipping 10 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));
 
-  int policy = OK;
-
+  bool allow = true;
+  CookieOptions options;
   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_]);
+    allow = false;
+  } else if (request_->delegate() && request_->context()->cookie_store()) {
+    CookieOptions options;
+    options.set_include_httponly();
+    if (request_->delegate()->CanSetCookie(
+            request_,
+            response_cookies_[response_cookies_save_index_], &options)) {
+      request_->context()->cookie_store()->SetCookieWithOptions(
+          request_->url(), response_cookies_[response_cookies_save_index_],
+          options);
+    }
   }
 
-  OnCanSetCookieCompleted(policy);
+  OnCanSetCookieCompleted();
 }
 
 void URLRequestHttpJob::FetchResponseCookies(
     const HttpResponseInfo* response_info,
     std::vector<std::string>* cookies) {
   std::string name = "Set-Cookie";
   std::string value;
 
   void* iter = NULL;
   while (response_info->headers->EnumerateHeader(&iter, name, &value)) {
@@ skipping 83 matching lines @@
         new HTTPSProberDelegateImpl(request_info_.url.host(), max_age,
                                     include_subdomains,
                                     ctx->transport_security_state());
     if (!prober->ProbeHost(request_info_.url.host(), request()->context(),
                            delegate)) {
       delete delegate;
     }
   }
 }
 
-void URLRequestHttpJob::OnCanGetCookiesCompleted(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) {
-        request_->delegate()->OnGetCookies(request_, true);
-      } else if (policy == OK) {
-        request_->delegate()->OnGetCookies(request_, false);
-        CookieOptions options;
-        options.set_include_httponly();
-        std::string cookies =
-            request_->context()->cookie_store()->GetCookiesWithOptions(
-                request_->url(), options);
-        if (!cookies.empty()) {
-          request_info_.extra_headers.SetHeader(
-              HttpRequestHeaders::kCookie, cookies);
-        }
-      }
+void URLRequestHttpJob::OnCanGetCookiesCompleted(bool allow) {
+  if (request_->context()->cookie_store() && allow) {
+    CookieOptions options;
+    options.set_include_httponly();
+    std::string cookies =
+        request_->context()->cookie_store()->GetCookiesWithOptions(
+            request_->url(), options);
+    if (!cookies.empty()) {
+      request_info_.extra_headers.SetHeader(
+          HttpRequestHeaders::kCookie, cookies);
     }
-    // We may have been canceled within OnGetCookies.
-    if (GetStatus().is_success()) {
-      StartTransaction();
-    } else {
-      NotifyCanceled();
-    }
+  }
+  // We may have been canceled within CanGetCookies.
+  if (GetStatus().is_success()) {
+    StartTransaction();
+  } else {
+    NotifyCanceled();
   }
 }
 
-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(
-            request_,
-            response_cookies_[response_cookies_save_index_],
-            options,
-            true);
-      } else if (policy == OK || policy == OK_FOR_SESSION_ONLY) {
-        // OK to save the current response cookie now.
-        CookieOptions options;
-        options.set_include_httponly();
-        if (policy == OK_FOR_SESSION_ONLY)
-          options.set_force_session();
-        request_->context()->cookie_store()->SetCookieWithOptions(
-            request_->url(), response_cookies_[response_cookies_save_index_],
-            options);
-        request_->delegate()->OnSetCookie(
-            request_,
-            response_cookies_[response_cookies_save_index_],
-            options,
-            false);
-      }
-    }
-    response_cookies_save_index_++;
-    // We may have been canceled within OnSetCookie.
-    if (GetStatus().is_success()) {
-      SaveNextCookie();
-    } else {
-      NotifyCanceled();
-    }
+void URLRequestHttpJob::OnCanSetCookieCompleted() {
+  response_cookies_save_index_++;
+  // We may have been canceled within OnSetCookie.
+  if (GetStatus().is_success()) {
+    SaveNextCookie();
+  } else {
+    NotifyCanceled();
   }
 }
 
 void URLRequestHttpJob::OnStartCompleted(int result) {
   RecordTimer();
 
   // If the request was destroyed, then there is no more work to do.
   if (!request_ || !request_->delegate())
     return;
 
@@ skipping 740 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