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 should be accessed via ExtensionsService.

[Aaron Boodman, 2010/12/03 08:58:10]

This last sentence no longer seems useful. It can be removed.

[battre (please use the other), 2010/12/03 19:32:58]

Done.

+//
+// 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:
+//       global preferences that an individual extension wants to set;
+//       these are arbitrary preferences that are controlled by other
+//       sub-systems.

[Aaron Boodman, 2010/12/03 08:58:10]

A quick example might clarify things here.

Also, in this overview, you should introduce the collaboration with
PrefValueStore.

[battre (please use the other), 2010/12/03 19:32:58]

Done.

 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::vector<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(Profile* profile,
+                          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

[Aaron Boodman, 2010/12/03 08:58:10]

It seems like what this thing really does is intialize the ExtensionPrefStore,
so how about calling it that? "InitPrefStore"? The name requires familiarity
with the idea of a 'pref store', but once you have that and the understanding of
how this class relates to pref stores, that name should make it clear what is
going on.

[battre (please use the other), 2010/12/03 19:32:58]

Done.

+  // pref store.
+  void InstallPersistedExtensionControlledPrefs();
+
+  // Returns the extension controlled preference value of the extension that was
+  // installed most recently.
+  const Value* WinningExtensionControlledPrefValue(

[Aaron Boodman, 2010/12/03 08:58:10]

Method names should be verbs, so "GetWinning...", or how about
"GetMostRecent..." so the reader doesn't have to guess at what defines
'winning'.

[battre (please use the other), 2010/12/03 19:32:58]

I have changed it to GetWinning. GetMostRecent does not quite nail it. It is
about the recency of extensions, not about the recency when an extension
controlled pref value has been set.

Done.

+      const std::string& key) const;
+
+  // Executes UpdateWinningPref for all |pref_keys|.
+  void UpdateWinningPrefs(const PrefKeySet& pref_keys);

[Aaron Boodman, 2010/12/03 08:58:10]

UpdatePrefStore?

[battre (please use the other), 2010/12/03 19:32:58]

Done.

+
+  // Finds the most recently installed extension that defines a preference
+  // for |pref_key|, then store its value in the PrefValueStore's extension pref
+  // store and send notifications to observers in case the value changed.
+  void UpdateWinningPref(const std::string& pref_key);

[Aaron Boodman, 2010/12/03 08:58:10]

Also UpdatePrefStore? (method overload)

[battre (please use the other), 2010/12/03 19:32:58]

Done.

+
+  // Retrieves a list of preference keys that the specified extension
+  // intents to manage. Keys are always appended, |out| is not cleared.

[Aaron Boodman, 2010/12/03 08:58:10]

s/intents/intends

[battre (please use the other), 2010/12/03 19:32:58]

Done.

+  void GetExtensionControlledPrefKeys(const std::string& extension_id,
+                                      PrefKeySet *out) const;
+
+  Profile* profile_;
+
   // 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_