Cleanup and style guideline conformance for policy implementation

chrome/browser/extensions/extension_pref_store.h

 // Copyright (c) 2010 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.
 
 #ifndef CHROME_BROWSER_EXTENSIONS_EXTENSION_PREF_STORE_H_
 #define CHROME_BROWSER_EXTENSIONS_EXTENSION_PREF_STORE_H_
 #pragma once
 
 #include <list>
 #include <map>
@@ skipping 15 matching lines @@
 class Profile;
 class Value;
 
 // This PrefStore keeps track of preferences set by extensions: for example,
 // proxy settings. A stack of relevant extensions is stored in order of
 // their addition to this PrefStore. For each preference, the last-added
 // enabled extension that tries to set it overrules any others.
 class ExtensionPrefStore : public PrefStore,
                            public NotificationObserver {
  public:
+  // Maps preference paths to their values.
+  typedef std::map<const char*, Value*> PrefValueMap;
+
+  // The type passed as Details for an EXTENSION_PREF_CHANGED notification.
+  // The nested pairs are <extension, <pref_path, pref_value> >. This is here,
+  // rather than in (say) notification_type.h, to keep the dependency on
+  // std::pair out of the many places that include notification_type.h.
+  typedef std::pair<const Extension*, std::pair<const char*, Value*> >
+      ExtensionPrefDetails;
+
   ExtensionPrefStore(Profile* profile, PrefNotifier::PrefStoreType type);
   virtual ~ExtensionPrefStore();
 
   // Begins tracking the preference and value an extension wishes to set. This
   // must be called each time an extension API tries to set a preference.
   // The ExtensionPrefStore will take ownership of the |pref_value|.
   virtual void InstallExtensionPref(const Extension* extension,
                                     const char* pref_path,
                                     Value* pref_value);
 
   // Removes an extension and all its preference settings from this PrefStore.
   // This must be called when an extension is uninstalled or disabled.
   virtual void UninstallExtension(const Extension* extension);
 
   // PrefStore methods:
-  virtual DictionaryValue* prefs() { return prefs_.get(); }
+  virtual DictionaryValue* prefs() const { return prefs_.get(); }
 
   virtual PrefReadError ReadPrefs() { return PREF_READ_ERROR_NONE; }
 
-  // The type passed as Details for an EXTENSION_PREF_CHANGED notification.
-  // The nested pairs are <extension, <pref_path, pref_value> >. This is here,
-  // rather than in (say) notification_type.h, to keep the dependency on
-  // std::pair out of the many places that include notification_type.h.
-  typedef std::pair<const Extension*, std::pair<const char*, Value*> >
-      ExtensionPrefDetails;
-
  protected:
   // Returns a vector of the extension IDs in the extension_stack_.
   // This should only be accessed by subclasses for unit-testing.
   void GetExtensionIDs(std::vector<std::string>* result);
 
   // Returns the applicable pref service from the profile (if we have one) or
   // the browser's local state. This should only be accessed or overridden by
   // subclasses for unit-testing.
   virtual PrefService* GetPrefService();
 
  private:
-  // Maps preference paths to their values.
-  typedef std::map<const char*, Value*> PrefValueMap;
+  // Associates an extension with the prefs it sets. Owns the pref values.
+  struct ExtensionPrefs {
+    ExtensionPrefs(const Extension* extension, PrefValueMap* values);
+    ~ExtensionPrefs();
+
+    const Extension* extension;
+    PrefValueMap* pref_values;
+  };
+
+  // A pseudo-stack of extensions and their preferences. Extensions are always
+  // added to the head, but may be removed from the middle.
+  typedef std::list<ExtensionPrefs*> ExtensionStack;
 
   // Applies the highest-priority extension's setting for the given preference
   // path to the |prefs_| store, or clears the setting there if no extensions
   // wish to control it.
   void UpdateOnePref(const char* path);
 
   // Updates each preference in the key set of the |pref_values| map.
   void UpdatePrefs(const PrefValueMap* pref_values);
 
   // Registers this as an observer for relevant notifications.
   void RegisterObservers();
 
   // Responds to observed notifications.
   void Observe(NotificationType type,
                const NotificationSource& source,
                const NotificationDetails& details);
 
   // A cache of the highest-priority values for each preference that any
   // extension is controlling, for quick read access. Owns the stored values.
   scoped_ptr<DictionaryValue> prefs_;
 
-  // Associates an extension with the prefs it sets. Owns the pref values.
-  struct ExtensionPrefs {
-    ExtensionPrefs(const Extension* extension, PrefValueMap* values);
-    ~ExtensionPrefs();
-
-    const Extension* extension;
-    PrefValueMap* pref_values;
-  };
-
-  // A pseudo-stack of extensions and their preferences. Extensions are always
-  // added to the head, but may be removed from the middle.
-  typedef std::list<ExtensionPrefs*> ExtensionStack;
   ExtensionStack extension_stack_;
 
   NotificationRegistrar notification_registrar_;
 
   // Weak reference to the profile whose extensions we're interested in. May be
   // NULL (for the local-state preferences), in which case we watch all
   // extensions.
   Profile* profile_;
 
   // My PrefStore type, assigned by the PrefValueStore.
   PrefNotifier::PrefStoreType type_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionPrefStore);
 };
 
 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_PREF_STORE_H_