Remove abonded privacy blacklist implementation.

chrome/browser/privacy_blacklist/blacklist.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/privacy_blacklist/blacklist.h"
-
-#include <algorithm>
-#include <limits>
-#include <string>
-
-#include "base/file_path.h"
-#include "base/file_util.h"
-#include "base/string_util.h"
-#include "chrome/browser/pref_service.h"
-#include "chrome/browser/profile.h"
-#include "chrome/common/pref_names.h"
-#include "chrome/common/url_constants.h"
-#include "net/http/http_util.h"
-
-namespace {
-
-const char* const cookie_headers[2] = { "cookie", "set-cookie" };
-
-} // namespace
-
-const unsigned int Blacklist::kBlockAll = 1;
-const unsigned int Blacklist::kBlockCookies = 1 << 1;
-const unsigned int Blacklist::kDontSendReferrer = 1 << 2;
-const unsigned int Blacklist::kDontSendUserAgent = 1 << 3;
-const unsigned int Blacklist::kBlockUnsecure = 1 << 4;
-const unsigned int Blacklist::kBlockRequest = kBlockAll | kBlockUnsecure;
-const unsigned int Blacklist::kModifySentHeaders =
-    kBlockCookies | kDontSendUserAgent | kDontSendReferrer;
-const unsigned int Blacklist::kModifyReceivedHeaders = kBlockCookies;
-
-// static
-bool Blacklist::Matches(const std::string& pattern, const std::string& url) {
-  if (pattern.size() > url.size())
-    return false;
-
-  std::string::size_type p = 0;
-  std::string::size_type u = 0;
-
-  while (pattern[p] != '\0' && url[u] != '\0') {
-    if (pattern[p] == '@') {
-      while (pattern[++p] == '@') {}  // Consecutive @ are redundant.
-
-      if (pattern[p] == '\0')
-        return true;  // Nothing to match after the @.
-
-      // Look for another wildcard to determine pattern-chunk.
-      std::string::size_type tp = pattern.find_first_of("@", p);
-
-      // If it must match until the end, compare the last characters.
-      if (tp == std::string::npos) {
-        std::string::size_type ur = url.size() - u;
-        std::string::size_type pr = pattern.size() - p;
-        return (pr <= ur) &&
-            (url.compare(url.size() - pr, pr, pattern.c_str() + p) == 0);
-      }
-
-      // Else find the pattern chunk which is pattern[p:tp]
-      std::string::size_type tu = url.find(pattern.c_str() + p, u, tp - p);
-      if (tu == std::string::npos)
-        return false;  // Pattern chunk not found.
-
-      // Since tp is strictly greater than p, both u and p always increase.
-      u = tu + tp - p;
-      p = tp;
-      continue;
-    }
-
-    // Match non-wildcard character.
-    if (pattern[p++] != url[u++])
-      return false;
-  }
-  return pattern[p] == '\0';
-}
-
-bool Blacklist::Entry::IsBlocked(const GURL& url) const {
-  return (attributes_ & kBlockAll) ||
-    ((attributes_ & kBlockUnsecure) && !url.SchemeIsSecure());
-}
-
-Blacklist::Entry::Entry(const std::string& pattern, const Provider* provider,
-                        bool is_exception)
-    : attributes_(0),
-      is_exception_(is_exception),
-      pattern_(pattern),
-      provider_(provider) {}
-
-void Blacklist::Entry::AddAttributes(unsigned int attributes) {
-  attributes_ |= attributes;
-}
-
-bool Blacklist::Match::IsBlocked(const GURL& url) const {
-  return (attributes() & kBlockAll) ||
-    ((attributes() & kBlockUnsecure) && !url.SchemeIsSecure());
-}
-
-Blacklist::Match::Match() : matching_attributes_(0), exception_attributes_(0) {}
-
-void Blacklist::Match::AddEntry(const Entry* entry) {
-  if (entry->is_exception()) {
-    exception_attributes_ |= entry->attributes();
-    exception_entries_.push_back(entry);
-  } else {
-    matching_attributes_ |= entry->attributes();
-    matching_entries_.push_back(entry);
-  }
-}
-
-Blacklist::Blacklist(PrefService* prefs) : prefs_(prefs) {
-  LoadPreferences();
-}
-
-Blacklist::~Blacklist() {
-}
-
-void Blacklist::AddEntry(Entry* entry) {
-  DCHECK(entry);
-  blacklist_.push_back(linked_ptr<Entry>(entry));
-}
-
-void Blacklist::AddProvider(Provider* provider) {
-  DCHECK(provider);
-  providers_.push_back(linked_ptr<Provider>(provider));
-}
-
-// Returns a pointer to the Blacklist-owned entry which matches the given
-// URL. If no matching Entry is found, returns null.
-Blacklist::Match* Blacklist::FindMatch(const GURL& url) const {
-  // Never match something which is not http, https or ftp.
-  // TODO(idanan): Investigate if this would be an inclusion test instead of an
-  // exclusion test and if there are other schemes to test for.
-  if (!url.SchemeIs(chrome::kHttpScheme) &&
-      !url.SchemeIs(chrome::kHttpsScheme) &&
-      !url.SchemeIs(chrome::kFtpScheme))
-    return 0;
-  std::string url_spec = GetURLAsLookupString(url);
-  Match* match = NULL;
-  for (EntryList::const_iterator i = blacklist_.begin();
-       i != blacklist_.end(); ++i) {
-    if (Matches((*i)->pattern(), url_spec)) {
-      if (!match)
-        match = new Match;
-      match->AddEntry(i->get());
-    }
-  }
-  return match;
-}
-
-bool Blacklist::LoadEntryPreference(const ListValue& pref,
-                                    const Provider* provider) {
-  EntryList entries;
-  for (ListValue::const_iterator i = pref.begin(); i != pref.end(); ++i) {
-    if (!(*i)->IsType(Value::TYPE_DICTIONARY))
-      return false;
-    const DictionaryValue* entry_pref = static_cast<DictionaryValue*>(*i);
-    std::string pattern;
-    int attributes;
-    bool is_exception;
-    if (!(entry_pref->GetString(L"pattern", &pattern) &&
-          entry_pref->GetInteger(L"attributes", &attributes) &&
-          entry_pref->GetBoolean(L"exception", &is_exception)))
-      return false;
-    Entry* entry = new Entry(pattern, provider, is_exception);
-    entry->AddAttributes(static_cast<unsigned int>(attributes));
-    entries.push_back(linked_ptr<Entry>(entry));
-  }
-  blacklist_.insert(blacklist_.end(), entries.begin(), entries.end());
-  return true;
-}
-
-bool Blacklist::LoadProviderPreference(const DictionaryValue& pref,
-                                       const std::wstring& path) {
-  std::string name, url;
-  ListValue* entries;
-  if (!(pref.GetString(L"name", &name) && pref.GetString(L"url", &url) &&
-        pref.GetList(L"entries", &entries)))
-    return false;
-  linked_ptr<Provider> provider(new Provider(name, url, path));
-  if (LoadEntryPreference(*entries, provider.get()))
-    providers_.push_back(provider);
-    return true;
-  return false;
-}
-
-bool Blacklist::LoadPreferences() {
-  DCHECK(prefs_);
-  const DictionaryValue* blacklist_rules = prefs_->GetDictionary(
-      prefs::kPrivacyFilterRules);
-  if (!blacklist_rules)
-    return false;
-  bool result = true;
-  for (DictionaryValue::key_iterator key = blacklist_rules->begin_keys();
-       key != blacklist_rules->end_keys(); ++key) {
-    DictionaryValue* provider;
-    if (!(blacklist_rules->GetDictionaryWithoutPathExpansion(*key, &provider) &&
-         LoadProviderPreference(*provider, *key)))
-      result = false;
-  }
-  return result;
-}
-
-// static
-std::string Blacklist::GetURLAsLookupString(const GURL& url) {
-  std::string url_spec = url.host() + url.path();
-  if (!url.query().empty())
-    url_spec = url_spec + "?" + url.query();
-
-  return url_spec;
-}
-
-// static
-void Blacklist::RegisterUserPrefs(PrefService* user_prefs) {
-  user_prefs->RegisterDictionaryPref(prefs::kPrivacyFilterRules);
-}
-
-// static
-std::string Blacklist::StripCookies(const std::string& header) {
-  return net::HttpUtil::StripHeaders(header, cookie_headers, 2);
-}