Fix for Bug 50726 "Save extension list and "winning" prefs from extensions"

chrome/browser/extensions/extension_prefs.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_PREFS_H_
 #define CHROME_BROWSER_EXTENSIONS_EXTENSION_PREFS_H_
 #pragma once
 
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/linked_ptr.h"
 #include "base/time.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/common/extensions/extension.h"
 #include "googleurl/src/gurl.h"
 
 // Class for managing global and per-extension preferences.
-// This class is instantiated by ExtensionsService, so it should be accessed
-// from there.
+//
+// This class distinguishes the following kinds of preferences:
+// - global preferences:
+//       internal state for the extension system in general, not associated
+//       with an individual extension, such as lastUpdateTime.
+// - per-extension preferences:
+//       meta-preferences describing properties of the extension like
+//       installation time, whether the extension is enabled, etc.
+// - extension controlled preferences:
+//       browser preferences that an extension controls. For example, an
+//       extension could use the proxy API to specify the browser's proxy
+//       preference. Extension-controlled preferences are stored in
+//       PrefValueStore::extension_prefs(), which this class populates and
+//       maintains as the underlying extensions change.
 class ExtensionPrefs {
  public:
   // Key name for a preference that keeps track of per-extension settings. This
   // is a dictionary object read from the Preferences file, keyed off of
   // extension ids.
   static const char kExtensionsPref[];
 
   typedef std::vector<linked_ptr<ExtensionInfo> > ExtensionsInfo;
 
+  // Vector containing identifiers for preferences.
+  typedef std::set<std::string> PrefKeySet;
+
+  // Vector containing identifiers for extensions.
+  typedef std::vector<std::string> ExtensionIdSet;
+
   // This enum is used for the launch type the user wants to use for an
   // application.
   // Do not remove items or re-order this enum as it is used in preferences
   // and histograms.
   enum LaunchType {
     LAUNCH_PINNED,
     LAUNCH_REGULAR,
     LAUNCH_FULLSCREEN,
     LAUNCH_WINDOW
   };
 
-  explicit ExtensionPrefs(PrefService* prefs, const FilePath& root_dir_);
+  explicit ExtensionPrefs(PrefService* prefs, const FilePath& root_dir);
   ~ExtensionPrefs();
 
   // Returns a copy of the Extensions prefs.
   // TODO(erikkay) Remove this so that external consumers don't need to be
   // aware of the internal structure of the preferences.
   DictionaryValue* CopyCurrentExtensions();
 
   // Populate |killed_ids| with extension ids that have been killed.
   void GetKilledExtensionIds(std::set<std::string>* killed_ids);
 
@@ skipping 14 matching lines @@
   void OnExtensionInstalled(const Extension* extension,
                             Extension::State initial_state,
                             bool initial_incognito_enabled);
 
   // Called when an extension is uninstalled, so that prefs get cleaned up.
   void OnExtensionUninstalled(const std::string& extension_id,
                               const Extension::Location& location,
                               bool external_uninstall);
 
   // Returns the state (enabled/disabled) of the given extension.
-  Extension::State GetExtensionState(const std::string& extension_id);
+  Extension::State GetExtensionState(const std::string& extension_id) const;
 
   // Called to change the extension's state when it is enabled/disabled.
   void SetExtensionState(const Extension* extension, Extension::State);
 
+  // Returns all installed and enabled extensions
+  void GetEnabledExtensions(ExtensionIdSet* out) const;
+
   // Getter and setter for browser action visibility.
   bool GetBrowserActionVisibility(const Extension* extension);
   void SetBrowserActionVisibility(const Extension* extension, bool visible);
 
   // Did the extension ask to escalate its permission during an upgrade?
   bool DidExtensionEscalatePermissions(const std::string& id);
 
   // If |did_escalate| is true, the preferences for |extension| will be set to
   // require the install warning when the user tries to enable.
   void SetDidExtensionEscalatePermissions(const Extension* extension,
@@ skipping 133 matching lines @@
   // highest current application launch index found.
   int GetNextAppLaunchIndex();
 
   // The extension's update URL data.  If not empty, the ExtensionUpdater
   // will append a ap= parameter to the URL when checking if a new version
   // of the extension is available.
   void SetUpdateUrlData(const std::string& extension_id,
                         const std::string& data);
   std::string GetUpdateUrlData(const std::string& extension_id);
 
+  // Sets a preference value that is controlled by the extension. In other
+  // words, this is not a pref value *about* the extension but something
+  // global the extension wants to override.
+  void SetExtensionControlledPref(const std::string& extension_id,
+                                  const std::string& pref_key,
+                                  Value* value);
+
   static void RegisterUserPrefs(PrefService* prefs);
 
   // The underlying PrefService.
   PrefService* pref_service() const { return prefs_; }
 
+ protected:
+  // For unit testing. Enables injecting an artificial clock that is used
+  // to query the current time, when an extension is installed.
+  virtual base::Time GetCurrentTime() const;
+
  private:
   // Converts absolute paths in the pref to paths relative to the
   // install_directory_.
   void MakePathsRelative();
 
   // Converts internal relative paths to be absolute. Used for export to
   // consumers who expect full paths.
   void MakePathsAbsolute(DictionaryValue* dict);
 
   // Sets the pref |key| for extension |id| to |value|.
@@ skipping 39 matching lines @@
   void AddToExtensionPrefStringSet(const std::string& extension_id,
                                    const std::string& pref_key,
                                    const std::set<std::string>& added_values);
 
   // Ensures and returns a mutable dictionary for extension |id|'s prefs.
   DictionaryValue* GetOrCreateExtensionPref(const std::string& id);
 
   // Same as above, but returns NULL if it doesn't exist.
   DictionaryValue* GetExtensionPref(const std::string& id) const;
 
+  // Returns the dictionary of preferences controlled by the specified extension
+  // or NULL if unknown. All entries in the dictionary contain non-expanded
+  // paths.
+  DictionaryValue* GetExtensionControlledPrefs(const std::string& id) const;
+
   // Serializes the data and schedules a persistent save via the |PrefService|.
   // Additionally fires a PREF_CHANGED notification with the top-level
   // |kExtensionsPref| path set.
   // TODO(andybons): Switch this to EXTENSION_PREF_CHANGED to be more granular.
   // TODO(andybons): Use a ScopedPrefUpdate to update observers on changes to
   // the mutable extension dictionary.
   void SavePrefsAndNotify();
 
   // Checks if kPrefBlacklist is set to true in the DictionaryValue.
   // Return false if the value is false or kPrefBlacklist does not exist.
   // This is used to decide if an extension is blacklisted.
   bool IsBlacklistBitSet(DictionaryValue* ext);
 
   // Helper methods for the public last ping day functions.
   base::Time LastPingDayImpl(const DictionaryValue* dictionary) const;
   void SetLastPingDayImpl(const base::Time& time, DictionaryValue* dictionary);
 
+  // Helper method to acquire the installation time of an extension.
+  base::Time GetInstallTime(const std::string& extension_id) const;
+
+  // Fix missing preference entries in the extensions that are were introduced
+  // in a later Chrome version.
+  void FixMissingPrefs(const ExtensionIdSet& extension_ids);
+
+  // Installs the persistent extension preferences into |prefs_|'s extension
+  // pref store.
+  void InitPrefStore();
+
+  // Returns the extension controlled preference value of the extension that was
+  // installed most recently.
+  const Value* GetWinningExtensionControlledPrefValue(
+      const std::string& key) const;
+
+  // Executes UpdatePrefStore for all |pref_keys|.
+  void UpdatePrefStore(const PrefKeySet& pref_keys);
+
+  // Finds the most recently installed extension that defines a preference
+  // for |pref_key|, then stores its value in the PrefValueStore's extension
+  // pref store and sends notifications to observers in case the value changed.
+  void UpdatePrefStore(const std::string& pref_key);
+
+  // Retrieves a list of preference keys that the specified extension
+  // intends to manage. Keys are always appended, |out| is not cleared.
+  void GetExtensionControlledPrefKeys(const std::string& extension_id,
+                                      PrefKeySet *out) const;
+
   // The pref service specific to this set of extension prefs.
   PrefService* prefs_;
 
   // Base extensions install directory.
   FilePath install_directory_;
 
   // The URLs of all of the toolstrips.
   URLList shelf_order_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionPrefs);
 };
 
 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_PREFS_H_