MacViews: Add WidgetEventGenerator to abstract platform-specific event generation for tests.

ui/views/widget/widget_unittest.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 <algorithm>
 #include <set>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "ui/aura/client/aura_constants.h"
-#include "ui/aura/client/window_tree_client.h"
-#include "ui/aura/test/event_generator.h"
-#include "ui/aura/test/test_window_delegate.h"
-#include "ui/aura/window.h"
-#include "ui/aura/window_tree_host.h"
 #include "ui/base/hit_test.h"
 #include "ui/compositor/scoped_animation_duration_scale_mode.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/events/event_processor.h"
 #include "ui/events/event_utils.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gfx/point.h"
 #include "ui/views/bubble/bubble_delegate.h"
 #include "ui/views/controls/textfield/textfield.h"
+#include "ui/views/ime/input_method_delegate.h"
 #include "ui/views/test/test_views_delegate.h"
+#include "ui/views/test/widget_event_generator.h"
 #include "ui/views/test/widget_test.h"
 #include "ui/views/views_delegate.h"
-#include "ui/views/widget/native_widget_aura.h"
 #include "ui/views/widget/native_widget_delegate.h"
 #include "ui/views/widget/root_view.h"
 #include "ui/views/widget/widget_deletion_observer.h"
 #include "ui/views/window/dialog_delegate.h"
 #include "ui/views/window/native_frame_view.h"
 
-#if !defined(OS_CHROMEOS)
-#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 {
 
 // A view that keeps track of the events it receives, but consumes no events.
 class EventCountView : public View {
  public:
-  EventCountView() {}
+  EventCountView() : last_flags_(0) {}
   virtual ~EventCountView() {}
 
   int GetEventCount(ui::EventType type) {
     return event_count_[type];
   }
 
   void ResetCounts() {
     event_count_.clear();
   }
 
+  int last_flags() const {
+    return last_flags_;
+  }
+
  protected:
+  // Overridden from View:
+  virtual void OnMouseMoved(const ui::MouseEvent& event) OVERRIDE {
+    // MouseMove events are not re-dispatched from the RootView.
+    ++event_count_[ui::ET_MOUSE_MOVED];
+    last_flags_ = 0;
+  }
+
   // Overridden from ui::EventHandler:
   virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE {
-    RecordEvent(*event);
+    RecordEvent(event);
   }
   virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
-    RecordEvent(*event);
+    RecordEvent(event);
   }
   virtual void OnScrollEvent(ui::ScrollEvent* event) OVERRIDE {
-    RecordEvent(*event);
+    RecordEvent(event);
   }
   virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE {
-    RecordEvent(*event);
+    RecordEvent(event);
   }
 
  private:
-  void RecordEvent(const ui::Event& event) {
-    ++event_count_[event.type()];
+  void RecordEvent(ui::Event* event) {
+    ++event_count_[event->type()];
+    last_flags_ = event->flags();
+    // Mark the event as handled so that EventCountView receives future events
+    // in the event sequence.
+    event->SetHandled();
   }
 
   std::map<ui::EventType, int> event_count_;
+  int last_flags_;
 
   DISALLOW_COPY_AND_ASSIGN(EventCountView);
 };
 
 // A view that keeps track of the events it receives, and consumes all scroll
 // gesture events and ui::ET_SCROLL events.
 class ScrollableEventCountView : public EventCountView {
  public:
   ScrollableEventCountView() {}
   virtual ~ScrollableEventCountView() {}
@@ skipping 211 matching lines @@
 // A bag of state to monitor destructions.
 struct OwnershipTestState {
   OwnershipTestState() : widget_deleted(false), native_widget_deleted(false) {}
 
   bool widget_deleted;
   bool native_widget_deleted;
 };
 
 // A platform NativeWidget subclass that updates a bag of state when it is
 // destroyed.
-class OwnershipTestNativeWidget : public NativeWidgetAura {
+class OwnershipTestNativeWidget : public PlatformNativeWidget {
  public:
   OwnershipTestNativeWidget(internal::NativeWidgetDelegate* delegate,
                             OwnershipTestState* state)
-      : NativeWidgetAura(delegate),
+      : PlatformNativeWidget(delegate),
         state_(state) {
   }
   virtual ~OwnershipTestNativeWidget() {
     state_->native_widget_deleted = true;
   }
 
  private:
   OwnershipTestState* state_;
 
   DISALLOW_COPY_AND_ASSIGN(OwnershipTestNativeWidget);
@@ skipping 156 matching lines @@
        Ownership_PlatformNativeWidgetOwnsWidget_NativeDestroy) {
   OwnershipTestState state;
 
   Widget* widget = new OwnershipTestWidget(&state);
   Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_POPUP);
   params.native_widget =
       new OwnershipTestNativeWidgetAura(widget, &state);
   widget->Init(params);
 
   // Now simulate a destroy of the platform native widget from the OS:
-  delete widget->GetNativeView();
+  test::WidgetEventGenerator::SimulateNativeDestroy(widget);
 
   EXPECT_TRUE(state.widget_deleted);
   EXPECT_TRUE(state.native_widget_deleted);
 }
 
 // NativeWidget owns its Widget, part 4: NativeWidget is a NativeWidget,
 // destroyed by the view hierarchy that contains it.
 TEST_F(WidgetOwnershipTest,
        Ownership_ViewsNativeWidgetOwnsWidget_NativeDestroy) {
   OwnershipTestState state;
@@ skipping 133 matching lines @@
   {
     Widget widget;
     Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_POPUP);
     params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
     widget.Init(params);
     widget.Show();
 
     widget.native_widget_private()->CloseNow();
     InvokeWidgetMethods(&widget);
   }
+
 #if !defined(OS_CHROMEOS)
   {
     Widget widget;
     Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_POPUP);
-    params.native_widget = new DesktopNativeWidgetAura(&widget);
+    params.native_widget = new PlatformDesktopNativeWidget(&widget);
     params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
     widget.Init(params);
     widget.Show();
 
     widget.native_widget_private()->CloseNow();
     InvokeWidgetMethods(&widget);
   }
 #endif
 }
 
