Moved ExtensionPrefs and related into extensions namespace

chrome/browser/extensions/extension_prefs.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/extensions/extension_prefs.h"
 
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/extensions/admin_policy.h"
 #include "chrome/browser/extensions/api/omnibox/omnibox_api.h"
 #include "chrome/browser/extensions/extension_pref_store.h"
 #include "chrome/browser/extensions/extension_sorting.h"
 #include "chrome/browser/prefs/pref_notifier.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension_switch_utils.h"
 #include "chrome/common/extensions/manifest.h"
 #include "chrome/common/extensions/permissions/permissions_info.h"
 #include "chrome/common/extensions/url_pattern.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/notification_service.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 
-using extensions::APIPermission;
-using extensions::APIPermissionSet;
-using extensions::Extension;
-using extensions::ExtensionInfo;
-using extensions::PermissionsInfo;
-using extensions::PermissionSet;
+namespace extensions {
 
 namespace {
 
 // Additional preferences keys
 
 // Where an extension was installed from. (see Extension::Location)
 const char kPrefLocation[] = "location";
 
 // Enabled, disabled, killed, etc. (see Extension::State)
 const char kPrefState[] = "state";
@@ skipping 226 matching lines @@
 
 ExtensionPrefs::ExtensionPrefs(
     PrefService* prefs,
     const FilePath& root_dir,
     ExtensionPrefValueMap* extension_pref_value_map)
     : prefs_(prefs),
       install_directory_(root_dir),
       extension_pref_value_map_(extension_pref_value_map),
       ALLOW_THIS_IN_INITIALIZER_LIST(extension_sorting_(
           new ExtensionSorting(this, prefs))),
-      content_settings_store_(new extensions::ContentSettingsStore()) {
+      content_settings_store_(new ContentSettingsStore()) {
 }
 
 ExtensionPrefs::~ExtensionPrefs() {
 }
 
 void ExtensionPrefs::Init(bool extensions_disabled) {
   MakePathsRelative();
 
   InitPrefStore(extensions_disabled);
 
@@ skipping 346 matching lines @@
 
 std::string ExtensionPrefs::GetDebugPolicyProviderName() const {
 #ifdef NDEBUG
   NOTREACHED();
   return std::string();
 #else
   return "admin policy black/white/forcelist, via the ExtensionPrefs";
 #endif
 }
 
-bool ExtensionPrefs::UserMayLoad(const extensions::Extension* extension,
+bool ExtensionPrefs::UserMayLoad(const Extension* extension,
                                  string16* error) const {
 
   const base::ListValue* blacklist =
       prefs_->GetList(prefs::kExtensionInstallDenyList);
   const base::ListValue* whitelist =
       prefs_->GetList(prefs::kExtensionInstallAllowList);
-  return extensions::admin_policy::UserMayLoad(blacklist, whitelist, extension,
+  return admin_policy::UserMayLoad(blacklist, whitelist, extension,
                                                error);
 }
 
 bool ExtensionPrefs::UserMayModifySettings(const Extension* extension,
                                            string16* error) const {
-  return extensions::admin_policy::UserMayModifySettings(extension, error);
+  return admin_policy::UserMayModifySettings(extension, error);
 }
 
 bool ExtensionPrefs::MustRemainEnabled(const Extension* extension,
                                        string16* error) const {
-  return extensions::admin_policy::MustRemainEnabled(extension, error);
+  return admin_policy::MustRemainEnabled(extension, error);
 }
 
 bool ExtensionPrefs::ExtensionsBlacklistedByDefault() const {
-  return extensions::admin_policy::BlacklistedByDefault(
+  return admin_policy::BlacklistedByDefault(
       prefs_->GetList(prefs::kExtensionInstallDenyList));
 }
 
 bool ExtensionPrefs::DidExtensionEscalatePermissions(
     const std::string& extension_id) {
   return ReadExtensionPrefBoolean(extension_id,
                                   kExtensionDidEscalatePermissions);
 }
 
 void ExtensionPrefs::SetDidExtensionEscalatePermissions(
@@ skipping 338 matching lines @@
 void ExtensionPrefs::SetRegisteredEvents(
     const std::string& extension_id, const std::set<std::string>& events) {
   ListValue* value = new ListValue();
   for (std::set<std::string>::const_iterator it = events.begin();
        it != events.end(); ++it) {
     value->Append(new StringValue(*it));
   }
   UpdateExtensionPref(extension_id, kRegisteredEvents, value);
 }
 
-extensions::ExtensionOmniboxSuggestion
+ExtensionOmniboxSuggestion
 ExtensionPrefs::GetOmniboxDefaultSuggestion(const std::string& extension_id) {
-  extensions::ExtensionOmniboxSuggestion suggestion;
+  ExtensionOmniboxSuggestion suggestion;
 
   const base::DictionaryValue* extension = GetExtensionPref(extension_id);
   base::DictionaryValue* dict = NULL;
   if (extension && extension->GetDictionary(kOmniboxDefaultSuggestion, &dict))
     suggestion.Populate(*dict, false);
 
   return suggestion;
 }
 
 void ExtensionPrefs::SetOmniboxDefaultSuggestion(
     const std::string& extension_id,
-    const extensions::ExtensionOmniboxSuggestion& suggestion) {
+    const ExtensionOmniboxSuggestion& suggestion) {
   scoped_ptr<base::DictionaryValue> dict = suggestion.ToValue().Pass();
   UpdateExtensionPref(extension_id, kOmniboxDefaultSuggestion, dict.release());
 }
 
 bool ExtensionPrefs::IsIncognitoEnabled(const std::string& extension_id) {
   return ReadExtensionPrefBoolean(extension_id, kPrefIncognitoEnabled);
 }
 
 void ExtensionPrefs::SetIsIncognitoEnabled(const std::string& extension_id,
                                            bool enabled) {
@@ skipping 229 matching lines @@
 void ExtensionPrefs::SetExtensionState(const std::string& extension_id,
                                        Extension::State state) {
   UpdateExtensionPref(extension_id, kPrefState,
                       Value::CreateIntegerValue(state));
   bool enabled = (state == Extension::ENABLED);
   extension_pref_value_map_->SetExtensionState(extension_id, enabled);
   content_settings_store_->SetExtensionState(extension_id, enabled);
 }
 
 bool ExtensionPrefs::GetBrowserActionVisibility(const Extension* extension) {
-  bool action_box_enabled = extensions::switch_utils::IsActionBoxEnabled();
+  bool action_box_enabled = switch_utils::IsActionBoxEnabled();
   bool default_value = !action_box_enabled;
 
   const DictionaryValue* extension_prefs = GetExtensionPref(extension->id());
   if (!extension_prefs)
     return default_value;
 
   bool visible = false;
   const char* browser_action_pref = action_box_enabled ? kBrowserActionPinned :
                                                          kBrowserActionVisible;
   bool pref_exists = extension_prefs->GetBoolean(browser_action_pref, &visible);
   if (!pref_exists)
     return default_value;
 
   return visible;
 }
 
 void ExtensionPrefs::SetBrowserActionVisibility(const Extension* extension,
                                                 bool visible) {
   if (GetBrowserActionVisibility(extension) == visible)
     return;
 
-  bool action_box_enabled = extensions::switch_utils::IsActionBoxEnabled();
+  bool action_box_enabled = switch_utils::IsActionBoxEnabled();
   const char* browser_action_pref = action_box_enabled ? kBrowserActionPinned :
                                                          kBrowserActionVisible;
   UpdateExtensionPref(extension->id(), browser_action_pref,
                       Value::CreateBooleanValue(visible));
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_EXTENSION_BROWSER_ACTION_VISIBILITY_CHANGED,
       content::Source<ExtensionPrefs>(this),
       content::Details<const Extension>(extension));
 }
 
@@ skipping 612 matching lines @@
                             PrefService::UNSYNCABLE_PREF);
   prefs->RegisterInt64Pref(prefs::kLastExtensionsUpdateCheck,
                            0,  // default value
                            PrefService::UNSYNCABLE_PREF);
   prefs->RegisterInt64Pref(prefs::kNextExtensionsUpdateCheck,
                            0,  // default value
                            PrefService::UNSYNCABLE_PREF);
   prefs->RegisterListPref(prefs::kExtensionAllowedInstallSites,
                           PrefService::UNSYNCABLE_PREF);
 }
+
+}  // namespace extensions