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/url_fetcher_delegate.h"
 #include "content/public/common/url_fetcher_factory.h"
+#include "content/public/common/url_request_user_data.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"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
@@ skipping 205 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 process_id_;                   // pid/rid of the associated render view.

[jam, 2012/03/05 19:11:03]

nit: please don't say "pid" as that's confusing, as process_id is not the pid of
the renderer, but the (always) unique id. i would call these render_process_id
and render_view_id and that'll be self-documenting and consistent with the rest
of the code.

[jochen (gone - plz use gerrit), 2012/03/08 13:00:02]

Done.

+  int routing_id_;
   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 281 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)),
+      process_id_(-1),
+      routing_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 195 matching lines @@
 
     if (automatically_retry_on_5xx_ &&
         num_retries_ <= max_retries_) {
       StartOnIOThread();
       return;
     }
   } else {
     backoff_delay = base::TimeDelta();
   }
   request_context_getter_ = NULL;
+  process_id_ = -1;
+  routing_id_ = -1;
   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_);
+  if (process_id_ != -1 && routing_id_ != -1) {
+    request_->SetUserData(
+        content::URLRequestUserData::kUserDataKey,
+        new content::URLRequestUserData(process_id_, 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;
+  process_id_ = -1;
+  routing_id_ = -1;
   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::AssociateWithRenderView(int process_id, int routing_id) {
+  DCHECK_EQ(core_->process_id_, -1);
+  DCHECK_EQ(core_->routing_id_, -1);
+  DCHECK_GE(process_id, 0);
+  DCHECK_GE(routing_id, 0);
+  core_->process_id_ = process_id;
+  core_->routing_id_ = routing_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 71 matching lines @@
 
 // static
 content::URLFetcherFactory* URLFetcherImpl::factory() {
   return g_factory;
 }
 
 // static
 void URLFetcherImpl::set_factory(content::URLFetcherFactory* factory) {
   g_factory = factory;
 }