Design changes in browser/privacy_blacklist needed to integrate

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>
 
@@ skipping 88 matching lines @@
       continue;
     }
 
     // Match non-wildcard character.
     if (pattern[p++] != url[u++])
       return false;
   }
   return pattern[p] == '\0';
 }
 
-bool Blacklist::Entry::MatchType(const std::string& type) const {
+bool Blacklist::Entry::MatchesType(const std::string& type) const {
   return std::find(types_.begin(), types_.end(), type) != types_.end();
 }
 
 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)
     : pattern_(pattern), attributes_(0), provider_(provider) {}
 
 void Blacklist::Entry::AddAttributes(unsigned int attributes) {
   attributes_ |= attributes;
 }
 
 void Blacklist::Entry::AddType(const std::string& type) {
   types_.push_back(type);
 }
 
 void Blacklist::Entry::Merge(const Entry& entry) {
   attributes_ |= entry.attributes_;
 
   std::copy(entry.types_.begin(), entry.types_.end(),
             std::back_inserter(types_));
 }
 
 void Blacklist::Entry::SwapTypes(std::vector<std::string>* types) {
-  if (types && types->size()) {
-    types->swap(types_);
-  }
+  DCHECK(types);
+  types->swap(types_);
 }
 
 bool Blacklist::Match::MatchType(const std::string& type) const {
   for (std::vector<const Entry*>::const_iterator i = entries_.begin();
       i != entries_.end(); ++i) {
-    if ((*i)->MatchType(type))
+    if ((*i)->MatchesType(type))
       return true;
   }
   return false;
 }
 
 bool Blacklist::Match::IsBlocked(const GURL& url) const {
   return (attributes_ & kBlockAll) ||
     ((attributes_ & kBlockUnsecure) && !url.SchemeIsSecure());
 }
 
 Blacklist::Match::Match() : attributes_(0) {}
 
 void Blacklist::Match::AddEntry(const Entry* entry) {
   attributes_ |= entry->attributes();
   entries_.push_back(entry);
 }
 
-Blacklist::Blacklist(const FilePath& file) : is_good_(false) {
-  // No blacklist, nothing to load.
-  if (file.value().empty())
-    return;
-
-  FILE* fp = file_util::OpenFile(file, "rb");
-  if (fp == NULL)
-    return;
-
-  BlacklistStoreInput input(fp);
-
-  // Read the providers
-  std::size_t n = input.ReadNumProviders();
-  if (n == std::numeric_limits<uint32>::max())
-    return;
-
-  providers_.reserve(n);
-  std::string name;
-  std::string url;
-  for (std::size_t i = 0; i < n; ++i) {
-    if (!input.ReadProvider(&name, &url))
-      return;
-    providers_.push_back(new Provider(name.c_str(), url.c_str()));
-  }
-
-  // Read the entries
-  n = input.ReadNumEntries();
-  if (n == std::numeric_limits<uint32>::max())
-    return;
-
-  std::string pattern;
-  unsigned int attributes, provider;
-  std::vector<std::string> types;
-  for (unsigned int i = 0; i < n; ++i) {
-    if (!input.ReadEntry(&pattern, &attributes, &types, &provider))
-      return;
-
-    Entry* entry = new Entry(pattern, providers_[provider]);
-    entry->AddAttributes(attributes);
-    entry->SwapTypes(&types);
-    blacklist_.push_back(entry);
-  }
-
-  is_good_ = true;
+Blacklist::Blacklist() {
 }
 
 Blacklist::~Blacklist() {
-  for (std::vector<Entry*>::iterator i = blacklist_.begin();
-       i != blacklist_.end(); ++i)
-    delete *i;
-  for (std::vector<Provider*>::iterator i = providers_.begin();
-       i != providers_.end(); ++i)
-    delete *i;
+}
+
+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 {
-  if (!is_good_)
-    return NULL;  // Don't attempt to find matches if the data is corrupt.
-
   // 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;
   Match* match = NULL;
-  for (std::vector<Entry*>::const_iterator i = blacklist_.begin();
+  for (EntryList::const_iterator i = blacklist_.begin();
        i != blacklist_.end(); ++i) {
-    if (Matches((*i)->pattern(), url.host()+url.path())) {
+    if (Matches((*i)->pattern(), url.host() + url.path())) {
       if (!match)
         match = new Match;
-      match->AddEntry(*i);
+      match->AddEntry(i->get());
     }
   }
   return match;
 }
 
 std::string Blacklist::StripCookies(const std::string& header) {
   return net::HttpUtil::StripHeaders(header, cookie_headers, 2);
 }
 
 std::string Blacklist::StripCookieExpiry(const std::string& cookie) {
   std::string::size_type delim = cookie.find(';');
   std::string::size_type start = cookie.find("expires=", delim + 1);
   if (start != std::string::npos) {
     std::string::size_type i = start;
     // Make sure only whitespace precedes the expiry until a delimiter.
     while (cookie[--i] != ';')
       if (!IsAsciiWhitespace(cookie[i]))
         return cookie;
 
     std::string session_cookie(cookie, 0, i);
     std::string::size_type end = cookie.find(';', start + 1);
     if (end != std::string::npos)
       session_cookie.append(cookie.substr(end));
     return session_cookie;
   }
   return cookie;
 }