MacViews: Get widget_interactive_uitest compiling on Mac

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 "base/basictypes.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
-#include "ui/aura/client/focus_client.h"
-#include "ui/aura/env.h"
-#include "ui/aura/window.h"
-#include "ui/aura/window_tree_host.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/ui_base_paths.h"
 #include "ui/base/ui_base_switches.h"
 #include "ui/events/event_processor.h"
 #include "ui/events/test/event_generator.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gl/gl_surface.h"
 #include "ui/views/controls/textfield/textfield.h"
 #include "ui/views/controls/textfield/textfield_test_api.h"
 #include "ui/views/test/widget_test.h"
 #include "ui/views/touchui/touch_selection_controller_impl.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/window/dialog_delegate.h"
 #include "ui/wm/public/activation_client.h"
 
-#if !defined(OS_CHROMEOS)
+#if defined(OS_WIN)
+#include "ui/aura/window.h"
+#include "ui/aura/window_tree_host.h"
 #include "ui/views/widget/desktop_aura/desktop_native_widget_aura.h"
-#endif
-
-#if defined(OS_WIN)
 #include "ui/views/win/hwnd_util.h"
 #endif
 
 namespace views {
 namespace test {
 
 namespace {
 
 // A View that closes the Widget and exits the current message-loop when it
 // receives a mouse-release event.
@@ skipping 122 matching lines @@
     ui::ResourceBundle::InitSharedInstanceWithPakPath(ui_test_pak_path);
     WidgetTest::SetUp();
   }
 
  protected:
   static void ShowQuickMenuImmediately(
       TouchSelectionControllerImpl* controller) {
     DCHECK(controller);
     if (controller->context_menu_timer_.IsRunning()) {
       controller->context_menu_timer_.Stop();
+// TODO(tapted): Enable this when porting ui/views/touchui to Mac.
+#if !defined(OS_MACOSX)
       controller->ContextMenuTimerFired();
+#endif

[tapted, 2014/08/05 13:42:26]

This is to avoid a link error, and is all that strictly necessary here to get
interactive_ui_tests to link. Looking at it again though, maybe more should be
guarded (along with the touchui #include), or these tests should be moved to a
separate file for touch. Let me know what you think.

     }
   }
 
   static bool IsQuickMenuVisible(TouchSelectionControllerImpl* controller) {
     DCHECK(controller);
     return controller->context_menu_ && controller->context_menu_->visible();
   }
 };
 
 #if defined(OS_WIN)
@@ skipping 53 matching lines @@
 
   // Now set focus back to widget 1 and expect the active window to be its
   // window.
   contents_view1->RequestFocus();
   ::SetActiveWindow(
       root_window1->GetHost()->GetAcceleratedWidget());
   EXPECT_EQ(activation_client2->GetActiveWindow(),
             reinterpret_cast<aura::Window*>(NULL));
   EXPECT_EQ(activation_client1->GetActiveWindow(), widget1.GetNativeView());
 }
-#endif
+#endif  // defined(OS_WIN)
 
 TEST_F(WidgetTestInteractive, CaptureAutoReset) {
   Widget* toplevel = CreateTopLevelFramelessPlatformWidget();
   View* container = new View;
   toplevel->SetContentsView(container);
 
   EXPECT_FALSE(toplevel->HasCapture());
   toplevel->SetCapture(NULL);
   EXPECT_TRUE(toplevel->HasCapture());
 
@@ skipping 362 matching lines @@
   EXPECT_TRUE(::IsWindow(win32_native_window1));
 
   ::SendMessage(win32_native_window1, WM_NCACTIVATE, 1, 0);
   EXPECT_EQ(false, widget1.active());
   EXPECT_EQ(true, widget2.active());
 
   ::SetActiveWindow(win32_native_window1);
   EXPECT_EQ(true, widget1.active());
   EXPECT_EQ(false, widget2.active());
 }
-#endif
+#endif  // defined(OS_WIN)
 
 #if !defined(OS_CHROMEOS)
 // Provides functionality to create a window modal dialog.
 class ModalDialogDelegate : public DialogDelegateView {
  public:
   explicit ModalDialogDelegate(ui::ModalType type) : type_(type) {}
   virtual ~ModalDialogDelegate() {}
 
   // WidgetDelegate overrides.
   virtual ui::ModalType GetModalType() const OVERRIDE {
@@ skipping 10 matching lines @@
 // created and destroyed. When it is destroyed it should focus the owner window.
 TEST_F(WidgetTestInteractive, WindowModalWindowDestroyedActivationTest) {
   // Create a top level widget.
   Widget top_level_widget;
   Widget::InitParams init_params =
       CreateParams(Widget::InitParams::TYPE_WINDOW);
   init_params.show_state = ui::SHOW_STATE_NORMAL;
   gfx::Rect initial_bounds(0, 0, 500, 500);
   init_params.bounds = initial_bounds;
   init_params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
-  init_params.native_widget = new DesktopNativeWidgetAura(&top_level_widget);
+  init_params.native_widget =
+      new PlatformDesktopNativeWidget(&top_level_widget);
   top_level_widget.Init(init_params);
   top_level_widget.Show();
 
-  aura::Window* top_level_window = top_level_widget.GetNativeWindow();
-  EXPECT_EQ(top_level_window, aura::client::GetFocusClient(
-                top_level_window)->GetFocusedWindow());
+  gfx::NativeWindow top_level_window = top_level_widget.GetNativeWindow();
+  EXPECT_EQ(top_level_window, CurrentlyFocussedWindow(&top_level_widget));
 
   // Create a modal dialog.
   // This instance will be destroyed when the dialog is destroyed.
   ModalDialogDelegate* dialog_delegate =
       new ModalDialogDelegate(ui::MODAL_TYPE_WINDOW);
 
   Widget* modal_dialog_widget = views::DialogDelegate::CreateDialogWidget(
-      dialog_delegate, NULL, top_level_widget.GetNativeWindow());
+      dialog_delegate, NULL, top_level_widget.GetNativeView());
   modal_dialog_widget->SetBounds(gfx::Rect(100, 100, 200, 200));
   modal_dialog_widget->Show();
-  aura::Window* dialog_window = modal_dialog_widget->GetNativeWindow();
-  EXPECT_EQ(dialog_window, aura::client::GetFocusClient(
-                top_level_window)->GetFocusedWindow());
 
+  gfx::NativeWindow dialog_window = modal_dialog_widget->GetNativeWindow();
+  EXPECT_EQ(dialog_window, CurrentlyFocussedWindow(&top_level_widget));
   modal_dialog_widget->CloseNow();
-  EXPECT_EQ(top_level_window, aura::client::GetFocusClient(
-                top_level_window)->GetFocusedWindow());
+  EXPECT_EQ(top_level_window, CurrentlyFocussedWindow(&top_level_widget));
+
   top_level_widget.CloseNow();
 }
 
 // Test that when opening a system-modal window, capture is released.
 TEST_F(WidgetTestInteractive, SystemModalWindowReleasesCapture) {
   // Create a top level widget.
   Widget top_level_widget;
   Widget::InitParams init_params =
       CreateParams(Widget::InitParams::TYPE_WINDOW);
   init_params.show_state = ui::SHOW_STATE_NORMAL;
   gfx::Rect initial_bounds(0, 0, 500, 500);
   init_params.bounds = initial_bounds;
   init_params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
-  init_params.native_widget = new DesktopNativeWidgetAura(&top_level_widget);
+  init_params.native_widget =
+      new PlatformDesktopNativeWidget(&top_level_widget);
   top_level_widget.Init(init_params);
   top_level_widget.Show();
 
-  aura::Window* top_level_window = top_level_widget.GetNativeWindow();
-  EXPECT_EQ(top_level_window, aura::client::GetFocusClient(
-                top_level_window)->GetFocusedWindow());
+  gfx::NativeWindow top_level_window = top_level_widget.GetNativeWindow();
+  EXPECT_EQ(top_level_window, CurrentlyFocussedWindow(&top_level_widget));
 
-  EXPECT_FALSE(top_level_window->HasCapture());
-  top_level_window->SetCapture();
-  EXPECT_TRUE(top_level_window->HasCapture());
+  EXPECT_FALSE(top_level_widget.HasCapture());
+  top_level_widget.SetCapture(NULL);
+  EXPECT_TRUE(top_level_widget.HasCapture());
 
   // Create a modal dialog.
   ModalDialogDelegate* dialog_delegate =
       new ModalDialogDelegate(ui::MODAL_TYPE_SYSTEM);
 
   Widget* modal_dialog_widget = views::DialogDelegate::CreateDialogWidget(
-      dialog_delegate, NULL, top_level_widget.GetNativeWindow());
+      dialog_delegate, NULL, top_level_widget.GetNativeView());
   modal_dialog_widget->SetBounds(gfx::Rect(100, 100, 200, 200));
   modal_dialog_widget->Show();
 
-  EXPECT_FALSE(top_level_window->HasCapture());
+  EXPECT_FALSE(top_level_widget.HasCapture());
 
   modal_dialog_widget->CloseNow();
   top_level_widget.CloseNow();
 }
 
-#endif
+#endif  // !defined(OS_CHROMEOS)
 
 TEST_F(WidgetTestInteractive, CanActivateFlagIsHonored) {
   Widget widget;
   Widget::InitParams init_params =
       CreateParams(Widget::InitParams::TYPE_WINDOW);
   init_params.bounds = gfx::Rect(0, 0, 200, 200);
   init_params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   init_params.activatable = Widget::InitParams::ACTIVATABLE_NO;
 #if !defined(OS_CHROMEOS)
-  init_params.native_widget = new DesktopNativeWidgetAura(&widget);
+  init_params.native_widget = new PlatformDesktopNativeWidget(&widget);
 #endif  // !defined(OS_CHROMEOS)
   widget.Init(init_params);
 
   widget.Show();
   EXPECT_FALSE(widget.IsActive());
 }
 
 // Test that touch selection quick menu is not activated when opened.
 TEST_F(WidgetTestInteractive, TouchSelectionQuickMenuIsNotActivated) {
   CommandLine::ForCurrentProcess()->AppendSwitch(switches::kEnableTouchEditing);
@@ skipping 13 matching lines @@
   textfield->SetText(base::ASCIIToUTF16("some text"));
   widget.GetRootView()->AddChildView(textfield);
 
   widget.Show();
   textfield->RequestFocus();
   textfield->SelectAll(true);
   TextfieldTestApi textfield_test_api(textfield);
 
   RunPendingMessages();
 
-  ui::test::EventGenerator generator(widget.GetNativeView()->GetRootWindow());
+  ui::test::EventGenerator generator(widget.GetNativeWindow());
   generator.GestureTapAt(gfx::Point(10, 10));
   ShowQuickMenuImmediately(static_cast<TouchSelectionControllerImpl*>(
       textfield_test_api.touch_selection_controller()));
 
   EXPECT_TRUE(textfield->HasFocus());
   EXPECT_TRUE(widget.IsActive());
   EXPECT_TRUE(IsQuickMenuVisible(static_cast<TouchSelectionControllerImpl*>(
       textfield_test_api.touch_selection_controller())));
 }
 
@@ skipping 82 matching lines @@
     EXPECT_FALSE(widget1.HasCapture());
     EXPECT_FALSE(widget2.HasCapture());
     EXPECT_TRUE(widget1.GetAndClearGotCaptureLost());
     EXPECT_FALSE(widget2.GetAndClearGotCaptureLost());
   }
 
   NativeWidget* CreateNativeWidget(bool create_desktop_native_widget,
                                    Widget* widget) {
 #if !defined(OS_CHROMEOS)
     if (create_desktop_native_widget)
-      return new DesktopNativeWidgetAura(widget);
+      return new PlatformDesktopNativeWidget(widget);
 #endif
     return NULL;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(WidgetCaptureTest);
 };
 
 // See description in TestCapture().
 TEST_F(WidgetCaptureTest, Capture) {
@@ skipping 24 matching lines @@
   widget.SetContentsView(contents_view);
 
   mouse_view1->SetBounds(0, 0, 200, 400);
   mouse_view2->SetBounds(200, 0, 200, 400);
 
   // Setting capture should fail because |widget| is not visible.
   widget.SetCapture(mouse_view1);
   EXPECT_FALSE(widget.HasCapture());
 
   widget.Show();
-  ui::MouseEvent mouse_press_event(ui::ET_MOUSE_PRESSED, gfx::Point(300, 10),
-      gfx::Point(300, 10), ui::EF_NONE, ui::EF_NONE);
-  ui::EventDispatchDetails details = widget.GetNativeWindow()->GetHost()->
-      event_processor()->OnEventFromSource(&mouse_press_event);
-  ASSERT_FALSE(details.dispatcher_destroyed);
+  ui::test::EventGenerator generator(GetContext(), widget.GetNativeWindow());
+  generator.set_current_location(gfx::Point(300, 10));
+  generator.PressLeftButton();
+
   EXPECT_FALSE(mouse_view1->pressed());
   EXPECT_TRUE(mouse_view2->pressed());
 }
 
 #if !defined(OS_CHROMEOS)
 // Test that a synthetic mouse exit is sent to the widget which was handling
 // mouse events when a different widget grabs capture.
 // TODO(pkotwicz): Make test pass on CrOS.
 TEST_F(WidgetCaptureTest, MouseExitOnCaptureGrab) {
   Widget widget1;
   Widget::InitParams params1 =
       CreateParams(Widget::InitParams::TYPE_WINDOW_FRAMELESS);
   params1.native_widget = CreateNativeWidget(true, &widget1);
   params1.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   widget1.Init(params1);
   MouseView* mouse_view1 = new MouseView;
   widget1.SetContentsView(mouse_view1);
   widget1.Show();
   widget1.SetBounds(gfx::Rect(300, 300));
 
   Widget widget2;
   Widget::InitParams params2 =
       CreateParams(Widget::InitParams::TYPE_WINDOW_FRAMELESS);
   params2.native_widget = CreateNativeWidget(true, &widget2);
   params2.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   widget2.Init(params2);
   widget2.Show();
   widget2.SetBounds(gfx::Rect(400, 0, 300, 300));
 
-  ui::MouseEvent mouse_move_event(ui::ET_MOUSE_MOVED, gfx::Point(100, 100),
-      gfx::Point(100, 100), ui::EF_NONE, ui::EF_NONE);
-  ui::EventDispatchDetails details = widget1.GetNativeWindow()->GetHost()->
-      event_processor()->OnEventFromSource(&mouse_move_event);
-  ASSERT_FALSE(details.dispatcher_destroyed);
+  ui::test::EventGenerator generator(widget1.GetNativeWindow());
+  generator.set_current_location(gfx::Point(100, 100));
+  generator.MoveMouseBy(0, 0);
+
   EXPECT_EQ(1, mouse_view1->EnteredCalls());
   EXPECT_EQ(0, mouse_view1->ExitedCalls());
 
   widget2.SetCapture(NULL);
   EXPECT_EQ(0, mouse_view1->EnteredCalls());
   // Grabbing native capture on Windows generates a ui::ET_MOUSE_EXITED event
   // in addition to the one generated by Chrome.
   EXPECT_LT(0, mouse_view1->ExitedCalls());
 }
