app_shell: Extract extension runtime data from ExtensionService

extensions/browser/extension_registry.h

 // Copyright 2013 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_REGISTRY_H_
 #define EXTENSIONS_BROWSER_EXTENSION_REGISTRY_H_
 
 #include <string>
 
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
+#include "base/observer_list.h"
 #include "components/browser_context_keyed_service/browser_context_keyed_service.h"
 #include "extensions/common/extension_set.h"
 
 namespace content {
 class BrowserContext;
 }
 
 namespace extensions {
 class Extension;
+class ExtensionRegistryObserver;
 
 // ExtensionRegistry holds sets of the installed extensions for a given
 // BrowserContext. An incognito browser context and its master browser context
 // share a single registry.
 class ExtensionRegistry : public BrowserContextKeyedService {
  public:
   // Flags to pass to GetExtensionById() to select which sets to look in.
   enum IncludeFlag {
     NONE        = 0,
     ENABLED     = 1 << 0,
@@ skipping 17 matching lines @@
   const ExtensionSet& disabled_extensions() const {
     return disabled_extensions_;
   }
   const ExtensionSet& terminated_extensions() const {
     return terminated_extensions_;
   }
   const ExtensionSet& blacklisted_extensions() const {
     return blacklisted_extensions_;
   }
 
+  // The usual observer interface.
+  void AddObserver(ExtensionRegistryObserver* observer);
+  void RemoveObserver(ExtensionRegistryObserver* observer);
+
   // Find an extension by ID using |include_mask| to pick the sets to search:
   //  * enabled_extensions()     --> ExtensionRegistry::ENABLED
   //  * disabled_extensions()    --> ExtensionRegistry::DISABLED
   //  * terminated_extensions()  --> ExtensionRegistry::TERMINATED
   //  * blacklisted_extensions() --> ExtensionRegistry::BLACKLISTED
   // Returns NULL if the extension is not found in the selected sets.
   const Extension* GetExtensionById(const std::string& id,
                                     int include_mask) const;
 
+  // Removes an extension from the enabled and disabled sets. Invokes the
+  // observer method OnExtensionUnloaded() after the extension is removed.
+  void UnloadExtension(const scoped_refptr<const Extension>& extension);

[not at google - send to devlin, 2014/01/21 23:58:59]

I kind of preferred the way it was... making this class really dumb and not
assuming intent of the caller. So like, this method in particular, the fact that
it "removes from enabled and disabled sets" seems a bit magical (same below with
Enable/DisableExtension though to a lesser extent).

I had imagined something like AddObserver/RemoveObserver then some number of
Trigger methods... TriggerOnUnloaded, etc.

+
+  // Moves an extension to the enabled set from the disabled set. The extension
+  // must exist in the disabled set.
+  void EnableExtension(const scoped_refptr<const Extension>& extension);

[James Cook, 2014/01/21 23:20:39]

By adding this function and the one below I was able to get rid of
RemoveEnabled() and RemovedDisabled(). This gets us closer to having each
extension only appear in one set at a time.

+
+  // Adds an extension to the disabled set and removes it from the enabled
+  // and terminated sets. Invokes the observer method OnExtensionDisabled()
+  // after the extension is added.
+  void DisableExtension(const scoped_refptr<const Extension>& extension);
+
   // Adds the specified extension to the enabled set. The registry becomes an
   // owner. Any previous extension with the same ID is removed.
   // Returns true if there is no previous extension.
   // NOTE: You probably want to use ExtensionService instead of calling this
   // method directly.
   bool AddEnabled(const scoped_refptr<const Extension>& extension);
 
-  // Removes the specified extension from the enabled set.
-  // Returns true if the set contained the specified extension.
-  // NOTE: You probably want to use ExtensionService instead of calling this
-  // method directly.
-  bool RemoveEnabled(const std::string& id);
-
   // As above, but for the disabled set.
   bool AddDisabled(const scoped_refptr<const Extension>& extension);
-  bool RemoveDisabled(const std::string& id);
 
   // As above, but for the terminated set.
   bool AddTerminated(const scoped_refptr<const Extension>& extension);
   bool RemoveTerminated(const std::string& id);
 
   // As above, but for the blacklisted set.
   bool AddBlacklisted(const scoped_refptr<const Extension>& extension);
   bool RemoveBlacklisted(const std::string& id);
 
   // Removes all extensions from all sets.
@@ skipping 17 matching lines @@
 
   // Extensions that are installed and terminated.
   ExtensionSet terminated_extensions_;
 
   // Extensions that are installed and blacklisted. Generally these shouldn't be
   // considered as installed by the extension platform: we only keep them around
   // so that if extensions are blacklisted by mistake they can easily be
   // un-blacklisted.
   ExtensionSet blacklisted_extensions_;
 
+  ObserverList<ExtensionRegistryObserver> observers_;
+
   DISALLOW_COPY_AND_ASSIGN(ExtensionRegistry);
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_BROWSER_EXTENSION_REGISTRY_H_