Extensions: Store disable reasons in Sync

extensions/browser/extension_prefs.h

 // Copyright 2014 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 EXTENSIONS_BROWSER_EXTENSION_PREFS_H_
 #define EXTENSIONS_BROWSER_EXTENSION_PREFS_H_
 
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 155 matching lines @@
   // Returns true if the specified external extension was uninstalled by the
   // user.
   bool IsExternalExtensionUninstalled(const std::string& id) const;
 
   // Checks whether |extension_id| is disabled. If there's no state pref for
   // the extension, this will return false. Generally you should use
   // ExtensionService::IsExtensionEnabled instead.
   bool IsExtensionDisabled(const std::string& id) const;
 
   // Get/Set the order that the browser actions appear in the toolbar.
-  ExtensionIdList GetToolbarOrder();
+  ExtensionIdList GetToolbarOrder() const;
   void SetToolbarOrder(const ExtensionIdList& extension_ids);
 
   // Called when an extension is installed, so that prefs get created.
   // If |page_ordinal| is invalid then a page will be found for the App.
   // |install_flags| are a bitmask of extension::InstallFlags.
   void OnExtensionInstalled(const Extension* extension,
                             Extension::State initial_state,
                             const syncer::StringOrdinal& page_ordinal,
                             int install_flags,
                             const std::string& install_parameter);
@@ skipping 18 matching lines @@
   void SetExtensionState(const std::string& extension_id, Extension::State);
 
   // Called to change the extension's BlacklistState. Currently only used for
   // non-malicious extensions.
   // TODO(oleg): replace SetExtensionBlacklisted by this function.
   void SetExtensionBlacklistState(const std::string& extension_id,
                                   BlacklistState state);
 
   // Checks whether |extension_id| is marked as greylisted.
   // TODO(oleg): Replace IsExtensionBlacklisted by this method.
-  BlacklistState GetExtensionBlacklistState(const std::string& extension_id);
+  BlacklistState GetExtensionBlacklistState(
+      const std::string& extension_id) const;
 
   // Populates |out| with the ids of all installed extensions.
-  void GetExtensions(ExtensionIdList* out);
+  void GetExtensions(ExtensionIdList* out) const;
 
   // ExtensionScopedPrefs methods:
   void UpdateExtensionPref(const std::string& id,
                            const std::string& key,
                            base::Value* value) override;
 
   void DeleteExtensionPrefs(const std::string& id) override;
 
   bool ReadPrefAsBoolean(const std::string& extension_id,
                          const std::string& pref_key,
@@ skipping 12 matching lines @@
                       const base::ListValue** out_value) const override;
 
   bool ReadPrefAsDictionary(
       const std::string& extension_id,
       const std::string& pref_key,
       const base::DictionaryValue** out_value) const override;
 
   bool HasPrefForExtension(const std::string& extension_id) const override;
 
   // Did the extension ask to escalate its permission during an upgrade?
-  bool DidExtensionEscalatePermissions(const std::string& id);
+  bool DidExtensionEscalatePermissions(const std::string& id) const;
 
   // 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,
       bool did_escalate);
 
   // Getters and setters for disabled reason.
   int GetDisableReasons(const std::string& extension_id) const;
   bool HasDisableReason(const std::string& extension_id,
                         Extension::DisableReason disable_reason) const;
   void AddDisableReason(const std::string& extension_id,
                         Extension::DisableReason disable_reason);
   void RemoveDisableReason(const std::string& extension_id,
                            Extension::DisableReason disable_reason);
   void ClearDisableReasons(const std::string& extension_id);
 
   // Gets the set of extensions that have been blacklisted in prefs. This will
   // return only the blocked extensions, not the "greylist" extensions.
   // TODO(oleg): Make method names consistent here, in extension service and in
   // blacklist.
-  std::set<std::string> GetBlacklistedExtensions();
+  std::set<std::string> GetBlacklistedExtensions() const;
 
   // Sets whether the extension with |id| is blacklisted.
   void SetExtensionBlacklisted(const std::string& extension_id,
                                bool is_blacklisted);
 
   // Returns the version string for the currently installed extension, or
   // the empty string if not found.