-#endif
+#endif  // !defined(OS_CHROMEOS)
 
 namespace {
 
 // Widget observer which grabs capture when the widget is activated.
 class CaptureOnActivationObserver : public WidgetObserver {
  public:
   CaptureOnActivationObserver() {
   }
   virtual ~CaptureOnActivationObserver() {
   }
@@ skipping 18 matching lines @@
       CreateParams(Widget::InitParams::TYPE_WINDOW_FRAMELESS);
   toplevel_params.native_widget = CreateNativeWidget(true, &toplevel);
   toplevel_params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   toplevel.Init(toplevel_params);
   toplevel.Show();
 
   Widget* child = new Widget;
   Widget::InitParams child_params =
       CreateParams(Widget::InitParams::TYPE_WINDOW_FRAMELESS);
   child_params.parent = toplevel.GetNativeView();
-  child_params.context = toplevel.GetNativeView();
+  child_params.context = toplevel.GetNativeWindow();
   child->Init(child_params);
 
   CaptureOnActivationObserver observer;
   child->AddObserver(&observer);
   child->Show();
 
   EXPECT_TRUE(child->HasCapture());
 }
 
 
@@ skipping 56 matching lines @@
   // Send a mouse event to the RootWindow associated with |widget1|. Even though
   // |widget2| has capture, |widget1| should still get the event.
   ui::MouseEvent mouse_event(ui::ET_MOUSE_EXITED, gfx::Point(), gfx::Point(),
                              ui::EF_NONE, ui::EF_NONE);
   ui::EventDispatchDetails details = widget1.GetNativeWindow()->
       GetHost()->event_processor()->OnEventFromSource(&mouse_event);
   ASSERT_FALSE(details.dispatcher_destroyed);
   EXPECT_TRUE(widget1.GetAndClearGotMouseEvent());
   EXPECT_FALSE(widget2.GetAndClearGotMouseEvent());
 }
-#endif
+#endif  // defined(OS_WIN)
 
 }  // namespace test
 }  // namespace views