Add a test helper class for ExtensionRegistry.

extensions/browser/test_extension_registry_observer.cc

+// 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.
+
+#include "extensions/browser/test_extension_registry_observer.h"
+
+#include "base/run_loop.h"
+#include "extensions/browser/extension_registry.h"
+
+namespace extensions {
+
+class TestExtensionRegistryObserver::Waiter {
+ public:
+  Waiter() : observed_(false), runner_(NULL), extension_id_(std::string()) {}
+
+  void Wait(const std::string& id) {
+    if (observed_ && extension_id_ == id)
+      return;
+
+    extension_id_ = id;
+    runner_ = new content::MessageLoopRunner();
+    runner_->Run();
+  }
+
+  void OnObserved(const std::string& id) {
+    observed_ = true;
+    extension_id_ = id;
+
+    if (runner_) {
+      runner_->Quit();
+      runner_ = NULL;
+    }
+  }
+
+ private:
+  bool observed_;
+  scoped_refptr<content::MessageLoopRunner> runner_;
+
+  std::string extension_id_;
+
+  DISALLOW_COPY_AND_ASSIGN(Waiter);
+};
+
+TestExtensionRegistryObserver::TestExtensionRegistryObserver(
+    ExtensionRegistry* registry)
+    : will_be_installed_waiter_(new Waiter()),

[Yoyo Zhou, 2014/06/17 18:15:37]

Do we need to instantiate all these if they're not being used?
We can do e.g. in WaitForExtensionUninstalled,
uninstalled_waiter_.reset(new Waiter);
uninstalled_waiter_->Wait...

As it is, we can't wait for multiple events in parallel anyway (at least with
this design).

[Yoyo Zhou, 2014/06/17 21:48:06]

Ah, I see what you mean.

Right now there is a flaw that if 2 extensions get installed, for example, we
only keep the 2nd extension's ID (even if we wanted to wait for the first one).

Since this is for the purpose of observing a single extension, can we pass the
ID in the constructor for TestExtensionRegistryObserver and Waiter?

[limasdf, 2014/06/19 18:06:28]

Done.

+      uninstalled_waiter_(new Waiter()),
+      loaded_waiter_(new Waiter()),
+      unloaded_waiter_(new Waiter()),
+      extension_registry_observer_(this) {
+  extension_registry_observer_.Add(registry);
+}
+
+TestExtensionRegistryObserver::~TestExtensionRegistryObserver() {
+}
+
+void TestExtensionRegistryObserver::WaitForExtensionUninstalled(
+    const std::string& extension_id) {
+  uninstalled_waiter_->Wait(extension_id);
+}
+
+void TestExtensionRegistryObserver::WaitForExtensionWillBeInstalled(
+    const std::string& extension_id) {
+  will_be_installed_waiter_->Wait(extension_id);
+}
+
+void TestExtensionRegistryObserver::WaitForExtensionLoaded(
+    const std::string& extension_id) {
+  loaded_waiter_->Wait(extension_id);
+}
+
+void TestExtensionRegistryObserver::WaitForExtensionUnloaded(
+    const std::string& extension_id) {
+  unloaded_waiter_->Wait(extension_id);
+}
+
+void TestExtensionRegistryObserver::OnExtensionWillBeInstalled(
+    content::BrowserContext* browser_context,
+    const Extension* extension,
+    bool is_update,
+    bool from_ephemeral,
+    const std::string& old_name) {
+  will_be_installed_waiter_->OnObserved(extension->id());
+}
+
+void TestExtensionRegistryObserver::OnExtensionUninstalled(
+    content::BrowserContext* browser_context,
+    const Extension* extension) {
+  uninstalled_waiter_->OnObserved(extension->id());
+}
+
+void TestExtensionRegistryObserver::OnExtensionLoaded(
+    content::BrowserContext* browser_context,
+    const Extension* extension) {
+  loaded_waiter_->OnObserved(extension->id());
+}
+
+void TestExtensionRegistryObserver::OnExtensionUnloaded(
+    content::BrowserContext* browser_context,
+    const Extension* extension,
+    UnloadedExtensionInfo::Reason reason) {
+  unloaded_waiter_->OnObserved(extension->id());
+}
+
+}  // namespace extensions