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

chrome/browser/safe_browsing/protocol_manager.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 "chrome/browser/safe_browsing/protocol_manager.h"
 
 #ifndef NDEBUG
 #include "base/base64.h"
 #endif
 #include "base/bind.h"
 #include "base/environment.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/rand_util.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/timer.h"
 #include "chrome/browser/safe_browsing/protocol_parser.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/env_vars.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/common/content_url_request_user_data.h"
 #include "content/public/common/url_fetcher.h"
 #include "net/base/escape.h"
 #include "net/base/load_flags.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_status.h"
 
 using base::Time;
 using base::TimeDelta;
 using content::BrowserThread;
 
@@ skipping 139 matching lines @@
   content::URLFetcher* fetcher = content::URLFetcher::Create(
       gethash_url, content::URLFetcher::POST, this);
   hash_requests_[fetcher] = check;
 
   std::string get_hash;
   SafeBrowsingProtocolParser parser;
   parser.FormatGetHash(prefixes, &get_hash);
 
   fetcher->SetLoadFlags(net::LOAD_DISABLE_CACHE);
   fetcher->SetRequestContext(request_context_getter_);
+  // TODO(jochen): Do cookie audit.
+  fetcher->SetContentURLRequestUserData(
+      new content::ContentURLRequestUserData());
   fetcher->SetUploadData("text/plain", get_hash);
   fetcher->Start();
 }
 
 void SafeBrowsingProtocolManager::GetNextUpdate() {
   if (initial_request_) {
     if (client_key_.empty() || wrapped_key_.empty()) {
       IssueKeyRequest();
       return;
     } else {
@@ skipping 367 matching lines @@
     return;
 
   ChunkUrl next_chunk = chunk_request_urls_.front();
   DCHECK(!next_chunk.url.empty());
   GURL chunk_url = NextChunkUrl(next_chunk.url);
   request_type_ = CHUNK_REQUEST;
   request_.reset(content::URLFetcher::Create(
       chunk_url, content::URLFetcher::GET, this));
   request_->SetLoadFlags(net::LOAD_DISABLE_CACHE);
   request_->SetRequestContext(request_context_getter_);
+  // TODO(jochen): Do cookie audit.
+  request_->SetContentURLRequestUserData(
+      new content::ContentURLRequestUserData());
   chunk_request_start_ = base::Time::Now();
   request_->Start();
 }
 
 void SafeBrowsingProtocolManager::IssueKeyRequest() {
   GURL key_url = MacKeyUrl();
   request_type_ = GETKEY_REQUEST;
   request_.reset(content::URLFetcher::Create(
       key_url, content::URLFetcher::GET, this));
   request_->SetLoadFlags(net::LOAD_DISABLE_CACHE);
   request_->SetRequestContext(request_context_getter_);
+  // TODO(jochen): Do cookie audit.
+  request_->SetContentURLRequestUserData(
+      new content::ContentURLRequestUserData());
   request_->Start();
 }
 
 void SafeBrowsingProtocolManager::OnGetChunksComplete(
     const std::vector<SBListChunkRanges>& lists, bool database_error) {
   DCHECK_EQ(request_type_, UPDATE_REQUEST);
   if (database_error) {
     UpdateFinished(false);
     ScheduleNextUpdate(false);
     return;
@@ skipping 22 matching lines @@
 
   if (!found_malware)
     list_data.append(FormatList(
         SBListChunkRanges(safe_browsing_util::kMalwareList), use_mac));
 
   GURL update_url = UpdateUrl(use_mac);
   request_.reset(content::URLFetcher::Create(
       update_url, content::URLFetcher::POST, this));
   request_->SetLoadFlags(net::LOAD_DISABLE_CACHE);
   request_->SetRequestContext(request_context_getter_);
+  // TODO(jochen): Do cookie audit.
+  request_->SetContentURLRequestUserData(
+      new content::ContentURLRequestUserData());
   request_->SetUploadData("text/plain", list_data);
   request_->Start();
 
   // Begin the update request timeout.
   update_timer_.Start(FROM_HERE, TimeDelta::FromSeconds(kSbMaxUpdateWaitSec),
                       this,
                       &SafeBrowsingProtocolManager::UpdateResponseTimeout);
 }
 
 // If we haven't heard back from the server with an update response, this method
@@ skipping 26 matching lines @@
     const std::string& post_data) {
   GURL report_url = SafeBrowsingHitUrl(malicious_url, page_url,
                                        referrer_url, is_subresource,
                                        threat_type);
   content::URLFetcher* report = content::URLFetcher::Create(
       report_url,
       post_data.empty() ? content::URLFetcher::GET : content::URLFetcher::POST,
       this);
   report->SetLoadFlags(net::LOAD_DISABLE_CACHE);
   report->SetRequestContext(request_context_getter_);
+  // TODO(jochen): Do cookie audit.
+  report->SetContentURLRequestUserData(
+      new content::ContentURLRequestUserData());
   if (!post_data.empty())
     report->SetUploadData("text/plain", post_data);
   report->Start();
   safebrowsing_reports_.insert(report);
 }
 
 // Sends malware details for users who opt-in.
 void SafeBrowsingProtocolManager::ReportMalwareDetails(
     const std::string& report) {
   GURL report_url = MalwareDetailsUrl();
   content::URLFetcher* fetcher = content::URLFetcher::Create(
       report_url, content::URLFetcher::POST, this);
   fetcher->SetLoadFlags(net::LOAD_DISABLE_CACHE);
   fetcher->SetRequestContext(request_context_getter_);
+  // TODO(jochen): Do cookie audit.
+  fetcher->SetContentURLRequestUserData(
+      new content::ContentURLRequestUserData());
   fetcher->SetUploadData("application/octet-stream", report);
   // Don't try too hard to send reports on failures.
   fetcher->SetAutomaticallyRetryOn5xx(false);
   fetcher->Start();
   safebrowsing_reports_.insert(fetcher);
 }
 
 
 // static
 std::string SafeBrowsingProtocolManager::FormatList(
@@ skipping 139 matching lines @@
   if (!additional_query_.empty()) {
     if (next_url.find("?") != std::string::npos) {
       next_url.append("&");
     } else {
       next_url.append("?");
     }
     next_url.append(additional_query_);
   }
   return GURL(next_url);
 }