Cleanup: Make ExtensionService::OnExtensionInstalled take a bitmask instead of

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>
 
 #include "base/basictypes.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/observer_list.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "components/keyed_service/core/keyed_service.h"
 #include "extensions/browser/app_sorting.h"
 #include "extensions/browser/blacklist_state.h"
 #include "extensions/browser/extension_scoped_prefs.h"
+#include "extensions/browser/install_flag.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/url_pattern_set.h"
 #include "sync/api/string_ordinal.h"
 
 class ExtensionPrefValueMap;
 class PrefService;
 
 namespace content {
 class BrowserContext;
@@ skipping 144 matching lines @@
   void SetToolbarOrder(const ExtensionIdList& extension_ids);
 
   // Gets the set of known disabled extension IDs into |id_set_out|. Returns
   // false iff the set of known disabled extension IDs hasn't been set yet.
   bool GetKnownDisabled(ExtensionIdSet* id_set_out);
 
   // Sets the set of known disabled extension IDs.
   void SetKnownDisabled(const ExtensionIdSet& extension_ids);
 
   // Called when an extension is installed, so that prefs get created.
-  // |blacklisted_for_malware| should be set if the extension was included in a
-  // blacklist due to being malware. If |page_ordinal| is an invalid ordinal,
-  // then a page will be found for the App.
+  // 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,
-                            bool blacklisted_for_malware,
-                            bool is_ephemeral,
                             const syncer::StringOrdinal& page_ordinal,
+                            int install_flags,
                             const std::string& install_parameter);
+  // OnExtensionInstalled with no install flags.
+  void OnExtensionInstalled(const Extension* extension,
+                            Extension::State initial_state,
+                            const syncer::StringOrdinal& page_ordinal,
+                            const std::string& install_parameter) {
+    OnExtensionInstalled(extension,
+                         initial_state,
+                         page_ordinal,
+                         kInstallFlagNone,
+                         install_parameter);
+  }
 
   // Called when an extension is uninstalled, so that prefs get cleaned up.
   void OnExtensionUninstalled(const std::string& extension_id,
                               const Manifest::Location& location,
                               bool external_uninstall);
 
   // Called to change the extension's state when it is enabled/disabled.
   void SetExtensionState(const std::string& extension_id, Extension::State);
 
   // Called to change the extension's BlacklistState. Currently only used for
@@ skipping 231 matching lines @@
   // explicitly uninstalled.
   scoped_ptr<ExtensionsInfo> GetUninstalledExtensionsInfo() const;
 
   // Returns the ExtensionInfo from the prefs for the given extension. If the
   // extension is not present, NULL is returned.
   scoped_ptr<ExtensionInfo> GetInstalledExtensionInfo(
       const std::string& extension_id) const;
 
   // We've downloaded an updated .crx file for the extension, but are waiting
   // to install it.
+  //
+  // |install_flags| are a bitmask of extension::InstallFlags.
   void SetDelayedInstallInfo(const Extension* extension,
                              Extension::State initial_state,
-                             bool blacklisted_for_malware,
-                             bool is_ephemeral,
+                             int install_flags,
                              DelayReason delay_reason,
                              const syncer::StringOrdinal& page_ordinal,
                              const std::string& install_parameter);
 
   // Removes any delayed install information we have for the given
   // |extension_id|. Returns true if there was info to remove; false otherwise.
   bool RemoveDelayedInstallInfo(const std::string& extension_id);
 
   // Update the prefs to finish the update for an extension.
   bool FinishDelayedInstallInfo(const std::string& extension_id);
@@ skipping 208 matching lines @@
 
   // 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
   // installations.
+  //
+  // |install_flags| are a bitmask of extension::InstallFlags.
   void PopulateExtensionInfoPrefs(const Extension* extension,
                                   const base::Time install_time,
                                   Extension::State initial_state,
-                                  bool blacklisted_for_malware,
-                                  bool is_ephemeral,
+                                  int install_flags,
                                   const std::string& install_parameter,
                                   base::DictionaryValue* extension_dict);
 
   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,
@@ skipping 21 matching lines @@
   bool extensions_disabled_;
 
   ObserverList<ExtensionPrefsObserver> observer_list_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionPrefs);
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_BROWSER_EXTENSION_PREFS_H_