Add OnLoaded to ExtensionRegistryObserver. Change GalleryWatchStateTracker

to use it rather than notifications to prove it works.

BUG=354367
R=jamescook@chromium.org, thestig@chromium.org

Review URL: https://codereview.chromium.org/206413002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@259708 0039d316-1c4b-4281-b951-d872f2087c98

4 files changed, 81 insertions, 0 deletions

diff --git a/extensions/browser/extension_registry.cc b/extensions/browser/extension_registry.cc
index 1d64ced..1f52ee1 100644
--- a/extensions/browser/extension_registry.cc
+++ b/extensions/browser/extension_registry.cc
@@ -36,6 +36,12 @@ void ExtensionRegistry::RemoveObserver(ExtensionRegistryObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
+void ExtensionRegistry::TriggerOnLoaded(const Extension* extension) {
+  DCHECK(enabled_extensions_.Contains(extension->id()));
+  FOR_EACH_OBSERVER(
+      ExtensionRegistryObserver, observers_, OnExtensionLoaded(extension));
+}
+
 void ExtensionRegistry::TriggerOnUnloaded(const Extension* extension) {
   DCHECK(!enabled_extensions_.Contains(extension->id()));
   FOR_EACH_OBSERVER(
diff --git a/extensions/browser/extension_registry.h b/extensions/browser/extension_registry.h
index 9f2fae3..3030c07 100644
--- a/extensions/browser/extension_registry.h
+++ b/extensions/browser/extension_registry.h
@@ -65,6 +65,10 @@ class ExtensionRegistry : public KeyedService {
   void AddObserver(ExtensionRegistryObserver* observer);
   void RemoveObserver(ExtensionRegistryObserver* observer);
 
+  // Invokes the observer method OnExtensionLoaded(). The extension must be
+  // enabled at the time of the call.
+  void TriggerOnLoaded(const Extension* extension);
+
   // Invokes the observer method OnExtensionUnloaded(). The extension must not
   // be enabled at the time of the call.
   void TriggerOnUnloaded(const Extension* extension);
diff --git a/extensions/browser/extension_registry_observer.h b/extensions/browser/extension_registry_observer.h
index 3382885..ae1281c 100644
--- a/extensions/browser/extension_registry_observer.h
+++ b/extensions/browser/extension_registry_observer.h
@@ -15,6 +15,10 @@ class ExtensionRegistryObserver {
  public:
   virtual ~ExtensionRegistryObserver() {}
 
+  // Called after an extension is loaded. The extension will exclusively exist
+  // in the enabled_extensions set of ExtensionRegistry.
+  virtual void OnExtensionLoaded(const Extension* extension) {}
+
   // Called after an extension is unloaded. The extension no longer exists in
   // any of the ExtensionRegistry sets (enabled, disabled, etc.).
   virtual void OnExtensionUnloaded(const Extension* extension) {}
diff --git a/extensions/browser/extension_registry_unittest.cc b/extensions/browser/extension_registry_unittest.cc
index 075019b..7eaec65 100644
--- a/extensions/browser/extension_registry_unittest.cc
+++ b/extensions/browser/extension_registry_unittest.cc
@@ -7,6 +7,7 @@
 #include <string>
 
 #include "base/memory/ref_counted.h"
+#include "extensions/browser/extension_registry_observer.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -16,6 +17,44 @@ namespace {
 
 typedef testing::Test ExtensionRegistryTest;
 
+testing::AssertionResult HasSingleExtension(
+    const ExtensionList& list,
+    const scoped_refptr<const Extension>& extension) {
+  if (list.empty())
+    return testing::AssertionFailure() << "No extensions in list";
+  if (list.size() > 1)
+    return testing::AssertionFailure() << list.size()
+                                       << " extensions, expected 1";
+  const Extension* did_load = list[0].get();
+  if (did_load != extension)
+    return testing::AssertionFailure() << "Expected " << extension->id()
+                                       << " found " << did_load->id();
+  return testing::AssertionSuccess();
+}
+
+class TestObserver : public ExtensionRegistryObserver {
+ public:
+  void Reset() {
+    loaded_.clear();
+    unloaded_.clear();
+  }
+
+  const ExtensionList& loaded() { return loaded_; }
+  const ExtensionList& unloaded() { return unloaded_; }
+
+ private:
+  virtual void OnExtensionLoaded(const Extension* extension) OVERRIDE {
+    loaded_.push_back(extension);
+  }
+
+  virtual void OnExtensionUnloaded(const Extension* extension) OVERRIDE {
+    unloaded_.push_back(extension);
+  }
+
+  ExtensionList loaded_;
+  ExtensionList unloaded_;
+};
+
 TEST_F(ExtensionRegistryTest, FillAndClearRegistry) {
   ExtensionRegistry registry;
   scoped_refptr<Extension> extension1 = test_util::CreateExtensionWithID("id1");
@@ -165,5 +204,33 @@ TEST_F(ExtensionRegistryTest, GetExtensionById) {
       "enabled", ExtensionRegistry::DISABLED | ExtensionRegistry::BLACKLISTED));
 }
 
+TEST_F(ExtensionRegistryTest, Observer) {
+  ExtensionRegistry registry;
+  TestObserver observer;
+  registry.AddObserver(&observer);
+
+  EXPECT_TRUE(observer.loaded().empty());
+  EXPECT_TRUE(observer.unloaded().empty());
+
+  scoped_refptr<const Extension> extension =
+      test_util::CreateExtensionWithID("id");
+
+  registry.AddEnabled(extension);
+  registry.TriggerOnLoaded(extension);
+
+  EXPECT_TRUE(HasSingleExtension(observer.loaded(), extension.get()));
+  EXPECT_TRUE(observer.unloaded().empty());
+  observer.Reset();
+
+  registry.RemoveEnabled(extension->id());
+  registry.TriggerOnUnloaded(extension);
+
+  EXPECT_TRUE(observer.loaded().empty());
+  EXPECT_TRUE(HasSingleExtension(observer.unloaded(), extension.get()));
+  observer.Reset();
+
+  registry.RemoveObserver(&observer);
+}
+
 }  // namespace
 }  // namespace extensions