@@ skipping 260 matching lines @@
 TEST_F(WidgetTest, DISABLED_FocusChangesOnBubble) {
   // Create a widget, show and activate it and focus the contents view.
   View* contents_view = new View;
   contents_view->SetFocusable(true);
   Widget widget;
   Widget::InitParams init_params =
       CreateParams(Widget::InitParams::TYPE_WINDOW_FRAMELESS);
   init_params.bounds = gfx::Rect(0, 0, 200, 200);
   init_params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
 #if !defined(OS_CHROMEOS)
-  init_params.native_widget = new DesktopNativeWidgetAura(&widget);
+  init_params.native_widget = new PlatformDesktopNativeWidget(&widget);
 #endif
   widget.Init(init_params);
   widget.SetContentsView(contents_view);
   widget.Show();
   widget.Activate();
   contents_view->RequestFocus();
   EXPECT_TRUE(contents_view->HasFocus());
 
   // Show a bubble.
   BubbleDelegateView* bubble_delegate_view =
@@ skipping 47 matching lines @@
 // Test to ensure that after minimize, view width is set to zero.
 TEST_F(WidgetTest, TestViewWidthAfterMinimizingWidget) {
   // Create a widget.
   Widget widget;
   Widget::InitParams init_params =
       CreateParams(Widget::InitParams::TYPE_WINDOW);
   init_params.show_state = ui::SHOW_STATE_NORMAL;
   gfx::Rect initial_bounds(0, 0, 300, 400);
   init_params.bounds = initial_bounds;
   init_params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
-  init_params.native_widget = new DesktopNativeWidgetAura(&widget);
+  init_params.native_widget = new PlatformDesktopNativeWidget(&widget);
   widget.Init(init_params);
   NonClientView* non_client_view = widget.non_client_view();
   NonClientFrameView* frame_view = new MinimumSizeFrameView(&widget);
   non_client_view->SetFrameView(frame_view);
   widget.Show();
   widget.Minimize();
   EXPECT_EQ(0, frame_view->width());
 }
 
 // This class validates whether paints are received for a visible Widget.
@@ skipping 33 matching lines @@
 
   bool received_paint_while_hidden() const {
     return received_paint_while_hidden_;
   }
 
  private:
   bool expect_paint_;
   bool received_paint_while_hidden_;
 };
 
