Do cookie checks in NetworkDelegate instead of the URLRequest::Delegate.

content/common/net/url_fetcher_impl.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 "content/common/net/url_fetcher_impl.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/file_util_proxy.h"
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
 #include "base/platform_file.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "base/threading/thread.h"
 #include "base/timer.h"
+#include "content/common/net/url_request_user_data.h"
 #include "content/public/common/url_fetcher_delegate.h"
 #include "content/public/common/url_fetcher_factory.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request.h"
@@ skipping 203 matching lines @@
                                      // on which file access happens.
   scoped_ptr<net::URLRequest> request_;   // The actual request this wraps
   int load_flags_;                   // Flags for the load operation
   int response_code_;                // HTTP status code for the request
   std::string data_;                 // Results of the request, when we are
                                      // storing the response as a string.
   scoped_refptr<net::IOBuffer> buffer_;
                                      // Read buffer
   scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
                                      // Cookie/cache info for the request
+  int render_process_id_;            // The RenderView associated with the
+  int render_view_id_;               // request
+  GURL first_party_for_cookies_;     // The first party URL for the request
   net::ResponseCookies cookies_;     // Response cookies
   net::HttpRequestHeaders extra_request_headers_;
   scoped_refptr<net::HttpResponseHeaders> response_headers_;
   bool was_fetched_via_proxy_;
   net::HostPortPair socket_address_;
 
   std::string upload_content_;       // HTTP POST payload
   std::string upload_content_type_;  // MIME type of POST payload
   std::string referrer_;             // HTTP Referer header value
   bool is_chunked_upload_;           // True if using chunked transfer encoding
@@ skipping 280 matching lines @@
     : fetcher_(fetcher),
       original_url_(original_url),
       request_type_(request_type),
       delegate_(d),
       delegate_loop_proxy_(
           base::MessageLoopProxy::current()),
       request_(NULL),
       load_flags_(net::LOAD_NORMAL),
       response_code_(RESPONSE_CODE_INVALID),
       buffer_(new net::IOBuffer(kBufferSize)),
+      render_process_id_(-1),
+      render_view_id_(-1),
       was_fetched_via_proxy_(false),
       is_chunked_upload_(false),
       num_retries_(0),
       was_cancelled_(false),
       response_destination_(STRING),
       automatically_retry_on_5xx_(true),
       max_retries_(0),
       current_response_bytes_(0),
       total_response_bytes_(-1) {
 }
@@ skipping 194 matching lines @@
       backoff_delay = base::TimeDelta();
 
     if (automatically_retry_on_5xx_ && num_retries_ <= max_retries_) {
       StartOnIOThread();
       return;
     }
   } else {
     backoff_delay = base::TimeDelta();
   }
   request_context_getter_ = NULL;
