Moved ExtensionPrefs and related into extensions namespace

chrome/browser/extensions/extension_preference_api.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_preference_api.h"
 
 #include <map>
 #include <utility>
 
 #include "base/memory/singleton.h"
@@ skipping 269 matching lines @@
   args.Append(dict);
   const PrefService::Preference* pref =
       pref_service->FindPreference(browser_pref.c_str());
   CHECK(pref);
   ExtensionService* extension_service = profile_->GetExtensionService();
   PrefTransformerInterface* transformer =
       PrefMapping::GetInstance()->FindTransformerForBrowserPref(browser_pref);
   dict->Set(keys::kValue,
             transformer->BrowserToExtensionPref(pref->GetValue()));
   if (incognito) {
-    ExtensionPrefs* ep = extension_service->extension_prefs();
+    extensions::ExtensionPrefs* ep = extension_service->extension_prefs();
     dict->SetBoolean(keys::kIncognitoSpecific,
                      ep->HasIncognitoPrefValue(browser_pref));
   }
 
   helpers::DispatchEventToExtensions(profile_,
                                      event_name,
                                      &args,
                                      permission,
                                      incognito,
                                      browser_pref);
@@ skipping 54 matching lines @@
   result->SetString(keys::kLevelOfControl, level_of_control);
 
   // Retrieve pref value.
   PrefTransformerInterface* transformer =
       PrefMapping::GetInstance()->FindTransformerForBrowserPref(browser_pref);
   result->Set(keys::kValue,
               transformer->BrowserToExtensionPref(pref->GetValue()));
 
   // Retrieve incognito status.
   if (incognito) {
-    ExtensionPrefs* ep = profile_->GetExtensionService()->extension_prefs();
+    extensions::ExtensionPrefs* ep =
+        profile_->GetExtensionService()->extension_prefs();
     result->SetBoolean(keys::kIncognitoSpecific,
                        ep->HasIncognitoPrefValue(browser_pref));
   }
 
   result_.reset(result.release());
   return true;
 }
 
 SetPreferenceFunction::~SetPreferenceFunction() { }
 
 bool SetPreferenceFunction::RunImpl() {
   std::string pref_key;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &pref_key));
   DictionaryValue* details = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(1, &details));
 
   Value* value = NULL;
   EXTENSION_FUNCTION_VALIDATE(details->Get(keys::kValue, &value));
 
-  ExtensionPrefsScope scope = kExtensionPrefsScopeRegular;
+  extensions::ExtensionPrefsScope scope =
+      extensions::kExtensionPrefsScopeRegular;
   if (details->HasKey(keys::kScopeKey)) {
     std::string scope_str;
     EXTENSION_FUNCTION_VALIDATE(
         details->GetString(keys::kScopeKey, &scope_str));
 
     EXTENSION_FUNCTION_VALIDATE(helpers::StringToScope(scope_str, &scope));
   }
 
   // Check incognito scope.
-  bool incognito = (scope == kExtensionPrefsScopeIncognitoPersistent ||
-                    scope == kExtensionPrefsScopeIncognitoSessionOnly);
+  bool incognito =
+      (scope == extensions::kExtensionPrefsScopeIncognitoPersistent ||
+       scope == extensions::kExtensionPrefsScopeIncognitoSessionOnly);
   if (incognito) {
     // Regular profiles can't access incognito unless include_incognito is true.
     if (!profile()->IsOffTheRecord() && !include_incognito()) {
       error_ = keys::kIncognitoErrorMessage;
       return false;
     }
   } else {
     // Incognito profiles can't access regular mode ever, they only exist in
     // split mode.
     if (profile()->IsOffTheRecord()) {
       error_ = "Can't modify regular settings from an incognito context.";
       return false;
     }
   }
 
-  if (scope == kExtensionPrefsScopeIncognitoSessionOnly &&
+  if (scope == extensions::kExtensionPrefsScopeIncognitoSessionOnly &&
       !profile_->HasOffTheRecordProfile()) {
     error_ = keys::kIncognitoSessionOnlyErrorMessage;
     return false;
   }
 
   // Obtain pref.
   std::string browser_pref;
   if (!ValidateBrowserPref(pref_key, &browser_pref))
     return false;
-  ExtensionPrefs* prefs = profile_->GetExtensionService()->extension_prefs();
+  extensions::ExtensionPrefs* prefs =
+      profile_->GetExtensionService()->extension_prefs();
   const PrefService::Preference* pref =
       prefs->pref_service()->FindPreference(browser_pref.c_str());
   CHECK(pref);
 
   // Validate new value.
   EXTENSION_FUNCTION_VALIDATE(value->GetType() == pref->GetType());
   PrefTransformerInterface* transformer =
       PrefMapping::GetInstance()->FindTransformerForBrowserPref(browser_pref);
   std::string error;
   bool bad_message = false;
@@ skipping 13 matching lines @@
 }
 
 ClearPreferenceFunction::~ClearPreferenceFunction() { }
 
 bool ClearPreferenceFunction::RunImpl() {
   std::string pref_key;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &pref_key));
   DictionaryValue* details = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(1, &details));
 
-  ExtensionPrefsScope scope = kExtensionPrefsScopeRegular;
+  extensions::ExtensionPrefsScope scope =
+      extensions::kExtensionPrefsScopeRegular;
   if (details->HasKey(keys::kScopeKey)) {
     std::string scope_str;
     EXTENSION_FUNCTION_VALIDATE(
         details->GetString(keys::kScopeKey, &scope_str));
 
     EXTENSION_FUNCTION_VALIDATE(helpers::StringToScope(scope_str, &scope));
   }
 
   // Check incognito scope.
-  bool incognito = (scope == kExtensionPrefsScopeIncognitoPersistent ||
-                    scope == kExtensionPrefsScopeIncognitoSessionOnly);
+  bool incognito =
+      (scope == extensions::kExtensionPrefsScopeIncognitoPersistent ||
+       scope == extensions::kExtensionPrefsScopeIncognitoSessionOnly);
   if (incognito) {
     // We don't check incognito permissions here, as an extension should be
     // always allowed to clear its own settings.
   } else {
     // Incognito profiles can't access regular mode ever, they only exist in
     // split mode.
     if (profile()->IsOffTheRecord()) {
       error_ = "Can't modify regular settings from an incognito context.";
       return false;
     }
   }
 
   std::string browser_pref;
   if (!ValidateBrowserPref(pref_key, &browser_pref))
     return false;
 
-  ExtensionPrefs* prefs = profile_->GetExtensionService()->extension_prefs();
+  extensions::ExtensionPrefs* prefs =
+      profile_->GetExtensionService()->extension_prefs();
   prefs->RemoveExtensionControlledPref(extension_id(), browser_pref, scope);
   return true;
 }