Enable/disable extensions upon changes in blacklist.

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_
 
 #include <list>
 #include <map>
 #include <set>
@@ skipping 44 matching lines @@
 class CrxInstaller;
 class ExtensionActionStorageManager;
 class ExtensionRegistry;
 class ExtensionSystem;
 class ExtensionUpdater;
 class PendingExtensionManager;
 class SettingsFrontend;
 class UpdateObserver;
 }  // namespace extensions
 
+using extensions::ExtensionIdSet;
+
 namespace syncer {
 class SyncErrorFactory;
 }
 
 // This is an interface class to encapsulate the dependencies that
 // various classes have on ExtensionService. This allows easy mocking.
 class ExtensionServiceInterface
     : public base::SupportsWeakPtr<ExtensionServiceInterface> {
  public:
   virtual ~ExtensionServiceInterface() {}
@@ skipping 519 matching lines @@
 #if defined(OS_CHROMEOS)
   void disable_garbage_collection() {
     disable_garbage_collection_ = true;
   }
   void enable_garbage_collection() {
     disable_garbage_collection_ = false;
   }
 #endif
 
  private:
+  // Populates greylist_.
+  void LoadGreylistFromPrefs();
+
   // Signals *ready_ and sends a notification to the listeners.
   void SetReadyAndNotifyListeners();
 
   // Return true if the sync type of |extension| matches |type|.
   void OnExtensionInstallPrefChanged();
 
   // Adds the given extension to the list of terminated extensions if
   // it is not already there and unloads it.
   void TrackTerminatedExtension(const extensions::Extension* extension);
 
@@ skipping 47 matching lines @@
   // Helper to search storage directories for extensions with isolated storage
   // that have been orphaned by an uninstall.
   void GarbageCollectIsolatedStorage();
   void OnGarbageCollectIsolatedStorageFinished();
 
   // extensions::Blacklist::Observer implementation.
   virtual void OnBlacklistUpdated() OVERRIDE;
 
   // Manages the blacklisted extensions, intended as callback from
   // Blacklist::GetBlacklistedIDs.
-  void ManageBlacklist(const std::set<std::string>& blacklisted_ids);
+  void ManageBlacklist(
+      const extensions::Blacklist::BlacklistStateMap& blacklisted_ids);
+
+  // Add extensions in |blocked| to blacklisted_extensions, remove extensions
+  // that are neither in |blocked|, nor in |unchanged|.
+  void UpdateBlockedExtensions(const ExtensionIdSet& blocked,
+                               const ExtensionIdSet& unchanged);
+
+  void UpdateGreylistedExtensions(
+      const ExtensionIdSet& greylist,
+      const ExtensionIdSet& unchanged,
+      const extensions::Blacklist::BlacklistStateMap& state_map);
 
   // Controls if installs are delayed. See comment for
   // |installs_delayed_for_gc_|.
   void set_installs_delayed_for_gc(bool value) {
     installs_delayed_for_gc_ = value;
   }
   bool installs_delayed_for_gc() const { return installs_delayed_for_gc_; }
 
   // Used only by test code.
   void UnloadAllExtensionsInternal();
@@ skipping 12 matching lines @@
 
   // Settings for the owning profile.
   scoped_ptr<extensions::SettingsFrontend> settings_frontend_;
 
   // The ExtensionSyncService that is used by this ExtensionService.
   ExtensionSyncService* extension_sync_service_;
 
   // Sets of enabled/disabled/terminated/blacklisted extensions. Not owned.
   extensions::ExtensionRegistry* registry_;
 
+  // Set of greylisted extensions. These extensions are disabled if they are
+  // already installed in Chromium at the time when they are added to
+  // the greylist. Unlike blacklisted extensions, greylisted ones are visible
+  // to the user and if user re-enables such an extension, they remain enabled.
+  //
+  // These extensions should appear in registry_.
+  extensions::ExtensionSet greylist_;
+
   // The list of extension installs delayed for various reasons.  The reason
   // for delayed install is stored in ExtensionPrefs. These are not part of
   // ExtensionRegistry because they are not yet installed.
   extensions::ExtensionSet delayed_installs_;
 
   // Hold the set of pending extensions.
   extensions::PendingExtensionManager pending_extension_manager_;
 
   // The full path to the directory where extensions are installed.
   base::FilePath install_directory_;
@@ skipping 102 matching lines @@
                            InstallAppsAndCheckStorageProtection);
   FRIEND_TEST_ALL_PREFIXES(ExtensionServiceTest, SetUnsetBlacklistInPrefs);
   FRIEND_TEST_ALL_PREFIXES(ExtensionServiceTest,
                            BlacklistedExtensionWillNotInstall);
   FRIEND_TEST_ALL_PREFIXES(ExtensionServiceTest,
                            UnloadBlacklistedExtensionPolicy);
   FRIEND_TEST_ALL_PREFIXES(ExtensionServiceTest,
                            WillNotLoadBlacklistedExtensionsFromDirectory);
   FRIEND_TEST_ALL_PREFIXES(ExtensionServiceTest,
                            BlacklistedInPrefsFromStartup);
+  FRIEND_TEST_ALL_PREFIXES(ExtensionServiceTest,
+                           GreylistedExtensionDisabled);
+  FRIEND_TEST_ALL_PREFIXES(ExtensionServiceTest,
+                           GreylistDontEnableManuallyDisabled);
+  FRIEND_TEST_ALL_PREFIXES(ExtensionServiceTest,
+                           GreylistUnknownDontChange);
   DISALLOW_COPY_AND_ASSIGN(ExtensionService);
 };
 
 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_SERVICE_H_