Implement delaying resource requests until privacy blacklists are ready.

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/privacy_blacklist/blacklist_request_info.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"
@@ skipping 642 matching lines @@
   return result;
 }
 
 const std::string& ChromeURLRequestContext::GetUserAgent(
     const GURL& url) const {
   return webkit_glue::GetUserAgent(url);
 }
 
 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_NONVISUAL_RESOURCE_BLOCKED,
-          Source<const ChromeURLRequestContext>(this),
-          Details<const URLRequest>(request));
+  BlacklistRequestInfo* request_info =
+      BlacklistRequestInfo::FromURLRequest(request);
+  // Requests which don't go through ResourceDispatcherHost don't have privacy
+  // blacklist request data.
+  if (!request_info)
+    return true;
+  const BlacklistManager* blacklist_manager =
+      request_info->GetBlacklistManager();
+  // TODO(phajdan.jr): remove the NULL check when blacklists are stable.
+  if (!blacklist_manager)
+    return NULL;
+  const Blacklist* blacklist = blacklist_manager->GetCompiledBlacklist();
+  scoped_ptr<Blacklist::Match> match(blacklist->findMatch(request->url()));
+  if (!match.get())
+    return true;
+  if (match->attributes() & Blacklist::kDontStoreCookies) {
+    NotificationService::current()->Notify(
+        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);
-    }
+    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_NONVISUAL_RESOURCE_BLOCKED,
-          Source<const ChromeURLRequestContext>(this),
-          Details<const URLRequest>(request));
+  BlacklistRequestInfo* request_info =
+      BlacklistRequestInfo::FromURLRequest(request);
+  // Requests which don't go through ResourceDispatcherHost don't have privacy
+  // blacklist request data.
+  if (!request_info)
+    return true;
+  const BlacklistManager* blacklist_manager =
+      request_info->GetBlacklistManager();
+  // TODO(phajdan.jr): remove the NULL check when blacklists are stable.
+  if (!blacklist_manager)
+    return NULL;
+  const Blacklist* blacklist = blacklist_manager->GetCompiledBlacklist();
+  scoped_ptr<Blacklist::Match> match(blacklist->findMatch(request->url()));
+  if (!match.get())
+    return true;
+  if (match->attributes() & Blacklist::kDontSendCookies) {
+    NotificationService::current()->Notify(
+        NotificationType::BLACKLIST_NONVISUAL_RESOURCE_BLOCKED,
+        Source<const ChromeURLRequestContext>(this),
+        Details<const URLRequest>(request));
 
-      return false;
-    }
+    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();
+BlacklistManager* ChromeURLRequestContext::GetBlacklistManager() const {
+  return blacklist_manager_.get();
 }
 
 void ChromeURLRequestContext::OnNewExtensions(
     const std::string& id,
     const FilePath& path,
     const std::string& default_locale) {
   if (!is_off_the_record_) {
     extension_paths_[id] = path;
     if (!default_locale.empty())
       extension_default_locales_[id] = default_locale;
@@ skipping 211 matching lines @@
   }
 
   if (command_line.HasSwitch(switches::kProxyBypassList)) {
     proxy_config->ParseNoProxyList(
         WideToASCII(command_line.GetSwitchValue(
             switches::kProxyBypassList)));
   }
 
   return proxy_config;
 }