-  std::string GetVersionString(const std::string& extension_id);
+  std::string GetVersionString(const std::string& extension_id) const;
 
   // Re-writes the extension manifest into the prefs.
   // Called to change the extension's manifest when it's re-localized.
   void UpdateManifest(const Extension* extension);
 
   // Returns base extensions install directory.
   const base::FilePath& install_directory() const { return install_directory_; }
 
   // Returns whether the extension with |id| has its blacklist bit set.
   //
   // WARNING: this only checks the extension's entry in prefs, so by definition
   // can only check extensions that prefs knows about. There may be other
   // sources of blacklist information, such as safebrowsing. You probably want
   // to use Blacklist::GetBlacklistedIDs rather than this method.
   bool IsExtensionBlacklisted(const std::string& id) const;
 
   // Increment the count of how many times we prompted the user to acknowledge
   // the given extension, and return the new count.
   int IncrementAcknowledgePromptCount(const std::string& extension_id);
 
   // Whether the user has acknowledged an external extension.
-  bool IsExternalExtensionAcknowledged(const std::string& extension_id);
+  bool IsExternalExtensionAcknowledged(const std::string& extension_id) const;
   void AcknowledgeExternalExtension(const std::string& extension_id);
 
   // Whether the user has acknowledged a blacklisted extension.
-  bool IsBlacklistedExtensionAcknowledged(const std::string& extension_id);
+  bool IsBlacklistedExtensionAcknowledged(
+      const std::string& extension_id) const;
   void AcknowledgeBlacklistedExtension(const std::string& extension_id);
 
   // Whether the external extension was installed during the first run
   // of this profile.
-  bool IsExternalInstallFirstRun(const std::string& extension_id);
+  bool IsExternalInstallFirstRun(const std::string& extension_id) const;
   void SetExternalInstallFirstRun(const std::string& extension_id);
 
   // Returns true if the extension notification code has already run for the
   // first time for this profile. Currently we use this flag to mean that any
   // extensions that would trigger notifications should get silently
   // acknowledged. This is a fuse. Calling it the first time returns false.
   // Subsequent calls return true. It's not possible through an API to ever
   // reset it. Don't call it unless you mean it!
   bool SetAlertSystemFirstRun();
 
   // Returns the last value set via SetLastPingDay. If there isn't such a
   // pref, the returned Time will return true for is_null().
   base::Time LastPingDay(const std::string& extension_id) const;
 
   // The time stored is based on the server's perspective of day start time, not
   // the client's.
   void SetLastPingDay(const std::string& extension_id, const base::Time& time);
 
   // Similar to the 2 above, but for the extensions blacklist.
   base::Time BlacklistLastPingDay() const;
   void SetBlacklistLastPingDay(const base::Time& time);
 
   // Similar to LastPingDay/SetLastPingDay, but for sending "days since active"
   // ping.
-  base::Time LastActivePingDay(const std::string& extension_id);
+  base::Time LastActivePingDay(const std::string& extension_id) const;
   void SetLastActivePingDay(const std::string& extension_id,
                             const base::Time& time);
 
   // A bit we use for determining if we should send the "days since active"
   // ping. A value of true means the item has been active (launched) since the
   // last update check.
-  bool GetActiveBit(const std::string& extension_id);
+  bool GetActiveBit(const std::string& extension_id) const;
   void SetActiveBit(const std::string& extension_id, bool active);
 
   // Returns the granted permission set for the extension with |extension_id|,
   // and NULL if no preferences were found for |extension_id|.
   // This passes ownership of the returned set to the caller.
-  PermissionSet* GetGrantedPermissions(const std::string& extension_id);
+  PermissionSet* GetGrantedPermissions(const std::string& extension_id) const;
 
   // Adds |permissions| to the granted permissions set for the extension with
   // |extension_id|. The new granted permissions set will be the union of
   // |permissions| and the already granted permissions.
   void AddGrantedPermissions(const std::string& extension_id,
                              const PermissionSet* permissions);
 
   // As above, but subtracts the given |permissions| from the granted set.
   void RemoveGrantedPermissions(const std::string& extension_id,
                                 const PermissionSet* permissions);
 
   // Gets the active permission set for the specified extension. This may
   // differ from the permissions in the manifest due to the optional
   // permissions API. This passes ownership of the set to the caller.
