Rename "managed (mode|user)" to "supervised user" (part 2)

chrome/browser/supervised_user/supervised_user_site_list.cc

 // Copyright (c) 2012 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/managed_mode/managed_mode_site_list.h"
+#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;
@@ skipping 46 matching lines @@
     if (g_categories[i].identifier == category)
       return i + 1;
   }
   return 0;
 }
 
 // Takes a DictionaryValue entry from the JSON file and fills the whitelist
 // (via URL patterns or hostname hashes) and the URL in the corresponding Site
 // struct.
 void AddWhitelistEntries(const base::DictionaryValue* site_dict,
-                         ManagedModeSiteList::Site* site) {
+                         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) {
       std::string pattern;
       if (!(*whitelist_it)->GetAsString(&pattern)) {
@@ skipping 35 matching lines @@
   if (!url.is_valid()) {
     LOG(ERROR) << "URL " << url_str << " is invalid";
     return;
   }
 
   patterns->push_back(url.host());
 }
 
 }  // namespace
 
-ManagedModeSiteList::Site::Site(const base::string16& name,
-                                int category_id)
+SupervisedUserSiteList::Site::Site(const base::string16& name,
+                                   int category_id)
     : name(name),
       category_id(category_id) {}
 
-ManagedModeSiteList::Site::~Site() {}
+SupervisedUserSiteList::Site::~Site() {}
 
-ManagedModeSiteList::ManagedModeSiteList(
+SupervisedUserSiteList::SupervisedUserSiteList(
     const std::string& extension_id,
     const base::FilePath& path)
     : extension_id_(extension_id),
       path_(path) {
 }
 
-ManagedModeSiteList::~ManagedModeSiteList() {
+SupervisedUserSiteList::~SupervisedUserSiteList() {
 }
 
-ManagedModeSiteList* ManagedModeSiteList::Clone() {
-  return new ManagedModeSiteList(extension_id_, path_);
+SupervisedUserSiteList* SupervisedUserSiteList::Clone() {
+  return new SupervisedUserSiteList(extension_id_, path_);
 }
 
 // static
-void ManagedModeSiteList::GetCategoryNames(
+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 ManagedModeSiteList::GetSites(std::vector<Site>* sites) {
+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)) {
       LOG(ERROR) << "Entry is invalid";
       continue;
     }
@@ skipping 15 matching lines @@
         }
         category_id = GetCategoryId(category);
         break;
       }
     }
     sites->push_back(Site(name, category_id));
     AddWhitelistEntries(entry, &sites->back());
   }
 }
 
-bool ManagedModeSiteList::LazyLoad() {
+bool SupervisedUserSiteList::LazyLoad() {
   if (sites_.get())
     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 20 matching lines @@
   if (dict->GetList(kSitesKey, &sites))
     sites_.reset(sites->DeepCopy());
 
   base::DictionaryValue* categories = NULL;
   if (dict->GetDictionary(kCategoriesKey, &categories))
     categories_.reset(categories->DeepCopy());
 
   return true;
 }
 
-void ManagedModeSiteList::CopyThumbnailUrl(const base::DictionaryValue* source,
-                                           base::DictionaryValue* dest) {
+void SupervisedUserSiteList::CopyThumbnailUrl(
+    const base::DictionaryValue* source,
+    base::DictionaryValue* dest) {
   if (!source->HasKey(kThumbnailKey))
     return;
 
   std::string thumbnail;
   if (!source->GetString(kThumbnailKey, &thumbnail)) {
     LOG(ERROR) << "Invalid thumbnail";
     return;
   }
 
   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());
 }