Move WidgetActivationWaiter to a common place

ui/views/widget/widget_interactive_uitest.cc

 // Copyright (c) 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 <stddef.h>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/macros.h"
@@ skipping 138 matching lines @@
     base::RunLoop run_loop;
     run_loop.Run();
     return true;
   }
 
   Widget* widget_;
 
   DISALLOW_COPY_AND_ASSIGN(NestedLoopCaptureView);
 };
 
-// Spins a run loop until a Widget's active state matches a desired state.
-class WidgetActivationWaiter : public WidgetObserver {
- public:
-  WidgetActivationWaiter(Widget* widget, bool active) : observed_(false) {
-#if defined(OS_WIN)
-    // On Windows, a HWND can receive a WM_ACTIVATE message without the value
-    // of ::GetActiveWindow() updating to reflect that change. This can cause
-    // the active window reported by IsActive() to get out of sync. Usually this
-    // happens after a call to HWNDMessageHandler::Deactivate() which works by
-    // activating some other window, which might be in another application.
-    // Doing this can trigger the native OS activation-blocker, causing the
-    // taskbar icon to flash instead. But since activation of native widgets on
-    // Windows is synchronous, we never have to wait anyway, so it's safe to
-    // return here.
-    if (active == widget->IsActive()) {
-      observed_ = true;
-      return;
-    }
-#endif
-    // Always expect a change for tests using this.
-    EXPECT_NE(active, widget->IsActive());
-    widget->AddObserver(this);
-  }
-
-  void Wait() {
-    if (!observed_)
-      run_loop_.Run();
-  }
-
-  void OnWidgetActivationChanged(Widget* widget, bool active) override {
-    observed_ = true;
-    widget->RemoveObserver(this);
-    if (run_loop_.running())
-      run_loop_.Quit();
-  }
-
- private:
-  base::RunLoop run_loop_;
-  bool observed_;
-
-  DISALLOW_COPY_AND_ASSIGN(WidgetActivationWaiter);
-};
-
 ui::WindowShowState GetWidgetShowState(const Widget* widget) {
   // Use IsMaximized/IsMinimized/IsFullScreen instead of GetWindowPlacement
   // because the former is implemented on all platforms but the latter is not.
   return widget->IsFullscreen() ? ui::SHOW_STATE_FULLSCREEN :
       widget->IsMaximized() ? ui::SHOW_STATE_MAXIMIZED :
       widget->IsMinimized() ? ui::SHOW_STATE_MINIMIZED :
       widget->IsActive() ? ui::SHOW_STATE_NORMAL :
                            ui::SHOW_STATE_INACTIVE;
 }
 
 // Give the OS an opportunity to process messages for an activation change, when
 // there is actually no change expected (e.g. ShowInactive()).
 void RunPendingMessagesForActiveStatusChange() {
 #if defined(OS_MACOSX)
   // On Mac, a single spin is *usually* enough. It isn't when a widget is shown
   // and made active in two steps, so tests should follow up with a ShowSync()
   // or ActivateSync to ensure a consistent state.
   base::RunLoop().RunUntilIdle();
 #endif
   // TODO(tapted): Check for desktop aura widgets.
 }
 
 // Activate a widget, and wait for it to become active. On non-desktop Aura
 // this is just an activation. For other widgets, it means activating and then
 // spinning the run loop until the OS has activated the window.
 void ActivateSync(Widget* widget) {
-  WidgetActivationWaiter waiter(widget, true);
+  views::test::WidgetActivationWaiter waiter(widget, true);
   widget->Activate();
   waiter.Wait();
 }
 
 // Like for ActivateSync(), wait for a widget to become active, but Show() the
 // widget rather than calling Activate().
 void ShowSync(Widget* widget) {
-  WidgetActivationWaiter waiter(widget, true);
+  views::test::WidgetActivationWaiter waiter(widget, true);
   widget->Show();
   waiter.Wait();
 }
 
 void DeactivateSync(Widget* widget) {
 #if defined(OS_MACOSX)
   // Deactivation of a window isn't a concept on Mac: If an application is
   // active and it has any activatable windows, then one of them is always
   // active. But we can simulate deactivation (e.g. as if another application
   // became active) by temporarily making |widget| non-activatable, then
   // activating (and closing) a temporary widget.
   widget->widget_delegate()->set_can_activate(false);
   Widget* stealer = new Widget;
   stealer->Init(Widget::InitParams(Widget::InitParams::TYPE_WINDOW));
   ShowSync(stealer);
   stealer->CloseNow();
   widget->widget_delegate()->set_can_activate(true);
 #else
-  WidgetActivationWaiter waiter(widget, false);
+  views::test::WidgetActivationWaiter waiter(widget, false);
   widget->Deactivate();
   waiter.Wait();
 #endif
 }
 
 #if defined(OS_WIN)
 void ActivatePlatformWindow(Widget* widget) {
   ::SetActiveWindow(
       widget->GetNativeWindow()->GetHost()->GetAcceleratedWidget());
 }
@@ skipping 653 matching lines @@
   modal_dialog_widget->Show();
 
   gfx::NativeView modal_native_view = modal_dialog_widget->GetNativeView();
   ASSERT_EQ(3u, focus_changes.size());
   EXPECT_EQ(nullptr, focus_changes[1]);
   EXPECT_EQ(modal_native_view, focus_changes[2]);
 
 #if defined(OS_MACOSX)
   // Window modal dialogs on Mac are "sheets", which animate to close before
   // activating their parent widget.
-  WidgetActivationWaiter waiter(&top_level_widget, true);
+  views::test::WidgetActivationWaiter waiter(&top_level_widget, true);
   modal_dialog_widget->Close();
   waiter.Wait();
 #else
   modal_dialog_widget->CloseNow();
 #endif
 
   ASSERT_EQ(5u, focus_changes.size());
   EXPECT_EQ(nullptr, focus_changes[3]);
   EXPECT_EQ(top_level_native_view, focus_changes[4]);
 
@@ skipping 919 matching lines @@
 
   ui::KeyEvent key_event2(key_event);
   widget->OnKeyEvent(&key_event2);
   EXPECT_FALSE(key_event2.stopped_propagation());
 
   widget->CloseNow();
 }
 
 }  // namespace test
 }  // namespace views