-  PermissionSet* GetActivePermissions(const std::string& extension_id);
+  PermissionSet* GetActivePermissions(const std::string& extension_id) const;
 
   // Sets the active |permissions| for the extension with |extension_id|.
   void SetActivePermissions(const std::string& extension_id,
                             const PermissionSet* permissions);
 
   // Records whether or not this extension is currently running.
   void SetExtensionRunning(const std::string& extension_id, bool is_running);
 
   // Returns whether or not this extension is marked as running. This is used to
   // restart apps across browser restarts.
-  bool IsExtensionRunning(const std::string& extension_id);
+  bool IsExtensionRunning(const std::string& extension_id) const;
 
   // Set/Get whether or not the app is active. Used to force a launch of apps
   // that don't handle onRestarted() on a restart. We can only safely do that if
   // the app was active when it was last running.
   void SetIsActive(const std::string& extension_id, bool is_active);
-  bool IsActive(const std::string& extension_id);
+  bool IsActive(const std::string& extension_id) const;
 
   // Returns true if the user enabled this extension to be loaded in incognito
   // mode.
   //
   // IMPORTANT: you probably want to use extensions::util::IsIncognitoEnabled
   // instead of this method.
   bool IsIncognitoEnabled(const std::string& extension_id) const;
   void SetIsIncognitoEnabled(const std::string& extension_id, bool enabled);
 
   // Returns true if the user has chosen to allow this extension to inject
@@ skipping 50 matching lines @@
   scoped_ptr<ExtensionsInfo> GetAllDelayedInstallInfo() const;
 
   // Returns true if the extension is an ephemeral app.
   bool IsEphemeralApp(const std::string& extension_id) const;
 
   // Promotes an ephemeral app to a regular installed app.
   void OnEphemeralAppPromoted(const std::string& extension_id);
 
   // Returns true if the user repositioned the app on the app launcher via drag
   // and drop.
-  bool WasAppDraggedByUser(const std::string& extension_id);
+  bool WasAppDraggedByUser(const std::string& extension_id) const;
 
   // Sets a flag indicating that the user repositioned the app on the app
   // launcher by drag and dropping it.
   void SetAppDraggedByUser(const std::string& extension_id);
 
   // Returns true if there is an extension which controls the preference value
   //  for |pref_key| *and* it is specific to incognito mode.
-  bool HasIncognitoPrefValue(const std::string& pref_key);
+  bool HasIncognitoPrefValue(const std::string& pref_key) const;
 
   // Returns the creation flags mask for the extension.
   int GetCreationFlags(const std::string& extension_id) const;
 
   // Returns the creation flags mask for a delayed install extension.
   int GetDelayedInstallCreationFlags(const std::string& extension_id) const;
 
   // Returns true if the extension was installed from the Chrome Web Store.
   bool IsFromWebStore(const std::string& extension_id) const;
 
@@ skipping 31 matching lines @@
   // The underlying PrefService.
   PrefService* pref_service() const { return prefs_; }
 
   // The underlying AppSorting.
   AppSorting* app_sorting() const { return app_sorting_.get(); }
 
   // Schedules garbage collection of an extension's on-disk data on the next
   // start of this ExtensionService. Applies only to extensions with isolated
   // storage.
   void SetNeedsStorageGarbageCollection(bool value);
-  bool NeedsStorageGarbageCollection();
+  bool NeedsStorageGarbageCollection() const;
 
   // Used by AppWindowGeometryCache to persist its cache. These methods
   // should not be called directly.
   const base::DictionaryValue* GetGeometryCache(
         const std::string& extension_id) const;
   void SetGeometryCache(const std::string& extension_id,
                         scoped_ptr<base::DictionaryValue> cache);
 
   // Used for verification of installed extension ids. For the Set method, pass
   // null to remove the preference.
-  const base::DictionaryValue* GetInstallSignature();
+  const base::DictionaryValue* GetInstallSignature() const;
   void SetInstallSignature(const base::DictionaryValue* signature);
 
   // The installation parameter associated with the extension.
   std::string GetInstallParam(const std::string& extension_id) const;
   void SetInstallParam(const std::string& extension_id,
                        const std::string& install_parameter);
 
   // The total number of times we've disabled an extension due to corrupted
   // contents.
