Cosmetic cleanups in chrome/browser/policy/

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/string_util.h"
 #include "base/values.h"
 #include "chrome/browser/net/url_fixer_upper.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/pref_names.h"
 #include "content/browser/browser_thread.h"
 #include "content/common/notification_details.h"
 #include "content/common/notification_source.h"
 #include "googleurl/src/gurl.h"
 
@@ skipping 58 matching lines @@
 
 }  // namespace
 
 URLBlacklist::URLBlacklist() {
 }
 
 URLBlacklist::~URLBlacklist() {
   STLDeleteValues(&host_filters_);
 }
 
-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;
-  }
-
-  if (!SchemeToFlag(scheme, &flag)) {
-    LOG(WARNING) << "Unsupported scheme in filter, ignoring filter: " << filter;
-    return;
-  }
-
-  // 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)
-      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)
-    path_filter->blocked_schemes |= flag;
-  else
-    path_filter->allowed_schemes |= flag;
-}
-
 void URLBlacklist::Block(const std::string& filter) {
   AddFilter(filter, true);
 }
 
 void URLBlacklist::Allow(const std::string& filter) {
   AddFilter(filter, false);
 }
 
 bool URLBlacklist::IsURLBlocked(const GURL& url) const {
   SchemeFlag flag = SCHEME_ALL;
@@ skipping 135 matching lines @@
   }
 
   if (parsed.path.is_nonempty())
     path->assign(filter, parsed.path.begin, parsed.path.len);
   else
     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;
+  }
+
+  if (!SchemeToFlag(scheme, &flag)) {
+    LOG(WARNING) << "Unsupported scheme in filter, ignoring filter: " << filter;
+    return;
+  }
+
+  // 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)
+      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)
+    path_filter->blocked_schemes |= flag;
+  else
+    path_filter->allowed_schemes |= flag;
+}
+
 URLBlacklistManager::URLBlacklistManager(PrefService* pref_service)
     : ALLOW_THIS_IN_INITIALIZER_LIST(ui_method_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_);
   pref_change_registrar_.Add(prefs::kUrlBlacklist, this);
   pref_change_registrar_.Add(prefs::kUrlWhitelist, this);
@@ 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