Fix a crash during shutdown where SafeBrowsingProtocolManager could end up getting back NULL for Pro

chrome/browser/safe_browsing/protocol_manager.cc

 // Copyright (c) 2006-2008 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"
 
 #include "base/file_version_info.h"
 #include "base/histogram.h"
 #include "base/logging.h"
 #include "base/rand_util.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "base/sys_info.h"
 #include "base/task.h"
 #include "base/timer.h"
 #include "chrome/browser/chrome_thread.h"
+#include "chrome/browser/net/url_request_context_getter.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/safe_browsing/protocol_parser.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/common/env_vars.h"
 #include "net/base/base64.h"
 #include "net/base/escape.h"
 #include "net/base/load_flags.h"
 
 using base::Time;
 using base::TimeDelta;
@@ skipping 27 matching lines @@
 // Maximum back off multiplier.
 static const int kSbMaxBackOff = 8;
 
 
 // SafeBrowsingProtocolManager implementation ----------------------------------
 
 SafeBrowsingProtocolManager::SafeBrowsingProtocolManager(
     SafeBrowsingService* sb_service,
     const std::string& client_name,
     const std::string& client_key,
-    const std::string& wrapped_key)
+    const std::string& wrapped_key,
+    URLRequestContextGetter* request_context_getter)
     : sb_service_(sb_service),
       request_type_(NO_REQUEST),
       update_error_count_(0),
       gethash_error_count_(0),
       update_back_off_mult_(1),
       gethash_back_off_mult_(1),
       next_update_sec_(-1),
       update_state_(FIRST_REQUEST),
       initial_request_(true),
       chunk_pending_to_write_(false),
       client_key_(client_key),
       wrapped_key_(wrapped_key),
       update_size_(0),
-      client_name_(client_name) {
+      client_name_(client_name),
+      request_context_getter_(request_context_getter) {
   // Set the backoff multiplier fuzz to a random value between 0 and 1.
   back_off_fuzz_ = static_cast<float>(base::RandDouble());
 
   // The first update must happen between 0-5 minutes of start up.
   next_update_sec_ = base::RandInt(60, kSbTimerStartIntervalSec);
 
   scoped_ptr<FileVersionInfo> version_info(
       FileVersionInfo::CreateFileVersionInfoForCurrentModule());
   if (!version_info.get())
     version_ = "0.1";
@@ skipping 39 matching lines @@
 
   GURL gethash_url(url);
   URLFetcher* fetcher = new URLFetcher(gethash_url, URLFetcher::POST, this);
   hash_requests_[fetcher] = check;
 
   std::string get_hash;
   SafeBrowsingProtocolParser parser;
   parser.FormatGetHash(prefixes, &get_hash);
 
   fetcher->set_load_flags(net::LOAD_DISABLE_CACHE);
-  fetcher->set_request_context(Profile::GetDefaultRequestContext());
+  fetcher->set_request_context(request_context_getter_);
   fetcher->set_upload_data("text/plain", get_hash);
   fetcher->Start();
 }
 
 void SafeBrowsingProtocolManager::GetNextUpdate() {
   if (initial_request_) {
     if (client_key_.empty() || wrapped_key_.empty()) {
       IssueKeyRequest();
       return;
     } else {
@@ skipping 355 matching lines @@
 
   ChunkUrl next_chunk = chunk_request_urls_.front();
   DCHECK(!next_chunk.url.empty());
   if (!StartsWithASCII(next_chunk.url, "http://", false) &&
       !StartsWithASCII(next_chunk.url, "https://", false))
     next_chunk.url = "http://" + next_chunk.url;
   GURL chunk_url(next_chunk.url);
   request_type_ = CHUNK_REQUEST;
   request_.reset(new URLFetcher(chunk_url, URLFetcher::GET, this));
   request_->set_load_flags(net::LOAD_DISABLE_CACHE);
-  request_->set_request_context(Profile::GetDefaultRequestContext());
+  request_->set_request_context(request_context_getter_);
   chunk_request_start_ = base::Time::Now();
   request_->Start();
 }
 
 void SafeBrowsingProtocolManager::IssueKeyRequest() {
   GURL key_url(StringPrintf(kSbNewKeyUrl,
                             client_name_.c_str(),
                             version_.c_str()));
   request_type_ = GETKEY_REQUEST;
   request_.reset(new URLFetcher(key_url, URLFetcher::GET, this));
   request_->set_load_flags(net::LOAD_DISABLE_CACHE);
-  request_->set_request_context(Profile::GetDefaultRequestContext());
+  request_->set_request_context(request_context_getter_);
   request_->Start();
 }
 
 void SafeBrowsingProtocolManager::OnGetChunksComplete(
     const std::vector<SBListChunkRanges>& lists, bool database_error) {
   DCHECK(request_type_ == UPDATE_REQUEST);
 
   if (database_error) {
     ScheduleNextUpdate(false);
     UpdateFinished(false);
@@ skipping 29 matching lines @@
                                  client_name_.c_str(),
                                  version_.c_str());
   if (use_mac) {
     url.append("&wrkey=");
     url.append(wrapped_key_);
   }
 
   GURL update_url(url);
   request_.reset(new URLFetcher(update_url, URLFetcher::POST, this));
   request_->set_load_flags(net::LOAD_DISABLE_CACHE);
-  request_->set_request_context(Profile::GetDefaultRequestContext());
+  request_->set_request_context(request_context_getter_);
   request_->set_upload_data("text/plain", list_data);
   request_->Start();
 
   // Begin the update request timeout.
   update_timer_.Start(TimeDelta::FromSeconds(kSbMaxUpdateWaitSec), this,
                       &SafeBrowsingProtocolManager::UpdateResponseTimeout);
 }
 
 // If we haven't heard back from the server with an update response, this method
 // will run. Close the current update session and schedule another update.
@@ skipping 21 matching lines @@
   std::string report_str = StringPrintf(
       kSbMalwareReportUrl,
       EscapeQueryParamValue(malware_url.spec()).c_str(),
       EscapeQueryParamValue(page_url.spec()).c_str(),
       EscapeQueryParamValue(referrer_url.spec()).c_str(),
       client_name_.c_str(),
       version_.c_str());
   GURL report_url(report_str);
   URLFetcher* report = new URLFetcher(report_url, URLFetcher::GET, this);
   report->set_load_flags(net::LOAD_DISABLE_CACHE);
-  report->set_request_context(Profile::GetDefaultRequestContext());
+  report->set_request_context(request_context_getter_);
   report->Start();
   malware_reports_.insert(report);
 }
 
 // static
 std::string SafeBrowsingProtocolManager::FormatList(
     const SBListChunkRanges& list, bool use_mac) {
   std::string formatted_results;
   formatted_results.append(list.name);
   formatted_results.append(";");
@@ skipping 23 matching lines @@
 void SafeBrowsingProtocolManager::HandleGetHashError(const Time& now) {
   int next = GetNextBackOffTime(&gethash_error_count_, &gethash_back_off_mult_);
   next_gethash_time_ = now + TimeDelta::FromSeconds(next);
 }
 
 void SafeBrowsingProtocolManager::UpdateFinished(bool success) {
   UMA_HISTOGRAM_COUNTS("SB2.UpdateSize", update_size_);
   update_size_ = 0;
   sb_service_->UpdateFinished(success);
 }