-  int GetCorruptedDisableCount();
+  int GetCorruptedDisableCount() const;
   void IncrementCorruptedDisableCount();
 
  private:
   friend class ExtensionPrefsBlacklistedExtensions;  // Unit test.
   friend class ExtensionPrefsComponentExtension;     // Unit test.
   friend class ExtensionPrefsUninstallExtension;     // Unit test.
 
   enum DisableReasonChange {
     DISABLE_REASON_ADD,
     DISABLE_REASON_REMOVE,
@@ skipping 22 matching lines @@
   // |extension| dictionary.
   scoped_ptr<ExtensionInfo> GetInstalledInfoHelper(
       const std::string& extension_id,
       const base::DictionaryValue* extension) const;
 
   // Interprets the list pref, |pref_key| in |extension_id|'s preferences, as a
   // URLPatternSet. The |valid_schemes| specify how to parse the URLPatterns.
   bool ReadPrefAsURLPatternSet(const std::string& extension_id,
                                const std::string& pref_key,
                                URLPatternSet* result,
-                               int valid_schemes);
+                               int valid_schemes) const;
 
   // Converts |new_value| to a list of strings and sets the |pref_key| pref
   // belonging to |extension_id|.
   void SetExtensionPrefURLPatternSet(const std::string& extension_id,
                                      const std::string& pref_key,
                                      const URLPatternSet& new_value);
 
   // Read the boolean preference entry and return true if the preference exists
   // and the preference's value is true; false otherwise.
   bool ReadPrefAsBooleanAndReturn(const std::string& extension_id,
                                   const std::string& key) const;
 
   // Interprets |pref_key| in |extension_id|'s preferences as an
   // PermissionSet, and passes ownership of the set to the caller.
   PermissionSet* ReadPrefAsPermissionSet(const std::string& extension_id,
-                                         const std::string& pref_key);
+                                         const std::string& pref_key) const;
 
   // Converts the |new_value| to its value and sets the |pref_key| pref
   // belonging to |extension_id|.
   void SetExtensionPrefPermissionSet(const std::string& extension_id,
                                      const std::string& pref_key,
                                      const PermissionSet* new_value);
 
   // Returns an immutable dictionary for extension |id|'s prefs, or NULL if it
   // doesn't exist.
   const base::DictionaryValue* GetExtensionPref(const std::string& id) const;
@@ skipping 24 matching lines @@
   // it matches |check_state|.
   bool DoesExtensionHaveState(const std::string& id,
                               Extension::State check_state) const;
 
   // Reads the list of strings for |pref| from user prefs into
   // |id_container_out|. Returns false if the pref wasn't found in the user
   // pref store.
   template <class ExtensionIdContainer>
   bool GetUserExtensionPrefIntoContainer(
       const char* pref,
-      ExtensionIdContainer* id_container_out);
+      ExtensionIdContainer* id_container_out) const;
 
   // Writes the list of strings contained in |strings| to |pref| in prefs.
   template <class ExtensionIdContainer>
   void SetExtensionPrefFromContainer(const char* pref,
                                      const ExtensionIdContainer& strings);
 
   // Helper function to populate |extension_dict| with the values needed
   // by a newly installed extension. Work is broken up between this
-  // function and FinishExtensionInfoPrefs() to accomodate delayed
+  // function and FinishExtensionInfoPrefs() to accommodate delayed
   // installations.
   //
   // |install_flags| are a bitmask of extension::InstallFlags.
   void PopulateExtensionInfoPrefs(const Extension* extension,
                                   const base::Time install_time,
                                   Extension::State initial_state,
                                   int install_flags,
                                   const std::string& install_parameter,
-                                  base::DictionaryValue* extension_dict);
+                                  base::DictionaryValue* extension_dict) const;
 
   void InitExtensionControlledPrefs(ExtensionPrefValueMap* value_map);
 
   // Helper function to complete initialization of the values in
   // |extension_dict| for an extension install. Also see
   // PopulateExtensionInfoPrefs().
   void FinishExtensionInfoPrefs(
       const std::string& extension_id,
       const base::Time install_time,
       bool needs_sort_ordinal,
@@ skipping 19 matching lines @@
   bool extensions_disabled_;
 
   ObserverList<ExtensionPrefsObserver> observer_list_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionPrefs);
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_BROWSER_EXTENSION_PREFS_H_