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

chrome/browser/safe_browsing/safe_browsing_service.cc

 // Copyright (c) 2009 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/safe_browsing_service.h"
 
 #include "base/command_line.h"
 #include "base/histogram.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_thread.h"
+#include "chrome/browser/net/url_request_context_getter.h"
 #include "chrome/browser/profile_manager.h"
 #include "chrome/browser/safe_browsing/protocol_manager.h"
 #include "chrome/browser/safe_browsing/safe_browsing_blocking_page.h"
 #include "chrome/browser/safe_browsing/safe_browsing_database.h"
 #include "chrome/browser/tab_contents/navigation_entry.h"
 #include "chrome/browser/tab_contents/tab_util.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/pref_service.h"
 #include "chrome/common/url_constants.h"
 #if defined(OS_WIN)
 #include "chrome/installer/util/browser_distribution.h"
 #endif
 #include "net/base/registry_controlled_domain.h"
 
 using base::Time;
 using base::TimeDelta;
 
+static Profile* GetDefaultProfile() {
+  FilePath user_data_dir;
+  PathService::Get(chrome::DIR_USER_DATA, &user_data_dir);
+  ProfileManager* profile_manager = g_browser_process->profile_manager();
+  return profile_manager->GetDefaultProfile(user_data_dir);
+}
+
 SafeBrowsingService::SafeBrowsingService()
     : database_(NULL),
       protocol_manager_(NULL),
       enabled_(false),
       resetting_(false),
       database_loaded_(false),
       update_in_progress_(false) {
 }
 
 SafeBrowsingService::~SafeBrowsingService() {
 }
 
 // Only called on the UI thread.
 void SafeBrowsingService::Initialize() {
   // Get the profile's preference for SafeBrowsing.
-  FilePath user_data_dir;
-  PathService::Get(chrome::DIR_USER_DATA, &user_data_dir);
-  ProfileManager* profile_manager = g_browser_process->profile_manager();
-  Profile* profile = profile_manager->GetDefaultProfile(user_data_dir);
-  PrefService* pref_service = profile->GetPrefs();
+  PrefService* pref_service = GetDefaultProfile()->GetPrefs();
   if (pref_service->GetBoolean(prefs::kSafeBrowsingEnabled))
     Start();
 }
 
 // Start up SafeBrowsing objects. This can be called at browser start, or when
 // the user checks the "Enable SafeBrowsing" option in the Advanced options UI.
 void SafeBrowsingService::Start() {
   DCHECK(!safe_browsing_thread_.get());
   safe_browsing_thread_.reset(new base::Thread("Chrome_SafeBrowsingThread"));
   if (!safe_browsing_thread_->Start())
     return;
 
   // Retrieve client MAC keys.
   PrefService* local_state = g_browser_process->local_state();
   std::string client_key, wrapped_key;
   if (local_state) {
     client_key =
       WideToASCII(local_state->GetString(prefs::kSafeBrowsingClientKey));
     wrapped_key =
       WideToASCII(local_state->GetString(prefs::kSafeBrowsingWrappedKey));
   }
 
+  // We will issue network fetches using the default profile's request context.
+  URLRequestContextGetter* request_context_getter =
+      GetDefaultProfile()->GetRequestContext();
+  request_context_getter->AddRef();  // Balanced in OnIOInitialize.
+
   ChromeThread::PostTask(
       ChromeThread::IO, FROM_HERE,
       NewRunnableMethod(
-          this, &SafeBrowsingService::OnIOInitialize, client_key, wrapped_key));
+          this, &SafeBrowsingService::OnIOInitialize, client_key, wrapped_key,
+          request_context_getter));
 
   safe_browsing_thread_->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
       this, &SafeBrowsingService::OnDBInitialize));
 }
 
 void SafeBrowsingService::ShutDown() {
   ChromeThread::PostTask(
       ChromeThread::IO, FROM_HERE,
       NewRunnableMethod(this, &SafeBrowsingService::OnIOShutdown));
 }
 
-void SafeBrowsingService::OnIOInitialize(const std::string& client_key,
-                                         const std::string& wrapped_key) {
+void SafeBrowsingService::OnIOInitialize(
+    const std::string& client_key,
+    const std::string& wrapped_key,
+    URLRequestContextGetter* request_context_getter) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
   enabled_ = true;
 
   // On Windows, get the safe browsing client name from the browser
   // distribution classes in installer util. These classes don't yet have
   // an analog on non-Windows builds so just keep the name specified here.
 #if defined(OS_WIN)
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
   std::string client_name(dist->GetSafeBrowsingName());
 #else
 #if defined(GOOGLE_CHROME_BUILD)
   std::string client_name("googlechrome");
 #else
   std::string client_name("chromium");
 #endif
 #endif
 
   protocol_manager_ = new SafeBrowsingProtocolManager(this,
                                                       client_name,
                                                       client_key,
-                                                      wrapped_key);
+                                                      wrapped_key,
+                                                      request_context_getter);
+
+  // Balance the reference added by Start().
+  request_context_getter->Release();
+
   // We want to initialize the protocol manager only after the database has
   // loaded, which we'll receive asynchronously (DatabaseLoadComplete). If
   // database_loaded_ isn't true, we'll wait for that notification to do the
   // init.
   if (database_loaded_)
     protocol_manager_->Initialize();
 }
 
 void SafeBrowsingService::OnDBInitialize() {
   DCHECK(MessageLoop::current() == safe_browsing_thread_->message_loop());
@@ skipping 566 matching lines @@
   // report if it's not there.
   std::string list;
   std::vector<SBPrefix> prefix_hits;
   std::vector<SBFullHashResult> full_hits;
   database_->ContainsUrl(page_url, &list, &prefix_hits, &full_hits,
                          protocol_manager_->last_update());
 
   if (full_hits.empty())
     protocol_manager_->ReportMalware(malware_url, page_url, referrer_url);
 }