Remove NOTIFICATION_EXTENSION_PAGE_ACTIONS_UPDATED

chrome/browser/extensions/extension_test_notification_observer.cc

 // 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.
 
 #include "chrome/browser/extensions/extension_test_notification_observer.h"
 
 #include "base/callback_list.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/test/test_utils.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/process_manager.h"
 #include "extensions/common/extension.h"
 
 using extensions::Extension;
 
 namespace {
 
-bool HasExtensionPageActionVisibilityReachedTarget(
-    LocationBarTesting* location_bar,
-    int target_visible_page_action_count) {
-  VLOG(1) << "Number of visible page actions: "
-          << location_bar->PageActionVisibleCount();
+// A callback that returns true if the condition has been met and takes no
+// arguments.
+typedef base::Callback<bool(void)> ConditionCallback;
+
+bool HasPageActionVisibilityReachedTarget(
+    LocationBarTesting* location_bar, int target_visible_page_action_count) {
   return location_bar->PageActionVisibleCount() ==
          target_visible_page_action_count;
 }
 
 bool HaveAllExtensionRenderViewHostsFinishedLoading(
     extensions::ProcessManager* manager) {
   extensions::ProcessManager::ViewSet all_views = manager->GetAllViews();
   for (extensions::ProcessManager::ViewSet::const_iterator iter =
            all_views.begin();
        iter != all_views.end(); ++iter) {
     if ((*iter)->IsLoading())
       return false;
   }
   return true;
 }
 
-class NotificationSet : public content::NotificationObserver {
+}  // namespace
+
+////////////////////////////////////////////////////////////////////////////////
+// ExtensionTestNotificationObserver::NotificationSet
+
+class ExtensionTestNotificationObserver::NotificationSet
+    : public content::NotificationObserver {
  public:
   void Add(int type, const content::NotificationSource& source);
   void Add(int type);
 
   // Notified any time an Add()ed notification is received.
   // The details of the notification are dropped.
   base::CallbackList<void()>& callback_list() {
     return callback_list_;
   }
 
  private:
   // content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
   content::NotificationRegistrar notification_registrar_;
   base::CallbackList<void()> callback_list_;
 };
 
-void NotificationSet::Add(
+void ExtensionTestNotificationObserver::NotificationSet::Add(
     int type,
     const content::NotificationSource& source) {
   notification_registrar_.Add(this, type, source);
 }
 
-void NotificationSet::Add(int type) {
+void ExtensionTestNotificationObserver::NotificationSet::Add(int type) {
   Add(type, content::NotificationService::AllSources());
 }
 
-void NotificationSet::Observe(
+void ExtensionTestNotificationObserver::NotificationSet::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   callback_list_.Notify();
 }
 
-void MaybeQuit(content::MessageLoopRunner* runner,
-               const base::Callback<bool(void)>& condition) {
-  if (condition.Run())
-    runner->Quit();
-}
-
-void WaitForCondition(
-    const base::Callback<bool(void)>& condition,
-    NotificationSet* notification_set) {
-  if (condition.Run())
-    return;
-
-  scoped_refptr<content::MessageLoopRunner> runner(
-      new content::MessageLoopRunner);
-  scoped_ptr<base::CallbackList<void()>::Subscription> subscription =
-      notification_set->callback_list().Add(
-          base::Bind(&MaybeQuit, base::Unretained(runner.get()), condition));
-  runner->Run();
-}
-
-void WaitForCondition(
-    const base::Callback<bool(void)>& condition,
-    int type) {
-  NotificationSet notification_set;
-  notification_set.Add(type);
-  WaitForCondition(condition, &notification_set);
-}
-
-}  // namespace
+////////////////////////////////////////////////////////////////////////////////
+// ExtensionTestNotificationObserver
 
 ExtensionTestNotificationObserver::ExtensionTestNotificationObserver(
     Browser* browser)
     : browser_(browser),
       profile_(NULL),
       extension_installs_observed_(0),
       extension_load_errors_observed_(0),
       crx_installers_done_observed_(0) {
 }
 
@@ skipping 18 matching lines @@
   registrar.Add(
       this, notification_type, content::NotificationService::AllSources());
   content::WindowedNotificationObserver(
       notification_type, content::NotificationService::AllSources()).Wait();
 }
 
 bool ExtensionTestNotificationObserver::WaitForPageActionVisibilityChangeTo(
     int count) {
   LocationBarTesting* location_bar =
       browser_->window()->GetLocationBar()->GetLocationBarForTesting();
+  extensions::ExtensionActionAPI::Get(GetProfile())->AddObserver(this);
   WaitForCondition(
-      base::Bind(
-          &HasExtensionPageActionVisibilityReachedTarget, location_bar, count),
-      extensions::NOTIFICATION_EXTENSION_PAGE_ACTIONS_UPDATED);
+      base::Bind(&HasPageActionVisibilityReachedTarget, location_bar, count),
+      NULL);
+  extensions::ExtensionActionAPI::Get(GetProfile())->
+      RemoveObserver(this);
   return true;
 }
 
 bool ExtensionTestNotificationObserver::WaitForExtensionViewsToLoad() {
   extensions::ProcessManager* manager =
       extensions::ExtensionSystem::Get(GetProfile())->process_manager();
   NotificationSet notification_set;
   notification_set.Add(content::NOTIFICATION_WEB_CONTENTS_DESTROYED);
   notification_set.Add(content::NOTIFICATION_LOAD_STOP);
   WaitForCondition(
@@ skipping 100 matching lines @@
     case extensions::NOTIFICATION_EXTENSION_LOAD_ERROR:
       VLOG(1) << "Got EXTENSION_LOAD_ERROR notification.";
       ++extension_load_errors_observed_;
       break;
 
     default:
       NOTREACHED();
       break;
   }
 }
+
+void ExtensionTestNotificationObserver::OnPageActionsUpdated(
+    content::WebContents* web_contents) {
+  MaybeQuit();
+}
+
+void ExtensionTestNotificationObserver::WaitForCondition(
+    const ConditionCallback& condition,
+    NotificationSet* notification_set) {
+  if (condition.Run())
+    return;
+  condition_ = condition;
+
+  scoped_refptr<content::MessageLoopRunner> runner(
+      new content::MessageLoopRunner);
+  quit_closure_ = runner->QuitClosure();
+
+  scoped_ptr<base::CallbackList<void()>::Subscription> subscription;
+  if (notification_set) {
+    subscription = notification_set->callback_list().Add(
+        base::Bind(&ExtensionTestNotificationObserver::MaybeQuit,
+                   base::Unretained(this)));
+  }
+  runner->Run();
+
+  condition_.Reset();
+  quit_closure_.Reset();
+}
+
+void ExtensionTestNotificationObserver::MaybeQuit() {
+  if (condition_.Run())
+    quit_closure_.Run();
+}