Integrate BlacklistManager with Profile.

chrome/browser/net/chrome_url_request_context.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/net/chrome_url_request_context.h"
 
 #include "base/command_line.h"
 #include "base/string_util.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/privacy_blacklist/blacklist.h"
 #include "chrome/browser/chrome_thread.h"
 #include "chrome/browser/extensions/extensions_service.h"
 #include "chrome/browser/extensions/user_script_master.h"
 #include "chrome/browser/net/sqlite_persistent_cookie_store.h"
 #include "chrome/browser/net/dns_global.h"
+#include "chrome/browser/privacy_blacklist/blacklist_manager.h"
 #include "chrome/browser/profile.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "net/ftp/ftp_network_layer.h"
 #include "net/http/http_cache.h"
 #include "net/http/http_network_layer.h"
 #include "net/http/http_util.h"
 #include "net/proxy/proxy_config_service_fixed.h"
 #include "net/proxy/proxy_script_fetcher.h"
 #include "net/proxy/proxy_service.h"
 #include "net/url_request/url_request.h"
 #include "webkit/glue/webkit_glue.h"
 
 #if defined(OS_LINUX)
 #include "net/ocsp/nss_ocsp.h"
 #endif
 
 namespace {
-// TODO(eroman): The ChromeURLRequestContext's Blacklist* is shared with the
-//               Profile... This is a problem since the Profile dies before
-//               the IO thread, so we may end up accessing a deleted variable.
-//               http://crbug.com/26733.
 
 // ----------------------------------------------------------------------------
 // Helper methods to check current thread
 // ----------------------------------------------------------------------------
 
 void CheckCurrentlyOnIOThread() {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
 }
 
 void CheckCurrentlyOnMainThread() {
@@ skipping 628 matching lines @@
 }
 
 bool ChromeURLRequestContext::InterceptCookie(const URLRequest* request,
                                               std::string* cookie) {
   const URLRequest::UserData* d =
       request->GetUserData(&Blacklist::kRequestDataKey);
   if (d) {
     const Blacklist::Match* match = static_cast<const Blacklist::Match*>(d);
     if (match->attributes() & Blacklist::kDontStoreCookies) {
       NotificationService::current()->Notify(
-          NotificationType::BLACKLIST_BLOCKED_RESOURCE,
+          NotificationType::BLACKLIST_NONVISUAL_RESOURCE_BLOCKED,
           Source<const ChromeURLRequestContext>(this),
           Details<const URLRequest>(request));
 
       cookie->clear();
       return false;
     }
     if (match->attributes() & Blacklist::kDontPersistCookies) {
       *cookie = Blacklist::StripCookieExpiry(*cookie);
     }
   }
   return true;
 }
 
 bool ChromeURLRequestContext::AllowSendingCookies(const URLRequest* request)
     const {
   const URLRequest::UserData* d =
       request->GetUserData(&Blacklist::kRequestDataKey);
   if (d) {
     const Blacklist::Match* match = static_cast<const Blacklist::Match*>(d);
     if (match->attributes() & Blacklist::kDontSendCookies) {
       NotificationService::current()->Notify(
-          NotificationType::BLACKLIST_BLOCKED_RESOURCE,
+          NotificationType::BLACKLIST_NONVISUAL_RESOURCE_BLOCKED,
           Source<const ChromeURLRequestContext>(this),
           Details<const URLRequest>(request));
 
       return false;
     }
   }
   return true;
 }
 
+const Blacklist* ChromeURLRequestContext::GetBlacklist() const {
+  // TODO(phajdan.jr): Remove the check when Privacy Blacklists become stable.
+  if (!blacklist_manager_)
+    return NULL;
+  return blacklist_manager_->GetCompiledBlacklist();
+}
+
 void ChromeURLRequestContext::OnNewExtensions(const std::string& id,
                                               const FilePath& path) {
   if (!is_off_the_record_)
     extension_paths_[id] = path;
 }
 
 void ChromeURLRequestContext::OnUnloadedExtension(const std::string& id) {
   CheckCurrentlyOnIOThread();
   if (is_off_the_record_)
     return;
@@ skipping 14 matching lines @@
   ftp_transaction_factory_ = other->ftp_transaction_factory_;
   cookie_store_ = other->cookie_store_;
   cookie_policy_.set_type(other->cookie_policy_.type());
   strict_transport_security_state_ = other->strict_transport_security_state_;
   accept_language_ = other->accept_language_;
   accept_charset_ = other->accept_charset_;
   referrer_charset_ = other->referrer_charset_;
 
   // Set ChromeURLRequestContext members
   appcache_service_ = other->appcache_service_;
+  blacklist_manager_ = other->blacklist_manager_;
   extension_paths_ = other->extension_paths_;
   user_script_dir_path_ = other->user_script_dir_path_;
-  blacklist_ = other->blacklist_;
   is_media_ = other->is_media_;
   is_off_the_record_ = other->is_off_the_record_;
 }
 
+void ChromeURLRequestContext::set_blacklist_manager(
+    BlacklistManager* blacklist_manager) {
+  blacklist_manager_ = blacklist_manager;
+}
+
 void ChromeURLRequestContext::OnAcceptLanguageChange(
     const std::string& accept_language) {
   CheckCurrentlyOnIOThread();
   accept_language_ =
       net::HttpUtil::GenerateAcceptLanguageHeader(accept_language);
 }
 
 void ChromeURLRequestContext::OnCookiePolicyChange(
     net::CookiePolicy::Type type) {
   CheckCurrentlyOnIOThread();
@@ skipping 40 matching lines @@
   // For the latter, we need a change on the webkit-side.
   // We initialize it to the default charset here and a user will
   // have an *arguably* better default charset for interpreting a raw 8bit
   // C-D header field.  It means the native OS codepage fallback in
   // net_util::GetSuggestedFilename is unlikely to be taken.
   referrer_charset_ = default_charset;
 
   cookie_policy_type_ = net::CookiePolicy::FromInt(
       prefs->GetInteger(prefs::kCookieBehavior));
 
-  // TODO(eroman): this doesn't look safe; sharing between IO and UI threads!
-  blacklist_ = profile->GetBlacklist();
+  blacklist_manager_ = profile->GetBlacklistManager();
 
   // TODO(eroman): this doesn't look safe; sharing between IO and UI threads!
   strict_transport_security_state_ = profile->GetStrictTransportSecurityState();
 
   if (profile->GetExtensionsService()) {
     const ExtensionList* extensions =
         profile->GetExtensionsService()->extensions();
     for (ExtensionList::const_iterator iter = extensions->begin();
         iter != extensions->end(); ++iter) {
       extension_paths_[(*iter)->id()] = (*iter)->path();
@@ skipping 18 matching lines @@
   // Apply all the parameters. NOTE: keep this in sync with
   // ChromeURLRequestContextFactory(Profile*).
   context->set_is_media(is_media_);
   context->set_is_off_the_record(is_off_the_record_);
   context->set_accept_language(accept_language_);
   context->set_accept_charset(accept_charset_);
   context->set_referrer_charset(referrer_charset_);
   context->set_cookie_policy_type(cookie_policy_type_);
   context->set_extension_paths(extension_paths_);
   context->set_user_script_dir_path(user_script_dir_path_);
-  context->set_blacklist(blacklist_);
+  context->set_blacklist_manager(blacklist_manager_.get());
   context->set_strict_transport_security_state(
       strict_transport_security_state_);
   context->set_ssl_config_service(ssl_config_service_);
 }
 
 // ----------------------------------------------------------------------------
 
 net::ProxyConfig* CreateProxyConfig(const CommandLine& command_line) {
   // Scan for all "enable" type proxy switches.
   static const char* proxy_switches[] = {
@@ skipping 44 matching lines @@
   }
 
   if (command_line.HasSwitch(switches::kProxyBypassList)) {
     proxy_config->ParseNoProxyList(
         WideToASCII(command_line.GetSwitchValue(
             switches::kProxyBypassList)));
   }
 
   return proxy_config;
 }