Readability review for joaodasilva

chrome/browser/policy/url_blacklist_manager.cc

 // Copyright (c) 2011 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/policy/url_blacklist_manager.h"
 
 #include "base/bind.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "base/values.h"
@@ skipping 11 matching lines @@
 namespace {
 
 // Maximum filters per policy. Filters over this index are ignored.
 const size_t kMaxFiltersPerPolicy = 100;
 
 typedef std::vector<std::string> StringVector;
 
 StringVector* ListValueToStringVector(const base::ListValue* list) {
   StringVector* vector = new StringVector;
 
-  if (!list)
+  if (list == NULL)
     return vector;
 
   vector->reserve(list->GetSize());
   std::string s;
   for (base::ListValue::const_iterator it = list->begin();
        it != list->end() && vector->size() < kMaxFiltersPerPolicy; ++it) {
     if ((*it)->GetAsString(&s))
       vector->push_back(s);
   }
 
@@ skipping 16 matching lines @@
   for (StringVector::iterator it = allow->begin(); it != allow->end(); ++it) {
     blacklist->Allow(*it);
   }
 }
 
 // A task that owns the URLBlacklist, and passes it to the URLBlacklistManager
 // on the IO thread, if the URLBlacklistManager still exists.
 void SetBlacklistOnIO(base::WeakPtr<URLBlacklistManager> blacklist_manager,
                       URLBlacklist* blacklist) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  if (blacklist_manager)
+  if (blacklist_manager) {
     blacklist_manager->SetBlacklist(blacklist);
-  else
+  } else {
     delete blacklist;
+  }
 }
 
 }  // namespace
 
+struct URLBlacklist::PathFilter {
+  explicit PathFilter(const std::string& path, uint16 port, bool match)
+      : path_prefix(path),
+        port(port),
+        blocked_schemes(0),
+        allowed_schemes(0),
+        match_subdomains(match) {}
+
+  std::string path_prefix;
+  uint16 port;
+  uint8 blocked_schemes;
+  uint8 allowed_schemes;
+  bool match_subdomains;
+};
+
 URLBlacklist::URLBlacklist() {
 }
 
 URLBlacklist::~URLBlacklist() {
   STLDeleteValues(&host_filters_);
 }
 
 void URLBlacklist::Block(const std::string& filter) {
   AddFilter(filter, true);
 }
@@ skipping 12 matching lines @@
   std::string host(url.host());
   int int_port = url.EffectiveIntPort();
   const uint16 port = int_port > 0 ? int_port : 0;
   const std::string& path = url.path();
 
   // The first iteration through the loop will be an exact host match.
   // Subsequent iterations are subdomain matches, and some filters don't apply
   // to those.
   bool is_matching_subdomains = false;
   const bool host_is_ip = url.HostIsIPAddress();
-  for (;;) {
+  while (1) {
     HostFilterTable::const_iterator host_filter = host_filters_.find(host);
     if (host_filter != host_filters_.end()) {
       const PathFilterList* list = host_filter->second;
       size_t longest_length = 0;
       bool is_blocked = false;
       bool has_match = false;
       bool has_exact_host_match = false;
       for (PathFilterList::const_iterator it = list->begin();
            it != list->end(); ++it) {
         // Filters that apply to an exact hostname only take precedence over
@@ skipping 52 matching lines @@
       ++i;
     host.erase(0, i);
   }
 
   // Default is to allow.
   return false;
 }
 
 // static
 bool URLBlacklist::SchemeToFlag(const std::string& scheme, SchemeFlag* flag) {
-  if (scheme.empty())
+  if (scheme.empty()) {
     *flag = SCHEME_ALL;
-  else if (scheme == "http")
+  } else if (scheme == "http") {
     *flag = SCHEME_HTTP;
-  else if (scheme == "https")
+  } else if (scheme == "https") {
     *flag = SCHEME_HTTPS;
-  else if (scheme == "ftp")
+  } else if (scheme == "ftp") {
     *flag = SCHEME_FTP;
-  else
+  } else {
     return false;
+  }
   return true;
 }
 
 // static
 bool URLBlacklist::FilterToComponents(const std::string& filter,
                                    std::string* scheme,
                                    std::string* host,
                                    uint16* port,
                                    std::string* path) {
   url_parse::Parsed parsed;
@@ skipping 32 matching lines @@
     path->clear();
 
   return true;
 }
 
 void URLBlacklist::AddFilter(const std::string& filter, bool block) {
   std::string scheme;
   std::string host;
   uint16 port;
   std::string path;
-  SchemeFlag flag;
-  bool match_subdomains = true;
-
   if (!FilterToComponents(filter, &scheme, &host, &port, &path)) {
     LOG(WARNING) << "Invalid filter, ignoring: " << filter;
     return;
   }
 
+  SchemeFlag flag;
   if (!SchemeToFlag(scheme, &flag)) {
     LOG(WARNING) << "Unsupported scheme in filter, ignoring filter: " << filter;
     return;
   }
 
+  bool match_subdomains = true;
   // Special syntax to disable subdomain matching.
   if (!host.empty() && host[0] == '.') {
     host.erase(0, 1);
     match_subdomains = false;
   }
 
   // Try to find an existing PathFilter with the same path prefix, port and
   // match_subdomains value.
   PathFilterList* list;
   HostFilterTable::iterator host_filter = host_filters_.find(host);
   if (host_filter == host_filters_.end()) {
     list = new PathFilterList;
     host_filters_[host] = list;
   } else {
     list = host_filter->second;
   }
   PathFilterList::iterator it;
   for (it = list->begin(); it != list->end(); ++it) {
     if (it->port == port && it->match_subdomains == match_subdomains &&
-        it->path_prefix == path)
+        it->path_prefix == path) {
       break;
+    }
   }
   PathFilter* path_filter;
   if (it == list->end()) {
     list->push_back(PathFilter(path, port, match_subdomains));
     path_filter = &list->back();
   } else {
     path_filter = &(*it);
   }
 
-  if (block)
+  if (block) {
     path_filter->blocked_schemes |= flag;
-  else
+  } else {
     path_filter->allowed_schemes |= flag;
+  }
 }
 
 URLBlacklistManager::URLBlacklistManager(PrefService* pref_service)
     : ALLOW_THIS_IN_INITIALIZER_LIST(ui_weak_ptr_factory_(this)),
       pref_service_(pref_service),
       ALLOW_THIS_IN_INITIALIZER_LIST(io_weak_ptr_factory_(this)),
       blacklist_(new URLBlacklist) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   pref_change_registrar_.Init(pref_service_);
@@ skipping 85 matching lines @@
 
 // static
 void URLBlacklistManager::RegisterPrefs(PrefService* pref_service) {
   pref_service->RegisterListPref(prefs::kUrlBlacklist,
                                  PrefService::UNSYNCABLE_PREF);
   pref_service->RegisterListPref(prefs::kUrlWhitelist,
                                  PrefService::UNSYNCABLE_PREF);
 }
 
 }  // namespace policy