OBSOLETE REVIEW. See http://codereview.chromium.org/10382149/

chrome/browser/extensions/extension_service.h

 // Copyright (c) 2012 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_SERVICE_H_
 #define CHROME_BROWSER_EXTENSIONS_EXTENSION_SERVICE_H_
 #pragma once
 
 #include <list>
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/property_bag.h"
+#include "base/string16.h"
 #include "base/time.h"
 #include "base/tuple.h"
 #include "chrome/browser/extensions/app_shortcut_manager.h"
 #include "chrome/browser/extensions/app_sync_bundle.h"
 #include "chrome/browser/extensions/apps_promo.h"
 #include "chrome/browser/extensions/extension_icon_manager.h"
+#include "chrome/browser/extensions/extension_management_policy.h"
 #include "chrome/browser/extensions/extension_menu_manager.h"
 #include "chrome/browser/extensions/extension_prefs.h"
 #include "chrome/browser/extensions/extension_process_manager.h"
 #include "chrome/browser/extensions/extension_sync_bundle.h"
 #include "chrome/browser/extensions/extension_toolbar_model.h"
 #include "chrome/browser/extensions/extension_warning_set.h"
 #include "chrome/browser/extensions/extensions_quota_service.h"
 #include "chrome/browser/extensions/external_extension_provider_interface.h"
 #include "chrome/browser/extensions/pending_extension_manager.h"
 #include "chrome/browser/extensions/process_map.h"
@@ skipping 51 matching lines @@
  public:
   // A function that returns true if the given extension should be
   // included and false if it should be filtered out.  Identical to
   // PendingExtensionInfo::ShouldAllowInstallPredicate.
   typedef bool (*ExtensionFilter)(const Extension&);
 
   virtual ~ExtensionServiceInterface() {}
   virtual const ExtensionSet* extensions() const = 0;
   virtual const ExtensionSet* disabled_extensions() const = 0;
   virtual PendingExtensionManager* pending_extension_manager() = 0;
+  virtual ExtensionManagementPolicy* extension_management_policy() = 0;
 
   // Install an update.  Return true if the install can be started.
   // Set out_crx_installer to the installer if one was started.
   virtual bool UpdateExtension(
       const std::string& id,
       const FilePath& path,
       const GURL& download_url,
       CrxInstaller** out_crx_installer) = 0;
   virtual const Extension* GetExtensionById(const std::string& id,
                                             bool include_disabled) const = 0;
@@ skipping 21 matching lines @@
       extension_misc::UnloadedExtensionReason reason) = 0;
 
   virtual void SyncExtensionChangeIfNeeded(const Extension& extension) = 0;
 
   virtual bool is_ready() = 0;
 };
 
 // Manages installed and running Chromium extensions.
 class ExtensionService
     : public ExtensionServiceInterface,
+      public ExtensionManagementPolicy::Delegate,
       public ExternalExtensionProviderInterface::VisitorInterface,
       public base::SupportsWeakPtr<ExtensionService>,
       public content::NotificationObserver {
  public:
   using base::SupportsWeakPtr<ExtensionService>::AsWeakPtr;
 
   // The name of the directory inside the profile where extensions are
   // installed to.
   static const char* kInstallDirectoryName;
 
@@ skipping 56 matching lines @@
   virtual const ExtensionSet* disabled_extensions() const OVERRIDE;
   const ExtensionSet* terminated_extensions() const;
 
   // Retuns a set of all installed, disabled, and terminated extensions and
   // transfers ownership to caller.
   const ExtensionSet* GenerateInstalledExtensionsSet() const;
 
   // Gets the object managing the set of pending extensions.
   virtual PendingExtensionManager* pending_extension_manager() OVERRIDE;
 
+  virtual ExtensionManagementPolicy* extension_management_policy() OVERRIDE;
+
   const FilePath& install_directory() const { return install_directory_; }
 
   AppsPromo* apps_promo() { return &apps_promo_; }
 
   extensions::ProcessMap* process_map() { return &process_map_; }
 
   // Whether this extension can run in an incognito window.
   virtual bool IsIncognitoEnabled(const std::string& extension_id) const;
   virtual void SetIsIncognitoEnabled(const std::string& extension_id,
                                      bool enabled);
@@ skipping 99 matching lines @@
   // callers should never set to true.
   //
   // We pass the |extension_id| by value to avoid having it deleted from under
   // us incase someone calls it with Extension::id() or another string that we
   // are going to delete in this function.
   //
   // TODO(aa): Remove |external_uninstall| -- this information should be passed
   // to ExtensionPrefs some other way.
   virtual bool UninstallExtension(std::string extension_id,
                                   bool external_uninstall,
-                                  std::string* error);
+                                  string16* error);
 
   virtual bool IsExtensionEnabled(
       const std::string& extension_id) const OVERRIDE;
   virtual bool IsExternalExtensionUninstalled(
       const std::string& extension_id) const OVERRIDE;
 
