views: Make BookmarkBarViewTest12.CloseWithModalDialog more predictable.

chrome/browser/ui/views/bookmarks/bookmark_bar_view_test.cc

 // 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.
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 16 matching lines @@
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "chrome/test/base/view_event_test_base.h"
 #include "components/bookmarks/browser/bookmark_model.h"
 #include "components/bookmarks/test/bookmark_test_helpers.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/page_navigator.h"
 #include "content/public/test/test_browser_thread.h"
 #include "grit/generated_resources.h"
+#include "ui/aura/env.h"
+#include "ui/aura/env_observer.h"
+#include "ui/aura/window.h"
 #include "ui/base/clipboard/clipboard.h"
 #include "ui/base/test/ui_controls.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 #include "ui/views/controls/button/menu_button.h"
 #include "ui/views/controls/button/text_button.h"
 #include "ui/views/controls/menu/menu_controller.h"
 #include "ui/views/controls/menu/menu_item_view.h"
 #include "ui/views/controls/menu/submenu_view.h"
 #include "ui/views/widget/widget.h"
 
 using base::ASCIIToUTF16;
 using content::BrowserThread;
 using content::OpenURLParams;
 using content::PageNavigator;
 using content::WebContents;
 
 namespace {
 
+// Waits for a views::Widget dialog to show up.
+class DialogWaiter : public aura::EnvObserver,
+                     public views::WidgetObserver {
+ public:
+  DialogWaiter()
+      : dialog_created_(false),
+        dialog_(NULL) {
+    aura::Env::GetInstance()->AddObserver(this);
+  }
+
+  virtual ~DialogWaiter() {
+    aura::Env::GetInstance()->RemoveObserver(this);
+  }
+
+  views::Widget* WaitForDialog() {
+    if (dialog_created_)
+      return dialog_;
+    base::MessageLoopForUI* loop = base::MessageLoopForUI::current();
+    base::MessageLoopForUI::ScopedNestableTaskAllower allow_nested(loop);
+    base::RunLoop run_loop;
+    quit_closure_ = run_loop.QuitClosure();
+    run_loop.Run();
+    return dialog_;
+  }
+
+ private:
+  // aura::EnvObserver:
+  virtual void OnWindowInitialized(aura::Window* window) OVERRIDE {
+    if (dialog_)
+      return;
+    views::Widget* widget = views::Widget::GetWidgetForNativeView(window);
+    if (!widget || !widget->IsDialogBox())
+      return;
+    dialog_ = widget;
+    dialog_->AddObserver(this);
+  }
+
+  // views::WidgetObserver:
+  virtual void OnWidgetVisibilityChanged(views::Widget* widget,
+                                         bool visible) OVERRIDE {
+    CHECK_EQ(dialog_, widget);
+    if (visible) {
+      dialog_created_ = true;
+      dialog_->RemoveObserver(this);
+      if (!quit_closure_.is_null())
+        quit_closure_.Run();
+    }
+  }
+
+  bool dialog_created_;
+  views::Widget* dialog_;
+  base::Closure quit_closure_;
+
+  DISALLOW_COPY_AND_ASSIGN(DialogWaiter);
+};
+
+// Waits for a dialog to terminate.
+class DialogCloseWaiter : public views::WidgetObserver {
+ public:
+  explicit DialogCloseWaiter(views::Widget* dialog)
+      : dialog_closed_(false) {
+    dialog->AddObserver(this);
+  }
+
+  virtual ~DialogCloseWaiter() {
+    // It is not necessary to remove |this| from the dialog's observer, since
+    // the dialog is destroyed before this waiter.
+  }
+
+  void WaitForDialogClose() {
+    if (dialog_closed_)
+      return;
+    base::MessageLoopForUI* loop = base::MessageLoopForUI::current();
+    base::MessageLoopForUI::ScopedNestableTaskAllower allow_nested(loop);
+    base::RunLoop run_loop;
+    quit_closure_ = run_loop.QuitClosure();
+    run_loop.Run();
+  }
+
+ private:
+  // views::WidgetObserver:
+  virtual void OnWidgetDestroyed(views::Widget* widget) OVERRIDE {
+    dialog_closed_ = true;
+    if (!quit_closure_.is_null())
+      quit_closure_.Run();
+  }
+
+  bool dialog_closed_;
+  base::Closure quit_closure_;
+
+  DISALLOW_COPY_AND_ASSIGN(DialogCloseWaiter);
+};
+
+// Waits for a views::Widget to receive a Tab key.
+class TabKeyWaiter : public ui::EventHandler {
+ public:
+  explicit TabKeyWaiter(views::Widget* widget)
+      : widget_(widget),
+        received_tab_(false) {
+    widget_->GetNativeView()->AddPreTargetHandler(this);
+  }
+
+  virtual ~TabKeyWaiter() {
+    widget_->GetNativeView()->RemovePreTargetHandler(this);
+  }
+
+  void WaitForTab() {
+    if (received_tab_)
+      return;
+    base::MessageLoopForUI* loop = base::MessageLoopForUI::current();
+    base::MessageLoopForUI::ScopedNestableTaskAllower allow_nested(loop);
+    base::RunLoop run_loop;
+    quit_closure_ = run_loop.QuitClosure();
+    run_loop.Run();
+  }
+
+ private:
+  // ui::EventHandler:
+  virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE {
+    if (event->type() == ui::ET_KEY_RELEASED &&
+        event->key_code() == ui::VKEY_TAB) {
+      received_tab_ = true;
+      if (!quit_closure_.is_null())
+        quit_closure_.Run();
+    }
+  }
+
+  views::Widget* widget_;
+  bool received_tab_;
+  base::Closure quit_closure_;
+
+  DISALLOW_COPY_AND_ASSIGN(TabKeyWaiter);
+};
+
 void MoveMouseAndPress(const gfx::Point& screen_pos,
                        ui_controls::MouseButton button,
                        int state,
                        const base::Closure& closure) {
   ui_controls::SendMouseMove(screen_pos.x(), screen_pos.y());
   ui_controls::SendMouseEventsNotifyWhenDone(button, state, closure);
 }
 
 // PageNavigator implementation that records the URL.
 class TestingPageNavigator : public PageNavigator {
@@ skipping 112 matching lines @@
 
   virtual void TearDown() {
     // Destroy everything, then run the message loop to ensure we delete all
     // Tasks and fully shut down.
     browser_->tab_strip_model()->CloseAllTabs();
     bb_view_.reset();
     browser_.reset();
     profile_.reset();
 
     // Run the message loop to ensure we delete allTasks and fully shut down.
-    base::MessageLoop::current()->PostTask(FROM_HERE,
-                                           base::MessageLoop::QuitClosure());
-    base::MessageLoop::current()->Run();
+    base::MessageLoopForUI* loop = base::MessageLoopForUI::current();
+    base::MessageLoopForUI::ScopedNestableTaskAllower allow_nested(loop);
+    base::RunLoop run_loop;
+    loop->PostTask(FROM_HERE, run_loop.QuitClosure());
+    run_loop.Run();
 
     ViewEventTestBase::TearDown();
     BookmarkBarView::DisableAnimationsForTesting(false);
 
     browser_content_client_.reset();
     content_client_.reset();
     content::SetContentClient(NULL);
   }
 
  protected:
@@ skipping 940 matching lines @@
 
   void Step3() {
     // Make sure the context menu is showing.
     views::MenuItemView* menu = bb_view_->GetContextMenu();
     ASSERT_TRUE(menu && menu->GetSubmenu() && menu->GetSubmenu()->IsShowing());
 
     // Select the first item in the context menu (open all).
     views::MenuItemView* child_menu =
         menu->GetSubmenu()->GetMenuItemAt(0);
     ASSERT_TRUE(child_menu != NULL);
-    ui_test_utils::MoveMouseToCenterAndPress(child_menu, ui_controls::LEFT,
-        ui_controls::DOWN | ui_controls::UP, base::Closure());
 
-    // Delay until we send tab, otherwise the message box doesn't appear
-    // correctly.
-    base::MessageLoop::current()->PostDelayedTask(
-        FROM_HERE,
-        CreateEventTask(this, &BookmarkBarViewTest12::Step4),
-        base::TimeDelta::FromSeconds(1));
+    // Click and wait until the dialog box appears.
+    scoped_ptr<DialogWaiter> dialog_waiter(new DialogWaiter());
+    ui_test_utils::MoveMouseToCenterAndPress(
+        child_menu,
+        ui_controls::LEFT,
+        ui_controls::DOWN | ui_controls::UP,
+        base::Bind(
+            &BookmarkBarViewTest12::Step4, this, base::Passed(&dialog_waiter)));
   }
 
-  void Step4() {
-    // Press tab to give focus to the cancel button.
+  void Step4(scoped_ptr<DialogWaiter> waiter) {
+    views::Widget* dialog = waiter->WaitForDialog();
+    waiter.reset();
+
+    // Press tab to give focus to the cancel button. Wait until the widget
+    // receives the tab key.
+    TabKeyWaiter tab_waiter(dialog);
     ui_controls::SendKeyPress(
         window_->GetNativeWindow(), ui::VKEY_TAB, false, false, false, false);
+    tab_waiter.WaitForTab();
 
     // For some reason return isn't processed correctly unless we delay.
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
-        CreateEventTask(this, &BookmarkBarViewTest12::Step5),
+        base::Bind(
+            &BookmarkBarViewTest12::Step5, this, base::Unretained(dialog)),
         base::TimeDelta::FromSeconds(1));
   }
 
-  void Step5() {
+  void Step5(views::Widget* dialog) {
+    DialogCloseWaiter waiter(dialog);
     // And press enter so that the cancel button is selected.
-    ui_controls::SendKeyPressNotifyWhenDone(
-        window_->GetNativeWindow(), ui::VKEY_RETURN, false, false, false, false,
-        CreateEventTask(this, &BookmarkBarViewTest12::Step6));
-  }
-
-  void Step6() {
-    // Do a delayed task to give the dialog time to exit.
-    base::MessageLoop::current()->PostTask(
-        FROM_HERE, CreateEventTask(this, &BookmarkBarViewTest12::Step7));
-  }
-
-  void Step7() {
+    ui_controls::SendKeyPressNotifyWhenDone(window_->GetNativeWindow(),
+                                            ui::VKEY_RETURN,
+                                            false,
+                                            false,
+                                            false,
+                                            false,
+                                            base::Closure());
+    waiter.WaitForDialogClose();
     Done();
   }
 };
 
 #if defined(OS_LINUX) && !defined(OS_CHROMEOS) && defined(USE_AURA)
 // TODO(erg): linux_aura bringup: http://crbug.com/163931
 #define MAYBE_CloseWithModalDialog DISABLED_CloseWithModalDialog
 #else
 #define MAYBE_CloseWithModalDialog CloseWithModalDialog
 #endif
@@ skipping 634 matching lines @@
     EXPECT_TRUE(bb_view_->GetContextMenu() == NULL);
     EXPECT_TRUE(bb_view_->GetMenu() == NULL);
 
     Done();
   }
 
   BookmarkContextMenuNotificationObserver observer_;
 };
 
 VIEW_TEST(BookmarkBarViewTest21, ContextMenusForEmptyFolder)