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/public/common/content_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 207 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
+  scoped_ptr<content::ContentURLRequestUserData> content_url_request_user_data_;
   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 301 matching lines @@
 
 URLFetcherImpl::Core::~Core() {
   // |request_| should be NULL.  If not, it's unsafe to delete it here since we
   // may not be on the IO thread.
   DCHECK(!request_.get());
 }
 
 void URLFetcherImpl::Core::Start() {
   DCHECK(delegate_loop_proxy_);
   DCHECK(request_context_getter_) << "We need an URLRequestContext!";
+  DCHECK(content_url_request_user_data_.get())
+      << "We need a ContentURLRequestUserData!";
   if (io_message_loop_proxy_) {
     DCHECK_EQ(io_message_loop_proxy_,
               request_context_getter_->GetIOMessageLoopProxy());
   } else {
     io_message_loop_proxy_ = request_context_getter_->GetIOMessageLoopProxy();
   }
   DCHECK(io_message_loop_proxy_.get()) << "We need an IO message loop proxy";
 
   io_message_loop_proxy_->PostTask(
       FROM_HERE, base::Bind(&Core::StartOnIOThread, this));
@@ skipping 175 matching lines @@
 
     if (automatically_retry_on_5xx_ &&
         num_retries_ <= max_retries_) {
       StartOnIOThread();
       return;
     }
   } else {
     backoff_delay = base::TimeDelta();
   }
   request_context_getter_ = NULL;
+  content_url_request_user_data_.reset(NULL);
   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 13 matching lines @@
 void URLFetcherImpl::Core::StartURLRequest() {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 
   if (was_cancelled_) {
     // Since StartURLRequest() is posted as a *delayed* task, it may
     // run after the URLFetcher was already stopped.
     return;
   }
 
   DCHECK(request_context_getter_);
+  DCHECK(content_url_request_user_data_.get());
   DCHECK(!request_.get());
 
   g_registry.Get().AddURLFetcherCore(this);
   current_response_bytes_ = 0;
   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_->SetUserData(
+      content::ContentURLRequestUserData::kUserDataKey,
+      new content::ContentURLRequestUserData(
+          content_url_request_user_data_->process_id(),
+          content_url_request_user_data_->routing_id()));
 
   switch (request_type_) {
     case GET:
       break;
 
     case POST:
     case PUT:
       DCHECK(!upload_content_.empty() || is_chunked_upload_);
       DCHECK(!upload_content_type_.empty());
 
@@ skipping 60 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;
+  content_url_request_user_data_.reset(NULL);
   was_cancelled_ = true;
   temp_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 113 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::SetContentURLRequestUserData(
+    content::ContentURLRequestUserData* user_data) {
+  DCHECK(!core_->content_url_request_user_data_.get());
+  core_->content_url_request_user_data_.reset(user_data);
+}
+
 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) {
+void URLFetcherImpl::StartWithRequestContextGetterAndUserData(
+    net::URLRequestContextGetter* request_context_getter,
+    content::ContentURLRequestUserData* user_data) {
   SetRequestContext(request_context_getter);
+  SetContentURLRequestUserData(user_data);
   core_->Start();
 }
 
 const GURL& URLFetcherImpl::GetOriginalURL() const {
   return core_->original_url_;
 }
 
 const GURL& URLFetcherImpl::GetURL() const {
   return core_->url_;
 }
@@ skipping 74 matching lines @@
 
 // static
 content::URLFetcherFactory* URLFetcherImpl::factory() {
   return g_factory;
 }
 
 // static
 void URLFetcherImpl::set_factory(content::URLFetcherFactory* factory) {
   g_factory = factory;
 }