Moved ExtensionPrefs and related into extensions namespace

chrome/browser/extensions/extension_pref_value_map.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_pref_value_map.h"
 
 #include "base/stl_util.h"
 #include "base/values.h"
 #include "chrome/browser/prefs/pref_value_map.h"
 
+using extensions::ExtensionPrefsScope;
+
 struct ExtensionPrefValueMap::ExtensionEntry {
   // Installation time of the extension.
   base::Time install_time;
   // Whether extension is enabled in the profile.
   bool enabled;
   // Extension controlled preferences for the regular profile.
   PrefValueMap regular_profile_preferences;
   // Extension controlled preferences that should *only* apply to the regular
   // profile.
   PrefValueMap regular_only_profile_preferences;
@@ skipping 127 matching lines @@
   i->second->enabled = is_enabled;
   NotifyPrefValueChanged(keys);
 }
 
 PrefValueMap* ExtensionPrefValueMap::GetExtensionPrefValueMap(
     const std::string& ext_id,
     ExtensionPrefsScope scope) {
   ExtensionEntryMap::const_iterator i = entries_.find(ext_id);
   CHECK(i != entries_.end());
   switch (scope) {
-    case kExtensionPrefsScopeRegular:
+    case extensions::kExtensionPrefsScopeRegular:
       return &(i->second->regular_profile_preferences);
-    case kExtensionPrefsScopeRegularOnly:
+    case extensions::kExtensionPrefsScopeRegularOnly:
       return &(i->second->regular_only_profile_preferences);
-    case kExtensionPrefsScopeIncognitoPersistent:
+    case extensions::kExtensionPrefsScopeIncognitoPersistent:
       return &(i->second->incognito_profile_preferences_persistent);
-    case kExtensionPrefsScopeIncognitoSessionOnly:
+    case extensions::kExtensionPrefsScopeIncognitoSessionOnly:
       return &(i->second->incognito_profile_preferences_session_only);
   }
   NOTREACHED();
   return NULL;
 }
 
 const PrefValueMap* ExtensionPrefValueMap::GetExtensionPrefValueMap(
     const std::string& ext_id,
     ExtensionPrefsScope scope) const {
   ExtensionEntryMap::const_iterator i = entries_.find(ext_id);
   CHECK(i != entries_.end());
   switch (scope) {
-    case kExtensionPrefsScopeRegular:
+    case extensions::kExtensionPrefsScopeRegular:
       return &(i->second->regular_profile_preferences);
-    case kExtensionPrefsScopeRegularOnly:
+    case extensions::kExtensionPrefsScopeRegularOnly:
       return &(i->second->regular_only_profile_preferences);
-    case kExtensionPrefsScopeIncognitoPersistent:
+    case extensions::kExtensionPrefsScopeIncognitoPersistent:
       return &(i->second->incognito_profile_preferences_persistent);
-    case kExtensionPrefsScopeIncognitoSessionOnly:
+    case extensions::kExtensionPrefsScopeIncognitoSessionOnly:
       return &(i->second->incognito_profile_preferences_session_only);
   }
   NOTREACHED();
   return NULL;
 }
 
 void ExtensionPrefValueMap::GetExtensionControlledKeys(
     const ExtensionEntry& entry,
     std::set<std::string>* out) const {
   PrefValueMap::const_iterator i;
@@ skipping 26 matching lines @@
       GetEffectivePrefValueController(key, incognito, from_incognito);
   if (winner == entries_.end())
     return NULL;
 
   const Value* value = NULL;
   const std::string& ext_id = winner->first;
 
   // First search for incognito session only preferences.
   if (incognito) {
     const PrefValueMap* prefs = GetExtensionPrefValueMap(
-        ext_id, kExtensionPrefsScopeIncognitoSessionOnly);
+        ext_id, extensions::kExtensionPrefsScopeIncognitoSessionOnly);
     prefs->GetValue(key, &value);
     if (value)
       return value;
 
     // If no incognito session only preference exists, fall back to persistent
     // incognito preference.
-    prefs = GetExtensionPrefValueMap(ext_id,
-                                     kExtensionPrefsScopeIncognitoPersistent);
+    prefs = GetExtensionPrefValueMap(
+        ext_id,
+        extensions::kExtensionPrefsScopeIncognitoPersistent);
     prefs->GetValue(key, &value);
     if (value)
       return value;
   } else {
     // Regular-only preference.
     const PrefValueMap* prefs = GetExtensionPrefValueMap(
-        ext_id, kExtensionPrefsScopeRegularOnly);
+        ext_id, extensions::kExtensionPrefsScopeRegularOnly);
     prefs->GetValue(key, &value);
     if (value)
       return value;
   }
 
   // Regular preference.
   const PrefValueMap* prefs = GetExtensionPrefValueMap(
-      ext_id, kExtensionPrefsScopeRegular);
+      ext_id, extensions::kExtensionPrefsScopeRegular);
   prefs->GetValue(key, &value);
   return value;
 }
 
 ExtensionPrefValueMap::ExtensionEntryMap::const_iterator
 ExtensionPrefValueMap::GetEffectivePrefValueController(
     const std::string& key,
     bool incognito,
     bool* from_incognito) const {
   ExtensionEntryMap::const_iterator winner = entries_.end();
   base::Time winners_install_time;
 
   ExtensionEntryMap::const_iterator i;
   for (i = entries_.begin(); i != entries_.end(); ++i) {
     const std::string& ext_id = i->first;
     const base::Time& install_time = i->second->install_time;
     const bool enabled = i->second->enabled;
 
     if (!enabled)
       continue;
     if (install_time < winners_install_time)
       continue;
 
     const Value* value = NULL;
     const PrefValueMap* prefs = GetExtensionPrefValueMap(
-        ext_id, kExtensionPrefsScopeRegular);
+        ext_id, extensions::kExtensionPrefsScopeRegular);
     if (prefs->GetValue(key, &value)) {
       winner = i;
       winners_install_time = install_time;
       if (from_incognito)
         *from_incognito = false;
     }
 
     if (!incognito) {
       const PrefValueMap* prefs = GetExtensionPrefValueMap(
-          ext_id, kExtensionPrefsScopeRegularOnly);
+          ext_id, extensions::kExtensionPrefsScopeRegularOnly);
       if (prefs->GetValue(key, &value)) {
         winner = i;
         winners_install_time = install_time;
         if (from_incognito)
           *from_incognito = false;
       }
       // Ignore the following prefs, because they're incognito-only.
       continue;
     }
 
     prefs = GetExtensionPrefValueMap(
-        ext_id, kExtensionPrefsScopeIncognitoPersistent);
+        ext_id, extensions::kExtensionPrefsScopeIncognitoPersistent);
     if (prefs->GetValue(key, &value)) {
       winner = i;
       winners_install_time = install_time;
       if (from_incognito)
         *from_incognito = true;
     }
 
     prefs = GetExtensionPrefValueMap(
-        ext_id, kExtensionPrefsScopeIncognitoSessionOnly);
+        ext_id, extensions::kExtensionPrefsScopeIncognitoSessionOnly);
     if (prefs->GetValue(key, &value)) {
       winner = i;
       winners_install_time = install_time;
       if (from_incognito)
         *from_incognito = true;
     }
   }
   return winner;
 }
 
@@ skipping 31 matching lines @@
 
 void ExtensionPrefValueMap::NotifyPrefValueChanged(const std::string& key) {
   FOR_EACH_OBSERVER(ExtensionPrefValueMap::Observer, observers_,
                     OnPrefValueChanged(key));
 }
 
 void ExtensionPrefValueMap::NotifyOfDestruction() {
   FOR_EACH_OBSERVER(ExtensionPrefValueMap::Observer, observers_,
                     OnExtensionPrefValueMapDestruction());
 }