+  render_process_id_ = -1;
+  render_view_id_ = -1;
+  first_party_for_cookies_ = GURL();
   bool posted = delegate_loop_proxy_->PostTask(
       FROM_HERE, base::Bind(&Core::OnCompletedURLRequest, this, backoff_delay));
 
   // If the delegate message loop does not exist any more, then the delegate
   // should be gone too.
   DCHECK(posted || !delegate_);
 }
 
 void URLFetcherImpl::Core::ReadResponse() {
   // Some servers may treat HEAD requests as GET requests.  To free up the
@@ skipping 27 matching lines @@
   request_.reset(new net::URLRequest(original_url_, this));
   int flags = request_->load_flags() | load_flags_;
   if (!g_interception_enabled)
     flags = flags | net::LOAD_DISABLE_INTERCEPT;
 
   if (is_chunked_upload_)
     request_->EnableChunkedUpload();
   request_->set_load_flags(flags);
   request_->set_context(request_context_getter_->GetURLRequestContext());
   request_->set_referrer(referrer_);
+  request_->set_first_party_for_cookies(first_party_for_cookies_.is_empty() ?
+      original_url_ : first_party_for_cookies_);
+  if (render_process_id_ != -1 && render_view_id_ != -1) {
+    request_->SetUserData(
+        URLRequestUserData::kUserDataKey,
+        new URLRequestUserData(render_process_id_, render_view_id_));
+  }
 
   switch (request_type_) {
     case GET:
       break;
 
     case POST:
     case PUT:
       DCHECK(!upload_content_.empty() || is_chunked_upload_);
       DCHECK(!upload_content_type_.empty());
 
@@ skipping 59 matching lines @@
 
   if (request_.get()) {
     request_->Cancel();
     ReleaseRequest();
   }
   // Release the reference to the request context. There could be multiple
   // references to URLFetcher::Core at this point so it may take a while to
   // delete the object, but we cannot delay the destruction of the request
   // context.
   request_context_getter_ = NULL;
+  render_process_id_ = -1;
+  render_view_id_ = -1;
+  first_party_for_cookies_ = GURL();
   was_cancelled_ = true;
   file_writer_.reset();
 }
 
 void URLFetcherImpl::Core::OnCompletedURLRequest(
     base::TimeDelta backoff_delay) {
   DCHECK(delegate_loop_proxy_->BelongsToCurrentThread());
 
   // Save the status and backoff_delay so that delegates can read it.
   if (delegate_) {
@@ skipping 112 matching lines @@
 void URLFetcherImpl::GetExtraRequestHeaders(net::HttpRequestHeaders* headers) {
   headers->CopyFrom(core_->extra_request_headers_);
 }
 
 void URLFetcherImpl::SetRequestContext(
     net::URLRequestContextGetter* request_context_getter) {
   DCHECK(!core_->request_context_getter_);
   core_->request_context_getter_ = request_context_getter;
 }
 
+void URLFetcherImpl::AssociateWithRenderView(
+    const GURL& first_party_for_cookies,
+    int render_process_id,
+    int render_view_id) {
+  DCHECK(core_->first_party_for_cookies_.is_empty());
+  DCHECK_EQ(core_->render_process_id_, -1);
+  DCHECK_EQ(core_->render_view_id_, -1);
+  DCHECK_GE(render_process_id, 0);
+  DCHECK_GE(render_view_id, 0);
+  core_->first_party_for_cookies_ = first_party_for_cookies;
+  core_->render_process_id_ = render_process_id;
+  core_->render_view_id_ = render_view_id;
+}
+
 void URLFetcherImpl::SetAutomaticallyRetryOn5xx(bool retry) {
   core_->automatically_retry_on_5xx_ = retry;
 }
 
 void URLFetcherImpl::SetMaxRetries(int max_retries) {
   core_->max_retries_ = max_retries;
 }
 
 int URLFetcherImpl::GetMaxRetries() const {
   return core_->max_retries_;
@@ skipping 31 matching lines @@
 }
 
 void URLFetcherImpl::set_was_fetched_via_proxy(bool flag) {
   core_->was_fetched_via_proxy_ = flag;
 }
 
 void URLFetcherImpl::Start() {
   core_->Start();
 }
 
-void URLFetcherImpl::StartWithRequestContextGetter(
-    net::URLRequestContextGetter* request_context_getter) {
-  SetRequestContext(request_context_getter);
-  core_->Start();
-}
-
 const GURL& URLFetcherImpl::GetOriginalURL() const {
   return core_->original_url_;
 }
 
 const GURL& URLFetcherImpl::GetURL() const {
   return core_->url_;
 }
 
 const net::URLRequestStatus& URLFetcherImpl::GetStatus() const {
   return core_->status_;
@@ skipping 69 matching lines @@
 
 // static
 content::URLFetcherFactory* URLFetcherImpl::factory() {
   return g_factory;
 }
 
 // static
 void URLFetcherImpl::set_factory(content::URLFetcherFactory* factory) {
   g_factory = factory;
 }