+  // ExtensionManagementPolicy::Delegate implementation.
+  // The ExtensionService is the keeper of the ExtensionManagementPolicy so
+  // other callers can query it. It's also an ExtensionManagementPolicy
+  // delegate itself, exposing any restrictions imposed by an individual
+  // extension.
+  virtual bool UserMayModifyStatus(const Extension* extension,
+                                   string16* error) const OVERRIDE;
+  virtual bool UserMayModifyUsage(const Extension* extension,
+                                  string16* error) const OVERRIDE;
+  virtual bool MustRemainEnabled(const Extension* extension,
+                                 string16* error) const OVERRIDE;
+
   // Enables the extension.  If the extension is already enabled, does
   // nothing.
   virtual void EnableExtension(const std::string& extension_id);
 
   // Disables the extension.  If the extension is already disabled, or
   // cannot be disabled, does nothing.
   virtual void DisableExtension(const std::string& extension_id,
                                 Extension::DisableReason disable_reason);
 
   // Updates the |extension|'s granted permissions lists to include all
@@ skipping 55 matching lines @@
   // Initializes the |extension|'s active permission set and disables the
   // extension if the privilege level has increased (e.g., due to an upgrade).
   void InitializePermissions(const Extension* extension);
 
   // Go through each extensions in pref, unload blacklisted extensions
   // and update the blacklist state in pref.
   virtual void UpdateExtensionBlacklist(
       const std::vector<std::string>& blacklist) OVERRIDE;
 
   // Go through each extension and unload those that the network admin has
-  // put on the blacklist (not to be confused with the Google managed blacklist
+  // put on the blacklist (not to be confused with the Google-managed blacklist)
   // set of extensions.
   virtual void CheckAdminBlacklist() OVERRIDE;
 
   virtual void CheckForUpdatesSoon() OVERRIDE;
 
   // SyncableService implementation.
   virtual SyncError MergeDataAndStartSyncing(
       syncable::ModelType type,
       const SyncDataList& initial_sync_data,
       scoped_ptr<SyncChangeProcessor> sync_processor,
@@ skipping 230 matching lines @@
       const extensions::ExtensionSyncData& extension_sync_data,
       syncable::ModelType type);
 
   // Look up an extension by ID, optionally including either or both of enabled
   // and disabled extensions.
   const Extension* GetExtensionByIdInternal(const std::string& id,
                                             bool include_enabled,
                                             bool include_disabled,
                                             bool include_terminated) const;
 
+  // Internal implementation for ExtensionManagementPolicy::Delegate methods.
+  // Returns |modifiable_value| if the extension can be modified.
+  bool ExtensionManagementPolicyImpl(const Extension* extension,
+                                     string16* error,
+                                     bool modifiable_value) const;
+
   // Adds the given extension to the list of terminated extensions if
   // it is not already there and unloads it.
   void TrackTerminatedExtension(const Extension* extension);
 
   // Removes the extension with the given id from the list of
   // terminated extensions if it is there.
   void UntrackTerminatedExtension(const std::string& id);
 
   // Handles sending notification that |extension| was loaded.
   void NotifyExtensionLoaded(const Extension* extension);
@@ skipping 37 matching lines @@
 
   // The list of installed extensions that have been disabled.
   ExtensionSet disabled_extensions_;
 
   // The list of installed extensions that have been terminated.
   ExtensionSet terminated_extensions_;
 
   // Hold the set of pending extensions.
   PendingExtensionManager pending_extension_manager_;
 
+  // ***
+  ExtensionManagementPolicy extension_management_policy_;
+
   // The map of extension IDs to their runtime data.
   ExtensionRuntimeDataMap extension_runtime_data_;
 
   // Holds a map between renderer process IDs that are associated with an
   // installed app and their app.
   typedef std::map<int, scoped_refptr<const Extension> > InstalledAppMap;
   InstalledAppMap installed_app_hosts_;
 
   // The full path to the directory where extensions are installed.
   FilePath install_directory_;
@@ skipping 111 matching lines @@
   scoped_ptr<ExtensionGlobalError> extension_global_error_;
 
   FRIEND_TEST_ALL_PREFIXES(ExtensionServiceTest,
                            InstallAppsWithUnlimtedStorage);
   FRIEND_TEST_ALL_PREFIXES(ExtensionServiceTest,
                            InstallAppsAndCheckStorageProtection);
   DISALLOW_COPY_AND_ASSIGN(ExtensionService);
 };
 
 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_SERVICE_H_