-TEST_F(WidgetTest, DesktopNativeWidgetAuraNoPaintAfterCloseTest) {
+TEST_F(WidgetTest, DesktopNativeWidgetNoPaintAfterCloseTest) {
   View* contents_view = new View;
   contents_view->SetFocusable(true);
   DesktopAuraTestValidPaintWidget widget;
   Widget::InitParams init_params =
       CreateParams(Widget::InitParams::TYPE_WINDOW_FRAMELESS);
   init_params.bounds = gfx::Rect(0, 0, 200, 200);
   init_params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
-  init_params.native_widget = new DesktopNativeWidgetAura(&widget);
+  init_params.native_widget = new PlatformDesktopNativeWidget(&widget);
   widget.Init(init_params);
   widget.SetContentsView(contents_view);
   widget.Show();
   widget.Activate();
   RunPendingMessages();
   widget.SchedulePaintInRect(init_params.bounds);
   widget.Close();
   RunPendingMessages();
   EXPECT_FALSE(widget.received_paint_while_hidden());
 }
 
-TEST_F(WidgetTest, DesktopNativeWidgetAuraNoPaintAfterHideTest) {
+TEST_F(WidgetTest, DesktopNativeWidgetNoPaintAfterHideTest) {
   View* contents_view = new View;
   contents_view->SetFocusable(true);
   DesktopAuraTestValidPaintWidget widget;
   Widget::InitParams init_params =
       CreateParams(Widget::InitParams::TYPE_WINDOW_FRAMELESS);
   init_params.bounds = gfx::Rect(0, 0, 200, 200);
   init_params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
-  init_params.native_widget = new DesktopNativeWidgetAura(&widget);
+  init_params.native_widget = new PlatformDesktopNativeWidget(&widget);
   widget.Init(init_params);
   widget.SetContentsView(contents_view);
   widget.Show();
   widget.Activate();
   RunPendingMessages();
   widget.SchedulePaintInRect(init_params.bounds);
   widget.Hide();
   RunPendingMessages();
   EXPECT_FALSE(widget.received_paint_while_hidden());
   widget.Close();
 }
 
-// This class provides functionality to create fullscreen and top level popup
-// windows. It additionally tests whether the destruction of these windows
-// occurs correctly in desktop AURA without crashing.
-// It provides facilities to test the following cases:-
-// 1. Child window destroyed which should lead to the destruction of the
-//    parent.
-// 2. Parent window destroyed which should lead to the child being destroyed.
-class DesktopAuraTopLevelWindowTest
-    : public views::TestViewsDelegate,
-      public aura::WindowObserver {
- public:
-  DesktopAuraTopLevelWindowTest()
-      : top_level_widget_(NULL),
-        owned_window_(NULL),
-        owner_destroyed_(false),
-        owned_window_destroyed_(false) {}
-
-  virtual ~DesktopAuraTopLevelWindowTest() {
-    EXPECT_TRUE(owner_destroyed_);
-    EXPECT_TRUE(owned_window_destroyed_);
-    top_level_widget_ = NULL;
-    owned_window_ = NULL;
-  }
-
-  // views::TestViewsDelegate overrides.
-  virtual void OnBeforeWidgetInit(
-      Widget::InitParams* params,
-      internal::NativeWidgetDelegate* delegate) OVERRIDE {
-    if (!params->native_widget)
-      params->native_widget = new views::DesktopNativeWidgetAura(delegate);
-  }
-
-  void CreateTopLevelWindow(const gfx::Rect& bounds, bool fullscreen) {
-    Widget::InitParams init_params;
-    init_params.type = Widget::InitParams::TYPE_WINDOW;
-    init_params.bounds = bounds;
-    init_params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
-    init_params.layer_type = aura::WINDOW_LAYER_NOT_DRAWN;
-    init_params.accept_events = fullscreen;
-
-    widget_.Init(init_params);
-
-    owned_window_ = new aura::Window(&child_window_delegate_);
-    owned_window_->SetType(ui::wm::WINDOW_TYPE_NORMAL);
-    owned_window_->SetName("TestTopLevelWindow");
-    if (fullscreen) {
-      owned_window_->SetProperty(aura::client::kShowStateKey,
-                                 ui::SHOW_STATE_FULLSCREEN);
-    } else {
-      owned_window_->SetType(ui::wm::WINDOW_TYPE_MENU);
-    }
-    owned_window_->Init(aura::WINDOW_LAYER_TEXTURED);
-    aura::client::ParentWindowWithContext(
-        owned_window_,
-        widget_.GetNativeView()->GetRootWindow(),
-        gfx::Rect(0, 0, 1900, 1600));
-    owned_window_->Show();
-    owned_window_->AddObserver(this);
-
-    ASSERT_TRUE(owned_window_->parent() != NULL);
-    owned_window_->parent()->AddObserver(this);
-
-    top_level_widget_ =
-        views::Widget::GetWidgetForNativeView(owned_window_->parent());
-    ASSERT_TRUE(top_level_widget_ != NULL);
-  }
-
-  void DestroyOwnedWindow() {
-    ASSERT_TRUE(owned_window_ != NULL);
-    delete owned_window_;
-  }
-
-  void DestroyOwnerWindow() {
-    ASSERT_TRUE(top_level_widget_ != NULL);
-    top_level_widget_->CloseNow();
-  }
-
-  virtual void OnWindowDestroying(aura::Window* window) OVERRIDE {
-    window->RemoveObserver(this);
-    if (window == owned_window_) {
-      owned_window_destroyed_ = true;
-    } else if (window == top_level_widget_->GetNativeView()) {
-      owner_destroyed_ = true;
-    } else {
-      ADD_FAILURE() << "Unexpected window destroyed callback: " << window;
-    }
-  }
-
-  aura::Window* owned_window() {
-    return owned_window_;
-  }
-
-  views::Widget* top_level_widget() {
-    return top_level_widget_;
-  }
-
- private:
-  views::Widget widget_;
-  views::Widget* top_level_widget_;
-  aura::Window* owned_window_;
-  bool owner_destroyed_;
-  bool owned_window_destroyed_;
-  aura::test::TestWindowDelegate child_window_delegate_;
-
-  DISALLOW_COPY_AND_ASSIGN(DesktopAuraTopLevelWindowTest);
-};
-
-TEST_F(WidgetTest, DesktopAuraFullscreenWindowDestroyedBeforeOwnerTest) {
-  ViewsDelegate::views_delegate = NULL;
-  DesktopAuraTopLevelWindowTest fullscreen_window;
-  ASSERT_NO_FATAL_FAILURE(fullscreen_window.CreateTopLevelWindow(
-      gfx::Rect(0, 0, 200, 200), true));
-
-  RunPendingMessages();
-  ASSERT_NO_FATAL_FAILURE(fullscreen_window.DestroyOwnedWindow());
-  RunPendingMessages();
-}
-
-TEST_F(WidgetTest, DesktopAuraFullscreenWindowOwnerDestroyed) {
-  ViewsDelegate::views_delegate = NULL;
-
-  DesktopAuraTopLevelWindowTest fullscreen_window;
-  ASSERT_NO_FATAL_FAILURE(fullscreen_window.CreateTopLevelWindow(
-      gfx::Rect(0, 0, 200, 200), true));
-
-  RunPendingMessages();
-  ASSERT_NO_FATAL_FAILURE(fullscreen_window.DestroyOwnerWindow());
-  RunPendingMessages();
-}
-
-TEST_F(WidgetTest, DesktopAuraTopLevelOwnedPopupTest) {
-  ViewsDelegate::views_delegate = NULL;
-  DesktopAuraTopLevelWindowTest popup_window;
-  ASSERT_NO_FATAL_FAILURE(popup_window.CreateTopLevelWindow(
-      gfx::Rect(0, 0, 200, 200), false));
-
-  RunPendingMessages();
-  ASSERT_NO_FATAL_FAILURE(popup_window.DestroyOwnedWindow());
-  RunPendingMessages();
-}
-
-// This test validates that when a top level owned popup Aura window is
-// resized, the widget is resized as well.
-TEST_F(WidgetTest, DesktopAuraTopLevelOwnedPopupResizeTest) {
-  ViewsDelegate::views_delegate = NULL;
-  DesktopAuraTopLevelWindowTest popup_window;
-  ASSERT_NO_FATAL_FAILURE(popup_window.CreateTopLevelWindow(
-      gfx::Rect(0, 0, 200, 200), false));
-
-  gfx::Rect new_size(0, 0, 400, 400);
-  popup_window.owned_window()->SetBounds(new_size);
-
-  EXPECT_EQ(popup_window.top_level_widget()->GetNativeView()->bounds().size(),
-            new_size.size());
-  RunPendingMessages();
-  ASSERT_NO_FATAL_FAILURE(popup_window.DestroyOwnedWindow());
-  RunPendingMessages();
-}
-
 // Test to ensure that the aura Window's visiblity state is set to visible if
 // the underlying widget is hidden and then shown.
 TEST_F(WidgetTest, TestWindowVisibilityAfterHide) {
   // Create a widget.
   Widget widget;
   Widget::InitParams init_params =
       CreateParams(Widget::InitParams::TYPE_WINDOW);
   init_params.show_state = ui::SHOW_STATE_NORMAL;
   gfx::Rect initial_bounds(0, 0, 300, 400);
   init_params.bounds = initial_bounds;
   init_params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
-  init_params.native_widget = new DesktopNativeWidgetAura(&widget);
+  init_params.native_widget = new PlatformDesktopNativeWidget(&widget);
   widget.Init(init_params);
   NonClientView* non_client_view = widget.non_client_view();
   NonClientFrameView* frame_view = new MinimumSizeFrameView(&widget);
   non_client_view->SetFrameView(frame_view);
 
   widget.Hide();
-  EXPECT_FALSE(widget.GetNativeView()->IsVisible());
+  EXPECT_FALSE(IsNativeWindowVisible(widget.GetNativeWindow()));
   widget.Show();
-  EXPECT_TRUE(widget.GetNativeView()->IsVisible());
+  EXPECT_TRUE(IsNativeWindowVisible(widget.GetNativeWindow()));
 }
 
 // The following code verifies we can correctly destroy a Widget from a mouse
 // enter/exit. We could test move/drag/enter/exit but in general we don't run
 // nested message loops from such events, nor has the code ever really dealt
 // with this situation.
 
 // Generates two moves (first generates enter, second real move), a press, drag
 // and release stopping at |last_event_type|.
 void GenerateMouseEvents(Widget* widget, ui::EventType last_event_type) {
   const gfx::Rect screen_bounds(widget->GetWindowBoundsInScreen());
   ui::MouseEvent move_event(ui::ET_MOUSE_MOVED, screen_bounds.CenterPoint(),
                             screen_bounds.CenterPoint(), 0, 0);
-  ui::EventProcessor* dispatcher =
-      widget->GetNativeWindow()->GetHost()->event_processor();
+  ui::EventProcessor* dispatcher = WidgetTest::GetEventProcessor(widget);
   ui::EventDispatchDetails details = dispatcher->OnEventFromSource(&move_event);
   if (last_event_type == ui::ET_MOUSE_ENTERED || details.dispatcher_destroyed)
     return;
   details = dispatcher->OnEventFromSource(&move_event);
   if (last_event_type == ui::ET_MOUSE_MOVED || details.dispatcher_destroyed)
     return;
 
   ui::MouseEvent press_event(ui::ET_MOUSE_PRESSED, screen_bounds.CenterPoint(),
                              screen_bounds.CenterPoint(), 0, 0);
   details = dispatcher->OnEventFromSource(&press_event);
@@ skipping 14 matching lines @@
     return;
 }
 
 // Creates a widget and invokes GenerateMouseEvents() with |last_event_type|.
 void RunCloseWidgetDuringDispatchTest(WidgetTest* test,
                                       ui::EventType last_event_type) {
   // |widget| is deleted by CloseWidgetView.
   Widget* widget = new Widget;
   Widget::InitParams params =
       test->CreateParams(Widget::InitParams::TYPE_POPUP);
-  params.native_widget = new DesktopNativeWidgetAura(widget);
+  params.native_widget = new PlatformDesktopNativeWidget(widget);
   params.bounds = gfx::Rect(0, 0, 50, 100);
   widget->Init(params);
   widget->SetContentsView(new CloseWidgetView(last_event_type));
   widget->Show();
   GenerateMouseEvents(widget, last_event_type);
 }
 
 // Verifies deleting the widget from a mouse pressed event doesn't crash.
 TEST_F(WidgetTest, CloseWidgetDuringMousePress) {
   RunCloseWidgetDuringDispatchTest(this, ui::ET_MOUSE_PRESSED);
@@ skipping 268 matching lines @@
 // Verifies WindowClosing() is invoked correctly on the delegate when a Widget
 // is closed.
 TEST_F(WidgetTest, SingleWindowClosing) {
   scoped_ptr<ClosingDelegate> delegate(new ClosingDelegate());
   Widget* widget = new Widget();  // Destroyed by CloseNow() below.
   Widget::InitParams init_params =
       CreateParams(Widget::InitParams::TYPE_WINDOW);
   init_params.bounds = gfx::Rect(0, 0, 200, 200);
   init_params.delegate = delegate.get();
 #if !defined(OS_CHROMEOS)
-  init_params.native_widget = new DesktopNativeWidgetAura(widget);
+  init_params.native_widget = new PlatformDesktopNativeWidget(widget);
 #endif
   widget->Init(init_params);
   EXPECT_EQ(0, delegate->count());
   widget->CloseNow();
   EXPECT_EQ(1, delegate->count());
 }
 
 class WidgetWindowTitleTest : public WidgetTest {
  protected:
   void RunTest(bool desktop_native_widget) {
     Widget* widget = new Widget();  // Destroyed by CloseNow() below.
     Widget::InitParams init_params =
         CreateParams(Widget::InitParams::TYPE_WINDOW);
     widget->Init(init_params);
 
 #if !defined(OS_CHROMEOS)
     if (desktop_native_widget)
-      init_params.native_widget = new DesktopNativeWidgetAura(widget);
+      init_params.native_widget = new PlatformDesktopNativeWidget(widget);
 #else
     DCHECK(!desktop_native_widget)
         << "DesktopNativeWidget does not exist on non-Aura or on ChromeOS.";
 #endif
 
     internal::NativeWidgetPrivate* native_widget =
         widget->native_widget_private();
 
     base::string16 empty;
     base::string16 s1(base::UTF8ToUTF16("Title1"));
@@ skipping 37 matching lines @@
   Widget* widget = new Widget;
   Widget::InitParams params =
       CreateParams(views::Widget::InitParams::TYPE_POPUP);
   widget->Init(params);
 
   widget->SetContentsView(new CloseWidgetView(ui::ET_MOUSE_PRESSED));
 
   widget->SetSize(gfx::Size(100, 100));
   widget->Show();
 
-  aura::test::EventGenerator generator(GetContext(), widget->GetNativeWindow());
+  test::WidgetEventGenerator generator(GetContext(), widget);
 
   WidgetDeletionObserver deletion_observer(widget);
   generator.ClickLeftButton();
   EXPECT_FALSE(deletion_observer.IsWidgetAlive());
 
   // Yay we did not crash!
 }
 
 TEST_F(WidgetTest, WidgetDeleted_InDispatchGestureEvent) {
   Widget* widget = new Widget;
   Widget::InitParams params =
       CreateParams(views::Widget::InitParams::TYPE_POPUP);
   widget->Init(params);
 
   widget->SetContentsView(new CloseWidgetView(ui::ET_GESTURE_TAP_DOWN));
 
   widget->SetSize(gfx::Size(100, 100));
   widget->Show();
 
-  aura::test::EventGenerator generator(GetContext());
+  test::WidgetEventGenerator generator(GetContext());
 
   WidgetDeletionObserver deletion_observer(widget);
   generator.GestureTapAt(widget->GetWindowBoundsInScreen().CenterPoint());
   EXPECT_FALSE(deletion_observer.IsWidgetAlive());
 
   // Yay we did not crash!
 }
 
 // See description of RunGetNativeThemeFromDestructor() for details.
 class GetNativeThemeFromDestructorView : public WidgetDelegateView {
@@ skipping 22 matching lines @@
 bool RunGetNativeThemeFromDestructor(const Widget::InitParams& in_params,
                                      bool is_first_run) {
   bool needs_second_run = false;
   // Destroyed by CloseNow() below.
   Widget* widget = new Widget;
   Widget::InitParams params(in_params);
   // Deletes itself when the Widget is destroyed.
   params.delegate = new GetNativeThemeFromDestructorView;
 #if !defined(OS_CHROMEOS)
   if (is_first_run) {
-    params.native_widget = new DesktopNativeWidgetAura(widget);
+    params.native_widget = new PlatformDesktopNativeWidget(widget);
     needs_second_run = true;
   }
 #endif
   widget->Init(params);
   widget->CloseNow();
   return needs_second_run;
 }
 
 // See description of RunGetNativeThemeFromDestructor() for details.
 TEST_F(WidgetTest, GetNativeThemeFromDestructor) {
@@ skipping 27 matching lines @@
 };
 
 // Verifies Close() results in destroying.
 TEST_F(WidgetTest, CloseDestroys) {
   bool destroyed = false;
   CloseDestroysWidget* widget = new CloseDestroysWidget(&destroyed);
   Widget::InitParams params =
       CreateParams(views::Widget::InitParams::TYPE_MENU);
   params.opacity = Widget::InitParams::OPAQUE_WINDOW;
 #if !defined(OS_CHROMEOS)
-  params.native_widget = new DesktopNativeWidgetAura(widget);
+  params.native_widget = new PlatformDesktopNativeWidget(widget);
 #endif
   widget->Init(params);
   widget->Show();
   widget->Hide();
   widget->Close();
   // Run the message loop as Close() asynchronously deletes.
   RunPendingMessages();
   EXPECT_TRUE(destroyed);
   // Close() should destroy the widget. If not we'll cleanup to avoid leaks.
   if (!destroyed) {
     widget->Detach();
     widget->CloseNow();
   }
 }
 
 // Tests that killing a widget while animating it does not crash.
 TEST_F(WidgetTest, CloseWidgetWhileAnimating) {
   scoped_ptr<Widget> widget(new Widget);
   Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_POPUP);
   params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   widget->Init(params);
 
   // Normal animations for tests have ZERO_DURATION, make sure we are actually
   // animating the movement.
   ui::ScopedAnimationDurationScaleMode animation_scale_mode(
       ui::ScopedAnimationDurationScaleMode::NORMAL_DURATION);
   ui::ScopedLayerAnimationSettings animation_settings(
-      widget->GetNativeWindow()->layer()->GetAnimator());
+      widget->GetLayer()->GetAnimator());
   widget->Show();
   // Animate the bounds change.
   widget->SetBounds(gfx::Rect(0, 0, 200, 200));
 }
 
 // A view that consumes mouse-pressed event and gesture-tap-down events.
 class RootViewTestView : public View {
  public:
   RootViewTestView(): View() {}
 
@@ skipping 155 matching lines @@
   void RunDestroyChildWidgetsTest(bool top_level_has_desktop_native_widget_aura,
                                   bool child_has_desktop_native_widget_aura) {
     // When a View is destroyed its name is added here.
     std::vector<std::string> destroyed;
 
     Widget* top_level = new Widget;
     Widget::InitParams params =
         CreateParams(views::Widget::InitParams::TYPE_WINDOW);
 #if !defined(OS_CHROMEOS)
     if (top_level_has_desktop_native_widget_aura)
-      params.native_widget = new DesktopNativeWidgetAura(top_level);
+      params.native_widget = new PlatformDesktopNativeWidget(top_level);
 #endif
     top_level->Init(params);
     top_level->GetRootView()->AddChildView(
         new DestroyedTrackingView("parent", &destroyed));
     top_level->Show();
 
     Widget* child = new Widget;
     Widget::InitParams child_params =
         CreateParams(views::Widget::InitParams::TYPE_POPUP);
     child_params.parent = top_level->GetNativeView();
 #if !defined(OS_CHROMEOS)
     if (child_has_desktop_native_widget_aura)
-      child_params.native_widget = new DesktopNativeWidgetAura(child);
+      child_params.native_widget = new PlatformDesktopNativeWidget(child);
 #endif
     child->Init(child_params);
     child->GetRootView()->AddChildView(
         new DestroyedTrackingView("child", &destroyed));
     child->Show();
 
     // Should trigger destruction of the child too.
     top_level->native_widget_private()->CloseNow();
 
     // Child should be destroyed first.
@@ skipping 13 matching lines @@
        DestroyChildWidgetsInOrderWithDesktopNativeWidget) {
   RunDestroyChildWidgetsTest(true, false);
 }
 
 // See description of RunDestroyChildWidgetsTest(). Both parent and child use
 // DesktopNativeWidgetAura.
 TEST_F(WidgetChildDestructionTest,
        DestroyChildWidgetsInOrderWithDesktopNativeWidgetForBoth) {
   RunDestroyChildWidgetsTest(true, true);
 }
-#endif
+#endif  // !defined(OS_CHROMEOS)
 
 // See description of RunDestroyChildWidgetsTest().
 TEST_F(WidgetChildDestructionTest, DestroyChildWidgetsInOrder) {
   RunDestroyChildWidgetsTest(false, false);
 }
 
 #if !defined(OS_CHROMEOS)
 // Provides functionality to create a window modal dialog.
 class ModalDialogDelegate : public DialogDelegateView {
  public:
@@ skipping 13 matching lines @@
 // displayed are eaten or recieved by the dialog.
 TEST_F(WidgetTest, WindowMouseModalityTest) {
   // 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();
   EXPECT_TRUE(top_level_widget.IsVisible());
 
   // Create a view and validate that a mouse moves makes it to the view.
   EventCountView* widget_view = new EventCountView();
   widget_view->SetBounds(0, 0, 10, 10);
   top_level_widget.GetRootView()->AddChildView(widget_view);
 
   gfx::Point cursor_location_main(5, 5);
   ui::MouseEvent move_main(ui::ET_MOUSE_MOVED,
                            cursor_location_main,
                            cursor_location_main,
                            ui::EF_NONE,
                            ui::EF_NONE);
-  ui::EventDispatchDetails details = top_level_widget.GetNativeView()->
-      GetHost()->event_processor()->OnEventFromSource(&move_main);
+  ui::EventDispatchDetails details =
+      GetEventProcessor(&top_level_widget)->OnEventFromSource(&move_main);
   ASSERT_FALSE(details.dispatcher_destroyed);
 
   EXPECT_EQ(1, widget_view->GetEventCount(ui::ET_MOUSE_ENTERED));
   widget_view->ResetCounts();
 
   // Create a modal dialog and validate that a mouse down message makes it to
   // the main view within the dialog.
 
   // This instance will be destroyed when the dialog is destroyed.
   ModalDialogDelegate* dialog_delegate = new ModalDialogDelegate;
 
   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));
   EventCountView* dialog_widget_view = new EventCountView();
   dialog_widget_view->SetBounds(0, 0, 50, 50);
   modal_dialog_widget->GetRootView()->AddChildView(dialog_widget_view);
   modal_dialog_widget->Show();
   EXPECT_TRUE(modal_dialog_widget->IsVisible());
 
   gfx::Point cursor_location_dialog(100, 100);
   ui::MouseEvent mouse_down_dialog(ui::ET_MOUSE_PRESSED,
                                    cursor_location_dialog,
                                    cursor_location_dialog,
                                    ui::EF_NONE,
                                    ui::EF_NONE);
-  details = top_level_widget.GetNativeView()->GetHost()->event_processor()->
-      OnEventFromSource(&mouse_down_dialog);
+  details = GetEventProcessor(&top_level_widget)->OnEventFromSource(
+      &mouse_down_dialog);
   ASSERT_FALSE(details.dispatcher_destroyed);
   EXPECT_EQ(1, dialog_widget_view->GetEventCount(ui::ET_MOUSE_PRESSED));
 
   // Send a mouse move message to the main window. It should not be received by
   // the main window as the modal dialog is still active.
   gfx::Point cursor_location_main2(6, 6);
   ui::MouseEvent mouse_down_main(ui::ET_MOUSE_MOVED,
                                  cursor_location_main2,
                                  cursor_location_main2,
                                  ui::EF_NONE,
                                  ui::EF_NONE);
-  details = top_level_widget.GetNativeView()->GetHost()->event_processor()->
-      OnEventFromSource(&mouse_down_main);
+  details = GetEventProcessor(&top_level_widget)->OnEventFromSource(
+      &mouse_down_main);
   ASSERT_FALSE(details.dispatcher_destroyed);
   EXPECT_EQ(0, widget_view->GetEventCount(ui::ET_MOUSE_MOVED));
 
   modal_dialog_widget->CloseNow();
   top_level_widget.CloseNow();
 }
 
 // Verifies nativeview visbility matches that of Widget visibility when
 // SetFullscreen is invoked.
 TEST_F(WidgetTest, FullscreenStatePropagated) {
   Widget::InitParams init_params =
       CreateParams(Widget::InitParams::TYPE_WINDOW);
   init_params.show_state = ui::SHOW_STATE_NORMAL;
   init_params.bounds = gfx::Rect(0, 0, 500, 500);
   init_params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
 
   {
     Widget top_level_widget;
     top_level_widget.Init(init_params);
     top_level_widget.SetFullscreen(true);
     EXPECT_EQ(top_level_widget.IsVisible(),
-              top_level_widget.GetNativeView()->IsVisible());
+              IsNativeWindowVisible(top_level_widget.GetNativeWindow()));
     top_level_widget.CloseNow();
   }
 
-#if !defined(OS_CHROMEOS)
   {
     Widget top_level_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.SetFullscreen(true);
     EXPECT_EQ(top_level_widget.IsVisible(),
-              top_level_widget.GetNativeView()->IsVisible());
+              IsNativeWindowVisible(top_level_widget.GetNativeWindow()));
     top_level_widget.CloseNow();
   }
-#endif
 }
 
 #if defined(OS_WIN)
 
 // Provides functionality to test widget activation via an activation flag
 // which can be set by an accessor.
 class ModalWindowTestWidgetDelegate : public WidgetDelegate {
  public:
   ModalWindowTestWidgetDelegate()
       : widget_(NULL),
@@ skipping 73 matching lines @@
   LRESULT activate_result = ::SendMessage(
       win32_window,
       WM_MOUSEACTIVATE,
       reinterpret_cast<WPARAM>(win32_window),
       MAKELPARAM(WM_LBUTTONDOWN, HTCLIENT));
   EXPECT_EQ(activate_result, MA_ACTIVATE);
 
   modal_dialog_widget->CloseNow();
   top_level_widget.CloseNow();
 }
-#endif
-#endif
+#endif  // defined(OS_WIN)
+#endif  // !defined(OS_CHROMEOS)
 
 TEST_F(WidgetTest, ShowCreatesActiveWindow) {
   Widget* widget = CreateTopLevelPlatformWidget();
 
   widget->Show();
   EXPECT_EQ(GetWidgetShowState(widget), ui::SHOW_STATE_NORMAL);
 
   widget->CloseNow();
 }
 
@@ skipping 27 matching lines @@
 }
 
 #if !defined(OS_CHROMEOS)
 TEST_F(WidgetTest, InactiveWidgetDoesNotGrabActivation) {
   Widget* widget = CreateTopLevelPlatformWidget();
   widget->Show();
   EXPECT_EQ(GetWidgetShowState(widget), ui::SHOW_STATE_NORMAL);
 
   Widget widget2;
   Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_POPUP);
