c/b/supervised_user: Use range-based for where appropriate.

chrome/browser/supervised_user/supervised_user_site_list.cc

 // Copyright 2014 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/supervised_user/supervised_user_site_list.h"
 
 #include "base/json/json_file_value_serializer.h"
 #include "base/logging.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "extensions/common/extension.h"
 
-using base::DictionaryValue;
-using base::ListValue;
-using base::Value;
-
 const int kSitelistFormatVersion = 1;
 
 const char kCategoriesKey[] = "categories";
 const char kHostnameHashesKey[] = "hostname_hashes";
 const char kNameKey[] = "name";
 const char kSitesKey[] = "sites";
 const char kSitelistFormatVersionKey[] = "version";
 const char kThumbnailKey[] = "thumbnail";
 const char kThumbnailUrlKey[] = "thumbnail_url";
 const char kUrlKey[] = "url";
@@ skipping 42 matching lines @@
 // (via URL patterns or hostname hashes) and the URL in the corresponding Site
 // struct.
 void AddWhitelistEntries(const base::DictionaryValue* site_dict,
                          SupervisedUserSiteList::Site* site) {
   std::vector<std::string>* patterns = &site->patterns;
 
   bool found = false;
   const base::ListValue* whitelist = NULL;
   if (site_dict->GetList(kWhitelistKey, &whitelist)) {
     found = true;
-    for (base::ListValue::const_iterator whitelist_it = whitelist->begin();
-         whitelist_it != whitelist->end(); ++whitelist_it) {
+    for (const base::Value* entry : *whitelist) {
       std::string pattern;
-      if (!(*whitelist_it)->GetAsString(&pattern)) {
+      if (!entry->GetAsString(&pattern)) {
         LOG(ERROR) << "Invalid whitelist entry";
         continue;
       }
 
       patterns->push_back(pattern);
     }
   }
 
   std::vector<std::string>* hashes = &site->hostname_hashes;
   const base::ListValue* hash_list = NULL;
   if (site_dict->GetList(kHostnameHashesKey, &hash_list)) {
     found = true;
-    for (base::ListValue::const_iterator hash_list_it = hash_list->begin();
-         hash_list_it != hash_list->end(); ++hash_list_it) {
+    for (const base::Value* entry : *hash_list) {
       std::string hash;
-      if (!(*hash_list_it)->GetAsString(&hash)) {
+      if (!entry->GetAsString(&hash)) {
         LOG(ERROR) << "Invalid whitelist entry";
         continue;
       }
 
       hashes->push_back(hash);
     }
   }
 
   if (found)
     return;
@@ skipping 26 matching lines @@
 SupervisedUserSiteList::SupervisedUserSiteList(
     const std::string& extension_id,
     const base::FilePath& path)
     : extension_id_(extension_id),
       path_(path) {
 }
 
 SupervisedUserSiteList::~SupervisedUserSiteList() {
 }
 
-SupervisedUserSiteList* SupervisedUserSiteList::Clone() {
+SupervisedUserSiteList* SupervisedUserSiteList::Clone() const {
   return new SupervisedUserSiteList(extension_id_, path_);
 }
 
 // static
 void SupervisedUserSiteList::GetCategoryNames(
     std::vector<base::string16>* categories) {
   // TODO(bauerb): Collect custom categories from extensions.
   for (size_t i = 0; i < arraysize(g_categories); ++i) {
     categories->push_back(base::ASCIIToUTF16(g_categories[i].name));
   }
 }
 
 void SupervisedUserSiteList::GetSites(std::vector<Site>* sites) {
   if (!LazyLoad())
     return;
 
-  for (base::ListValue::iterator entry_it = sites_->begin();
-       entry_it != sites_->end(); ++entry_it) {
-    base::DictionaryValue* entry = NULL;
-    if (!(*entry_it)->GetAsDictionary(&entry)) {
+  for (const base::Value* site : *sites_) {
+    const base::DictionaryValue* entry = NULL;
+    if (!site->GetAsDictionary(&entry)) {
       LOG(ERROR) << "Entry is invalid";
       continue;
     }
 
     base::string16 name;
     entry->GetString(kNameKey, &name);
 
     // TODO(bauerb): We need to distinguish between "no category assigned" and
     // "not on any site list".
     int category_id = 0;
     const base::ListValue* categories = NULL;
     if (entry->GetList(kCategoriesKey, &categories)) {
-      for (base::ListValue::const_iterator it = categories->begin();
-           it != categories->end(); ++it) {
+      for (const base::Value* category_entry : *categories) {
         std::string category;
-        if (!(*it)->GetAsString(&category)) {
+        if (!category_entry->GetAsString(&category)) {
           LOG(ERROR) << "Invalid category";
           continue;
         }
         category_id = GetCategoryId(category);
         break;
       }
     }
     sites->push_back(Site(name, category_id));
     AddWhitelistEntries(entry, &sites->back());
   }
 }
 
 bool SupervisedUserSiteList::LazyLoad() {
-  if (sites_.get())
+  if (sites_)
     return true;
 
   JSONFileValueSerializer serializer(path_);
   std::string error;
   scoped_ptr<base::Value> value(serializer.Deserialize(NULL, &error));
   if (!value.get()) {
     LOG(ERROR) << "Couldn't load site list " << path_.value() << ": "
                << error;
     return false;
   }
@@ skipping 41 matching lines @@
   GURL base_url =
       extensions::Extension::GetBaseURLFromExtensionId(extension_id_);
   GURL thumbnail_url = base_url.Resolve(thumbnail);
   if (!thumbnail_url.is_valid()) {
     LOG(ERROR) << "Invalid thumbnail";
     return;
   }
 
   dest->SetString(kThumbnailUrlKey, thumbnail_url.spec());
 }