-  params.native_widget = new DesktopNativeWidgetAura(&widget2);
+  params.native_widget = new PlatformDesktopNativeWidget(&widget2);
   params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   widget2.Init(params);
   widget2.Show();
 
   EXPECT_EQ(GetWidgetShowState(&widget2), ui::SHOW_STATE_INACTIVE);
   EXPECT_EQ(GetWidgetShowState(widget), ui::SHOW_STATE_NORMAL);
 
   widget->CloseNow();
   widget2.CloseNow();
 }
-#endif
+#endif  // !defined(OS_CHROMEOS)
 
 namespace {
 
 class FullscreenAwareFrame : public views::NonClientFrameView {
  public:
   explicit FullscreenAwareFrame(views::Widget* widget)
       : widget_(widget), fullscreen_layout_called_(false) {}
   virtual ~FullscreenAwareFrame() {}
 
   // views::NonClientFrameView overrides:
@@ skipping 69 matching lines @@
 }  // namespace
 
 // Verifies Widget::IsActive() invoked from
 // WidgetObserver::OnWidgetDestroying() in a child widget doesn't crash.
 TEST_F(WidgetTest, IsActiveFromDestroy) {
   // Create two widgets, one a child of the other.
   IsActiveFromDestroyObserver observer;
   Widget parent_widget;
   Widget::InitParams parent_params =
       CreateParams(Widget::InitParams::TYPE_POPUP);
-  parent_params.native_widget = new DesktopNativeWidgetAura(&parent_widget);
+  parent_params.native_widget = new PlatformDesktopNativeWidget(&parent_widget);
   parent_params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   parent_widget.Init(parent_params);
   parent_widget.Show();
 
   Widget child_widget;
   Widget::InitParams child_params =
       CreateParams(Widget::InitParams::TYPE_POPUP);
   child_params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   child_params.context = parent_widget.GetNativeView();
   child_widget.Init(child_params);
   child_widget.AddObserver(&observer);
   child_widget.Show();
 
   parent_widget.CloseNow();
 }
-#endif
+#endif  // !defined(OS_CHROMEOS)
+
+// Tests that events propagate through from the dispatcher with the correct
+// event type, and that the different platforms behave the same.
+TEST_F(WidgetTest, MouseEventTypesViaGenerator) {
+  EventCountView* view = new EventCountView;
+  view->SetBounds(10, 10, 50, 40);
+
+  Widget* widget = CreateTopLevelPlatformWidget();
+  widget->GetRootView()->AddChildView(view);
+
+  widget->SetBounds(gfx::Rect(0, 0, 100, 80));
+
+  test::WidgetEventGenerator generator(widget);
+  generator.set_current_location(gfx::Point(20, 20));
+
+  generator.ClickLeftButton();
+  EXPECT_EQ(1, view->GetEventCount(ui::ET_MOUSE_PRESSED));
+  EXPECT_EQ(1, view->GetEventCount(ui::ET_MOUSE_RELEASED));
+  EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON, view->last_flags());
+
+  generator.PressRightButton();
+  EXPECT_EQ(2, view->GetEventCount(ui::ET_MOUSE_PRESSED));
+  EXPECT_EQ(1, view->GetEventCount(ui::ET_MOUSE_RELEASED));
+  EXPECT_EQ(ui::EF_RIGHT_MOUSE_BUTTON, view->last_flags());
+
+  generator.ReleaseRightButton();
+  EXPECT_EQ(2, view->GetEventCount(ui::ET_MOUSE_PRESSED));
+  EXPECT_EQ(2, view->GetEventCount(ui::ET_MOUSE_RELEASED));
+  EXPECT_EQ(ui::EF_RIGHT_MOUSE_BUTTON, view->last_flags());
+
+  // Test mouse move events.

[Andre, 2014/06/17 21:17:56]

In Cocoa, mouseEntered: and mouseExited: are sent when entering/exiting
NSTrackingArea not NSView.
mouseEntered: and mouseExited: are sent to the owner of the tracking area.
So the scenario in this test will not happen when moving a real mouse over
views.

[tapted, 2014/06/18 08:28:06]

Yeah - EmulateSendEvent in the event generator currently assumes tracking areas
are set up correctly. We'll need separate tests for that in
bridged_somethingorother_unittest to ensure we get mouseMoved events.
views::internal::RootView will then convert the mouseMoved into appropriate
entered/existed events. (so, since the generator shouldn't care about
entered/exited, I've made those NOTREACHED() in EmulateSendEvent)

+  EXPECT_EQ(0, view->GetEventCount(ui::ET_MOUSE_MOVED));
+  EXPECT_EQ(0, view->GetEventCount(ui::ET_MOUSE_ENTERED));
+
+  // Move the mouse within the view (20, 20) -> (30, 30).
+  generator.MoveMouseTo(gfx::Point(30, 30));
+  EXPECT_EQ(1, view->GetEventCount(ui::ET_MOUSE_MOVED));
+  EXPECT_EQ(1, view->GetEventCount(ui::ET_MOUSE_ENTERED));
+  EXPECT_EQ(ui::EF_NONE, view->last_flags());
+
+  // Move it again - entered count shouldn't change.
+  generator.MoveMouseTo(gfx::Point(31, 31));
+  EXPECT_EQ(2, view->GetEventCount(ui::ET_MOUSE_MOVED));
+  EXPECT_EQ(1, view->GetEventCount(ui::ET_MOUSE_ENTERED));
+  EXPECT_EQ(0, view->GetEventCount(ui::ET_MOUSE_EXITED));
+
+  // Move it off the view.
+  generator.MoveMouseTo(gfx::Point(5, 5));
+  EXPECT_EQ(2, view->GetEventCount(ui::ET_MOUSE_MOVED));

[Andre, 2014/06/17 21:17:56]

MOUSE_MOVED does not increase to 3 here?
Seems a little weird that entering increments MOUSE_MOVED but not exiting.
Also, check that MOUSE_ENTERED is still 1 here?

[tapted, 2014/06/18 08:28:06]

I think that's reasonable - if a MOUSEMOVED were sent, it would have coordinates
that were not enclosed within the view, which isn't the case when entering.
Done.

+  EXPECT_EQ(1, view->GetEventCount(ui::ET_MOUSE_EXITED));
+
+  // Move it back on.
+  generator.MoveMouseTo(gfx::Point(20, 20));
+  EXPECT_EQ(3, view->GetEventCount(ui::ET_MOUSE_MOVED));
+  EXPECT_EQ(2, view->GetEventCount(ui::ET_MOUSE_ENTERED));
+  EXPECT_EQ(1, view->GetEventCount(ui::ET_MOUSE_EXITED));
+
+  // Drargging. Cover HasCapture() and NativeWidgetPrivate::IsMouseButtonDown().
+  generator.DragMouseTo(gfx::Point(40, 40));
+  EXPECT_EQ(3, view->GetEventCount(ui::ET_MOUSE_PRESSED));
+  EXPECT_EQ(3, view->GetEventCount(ui::ET_MOUSE_RELEASED));
+  EXPECT_EQ(1, view->GetEventCount(ui::ET_MOUSE_DRAGGED));
+  EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON, view->last_flags());
+
+  widget->CloseNow();
+}
 
 }  // namespace test
 }  // namespace views