mus: Server-side implementation of modal windows

components/mus/ws/event_dispatcher_unittest.cc

 // Copyright 2015 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 "components/mus/ws/event_dispatcher.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <queue>
@@ skipping 163 matching lines @@
 
   ServerWindow* root_window() { return root_window_.get(); }
   TestEventDispatcherDelegate* test_event_dispatcher_delegate() {
     return test_event_dispatcher_delegate_.get();
   }
   EventDispatcher* event_dispatcher() { return event_dispatcher_.get(); }
 
   bool AreAnyPointersDown() const;
   // Deletes everything created during SetUp()
   void ClearSetup();
-  // Creates a window which is a child of |root_window_|. It is not owned by
-  // EventDispatcherTest.
-  ServerWindow* CreateChildWindow(const WindowId& id);
+  scoped_ptr<ServerWindow> CreateChildWindowWithParent(const WindowId& id,
+                                                       ServerWindow* parent);
+  // Creates a window which is a child of |root_window_|.
+  scoped_ptr<ServerWindow> CreateChildWindow(const WindowId& id);
   bool IsMouseButtonDown() const;
   bool IsWindowPointerTarget(ServerWindow* window) const;
   int NumberPointerTargetsForWindow(ServerWindow* window) const;
 
  protected:
   // testing::Test:
   void SetUp() override;
 
  private:
   scoped_ptr<TestServerWindowDelegate> window_delegate_;
   scoped_ptr<ServerWindow> root_window_;
   scoped_ptr<TestEventDispatcherDelegate> test_event_dispatcher_delegate_;
   scoped_ptr<EventDispatcher> event_dispatcher_;
 
   DISALLOW_COPY_AND_ASSIGN(EventDispatcherTest);
 };
 
 bool EventDispatcherTest::AreAnyPointersDown() const {
   return event_dispatcher_->AreAnyPointersDown();
 }
 
 void EventDispatcherTest::ClearSetup() {
   window_delegate_.reset();
   root_window_.reset();
   test_event_dispatcher_delegate_.reset();
   event_dispatcher_.reset();
 }
 
-ServerWindow* EventDispatcherTest::CreateChildWindow(const WindowId& id) {
-  ServerWindow* child = new ServerWindow(window_delegate_.get(), id);
-  root_window_->Add(child);
+scoped_ptr<ServerWindow> EventDispatcherTest::CreateChildWindowWithParent(
+    const WindowId& id,
+    ServerWindow* parent) {
+  scoped_ptr<ServerWindow> child(new ServerWindow(window_delegate_.get(), id));
+  parent->Add(child.get());
   child->SetVisible(true);
-  EnableHitTest(child);
+  EnableHitTest(child.get());
   return child;
 }
 
+scoped_ptr<ServerWindow> EventDispatcherTest::CreateChildWindow(
+    const WindowId& id) {
+  return CreateChildWindowWithParent(id, root_window_.get());
+}
+
 bool EventDispatcherTest::IsMouseButtonDown() const {
   return event_dispatcher_->mouse_button_down_;
 }
 
 bool EventDispatcherTest::IsWindowPointerTarget(ServerWindow* window) const {
   return event_dispatcher_->IsObservingWindow(window);
 }
 
 int EventDispatcherTest::NumberPointerTargetsForWindow(
     ServerWindow* window) const {
@@ skipping 13 matching lines @@
   root_window_->SetVisible(true);
 
   test_event_dispatcher_delegate_.reset(
       new TestEventDispatcherDelegate(root_window_.get()));
   event_dispatcher_.reset(
       new EventDispatcher(test_event_dispatcher_delegate_.get()));
   event_dispatcher_->set_root(root_window_.get());
 }
 
 TEST_F(EventDispatcherTest, ProcessEvent) {
-  scoped_ptr<ServerWindow> child(CreateChildWindow(WindowId(1, 3)));
+  scoped_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
 
   root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
   child->SetBounds(gfx::Rect(10, 10, 20, 20));
 
   // Send event that is over child.
   const ui::PointerEvent ui_event(ui::MouseEvent(
       ui::ET_MOUSE_PRESSED, gfx::Point(20, 25), gfx::Point(20, 25),
       base::TimeDelta(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON));
   event_dispatcher()->ProcessEvent(ui_event);
 
@@ skipping 103 matching lines @@
   ui::KeyEvent key(ui::ET_KEY_PRESSED, ui::VKEY_W, ui::EF_CONTROL_DOWN);
   dispatcher->ProcessEvent(key);
   EXPECT_EQ(0u, event_dispatcher_delegate->GetAndClearLastAccelerator());
 
   // TODO(jonross): Update this test to include actual invokation of PostTarget
   // acceleratos once events acking includes consuming.
 }
 
 TEST_F(EventDispatcherTest, Capture) {
   ServerWindow* root = root_window();
-  scoped_ptr<ServerWindow> child(CreateChildWindow(WindowId(1, 3)));
+  scoped_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
 
   root->SetBounds(gfx::Rect(0, 0, 100, 100));
   child->SetBounds(gfx::Rect(10, 10, 20, 20));
 
   MouseEventTest tests[] = {
       // Send a mouse down event over child.
       {ui::MouseEvent(ui::ET_MOUSE_PRESSED, gfx::Point(20, 25),
                       gfx::Point(20, 25), base::TimeDelta(),
                       ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON),
        child.get(), gfx::Point(20, 25), gfx::Point(10, 15), nullptr,
@@ skipping 21 matching lines @@
                       ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON),
        child.get(), gfx::Point(50, 50), gfx::Point(40, 40), root,
        gfx::Point(50, 50), gfx::Point(50, 50)},
 
   };
   RunMouseEventTests(event_dispatcher(), test_event_dispatcher_delegate(),
                      tests, arraysize(tests));
 }
 
 TEST_F(EventDispatcherTest, CaptureMultipleMouseButtons) {
-  scoped_ptr<ServerWindow> child(CreateChildWindow(WindowId(1, 3)));
+  scoped_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
 
   root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
   child->SetBounds(gfx::Rect(10, 10, 20, 20));
 
   MouseEventTest tests[] = {
       // Send a mouse down event over child with a left mouse button
       {ui::MouseEvent(ui::ET_MOUSE_PRESSED, gfx::Point(20, 25),
                       gfx::Point(20, 25), base::TimeDelta(),
                       ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON),
        child.get(), gfx::Point(20, 25), gfx::Point(10, 15), nullptr,
@@ skipping 22 matching lines @@
                       ui::EF_LEFT_MOUSE_BUTTON, 0),
        child.get(), gfx::Point(50, 50), gfx::Point(40, 40), nullptr,
        gfx::Point(), gfx::Point()},
 
   };
   RunMouseEventTests(event_dispatcher(), test_event_dispatcher_delegate(),
                      tests, arraysize(tests));
 }
 
 TEST_F(EventDispatcherTest, ClientAreaGoesToOwner) {
-  scoped_ptr<ServerWindow> child(CreateChildWindow(WindowId(1, 3)));
+  scoped_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
 
   root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
   child->SetBounds(gfx::Rect(10, 10, 20, 20));
 
   child->SetClientArea(gfx::Insets(5, 5, 5, 5), std::vector<gfx::Rect>());
 
   TestEventDispatcherDelegate* event_dispatcher_delegate =
       test_event_dispatcher_delegate();
   EventDispatcher* dispatcher = event_dispatcher();
 
@@ skipping 48 matching lines @@
   EXPECT_EQ(ui::ET_POINTER_EXITED, details->event->type());
 
   details = event_dispatcher_delegate->GetAndAdvanceDispatchedEventDetails();
   EXPECT_FALSE(event_dispatcher_delegate->has_queued_events());
   ASSERT_EQ(child.get(), details->window);
   EXPECT_FALSE(details->in_nonclient_area);
   EXPECT_EQ(ui::ET_POINTER_DOWN, details->event->type());
 }
 
 TEST_F(EventDispatcherTest, AdditionalClientArea) {
-  scoped_ptr<ServerWindow> child(CreateChildWindow(WindowId(1, 3)));
+  scoped_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
 
   root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
   child->SetBounds(gfx::Rect(10, 10, 20, 20));
 
   std::vector<gfx::Rect> additional_client_areas;
   additional_client_areas.push_back(gfx::Rect(18, 0, 2, 2));
   child->SetClientArea(gfx::Insets(5, 5, 5, 5), additional_client_areas);
 
   TestEventDispatcherDelegate* event_dispatcher_delegate =
       test_event_dispatcher_delegate();
   // Press in the additional client area, it should go to the child.
   const ui::PointerEvent press_event(ui::MouseEvent(
       ui::ET_MOUSE_PRESSED, gfx::Point(28, 11), gfx::Point(28, 11),
       base::TimeDelta(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON));
   event_dispatcher()->ProcessEvent(press_event);
 
   // Events should target child and be in the client area.
   scoped_ptr<DispatchedEventDetails> details =
       event_dispatcher_delegate->GetAndAdvanceDispatchedEventDetails();
   EXPECT_FALSE(event_dispatcher_delegate->has_queued_events());
   ASSERT_EQ(child.get(), details->window);
   EXPECT_FALSE(details->in_nonclient_area);
 }
 
 TEST_F(EventDispatcherTest, DontFocusOnSecondDown) {
-  scoped_ptr<ServerWindow> child1(CreateChildWindow(WindowId(1, 3)));
-  scoped_ptr<ServerWindow> child2(CreateChildWindow(WindowId(1, 4)));
+  scoped_ptr<ServerWindow> child1 = CreateChildWindow(WindowId(1, 3));
+  scoped_ptr<ServerWindow> child2 = CreateChildWindow(WindowId(1, 4));
 
   root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
   child1->SetBounds(gfx::Rect(10, 10, 20, 20));
   child2->SetBounds(gfx::Rect(50, 51, 11, 12));
 
   TestEventDispatcherDelegate* event_dispatcher_delegate =
       test_event_dispatcher_delegate();
   EventDispatcher* dispatcher = event_dispatcher();
 
   // Press on child1. First press event should change focus.
@@ skipping 13 matching lines @@
   const ui::PointerEvent touch_event(ui::TouchEvent(
       ui::ET_TOUCH_PRESSED, gfx::Point(53, 54), 2, base::TimeDelta()));
   dispatcher->ProcessEvent(touch_event);
   details = event_dispatcher_delegate->GetAndAdvanceDispatchedEventDetails();
   EXPECT_FALSE(event_dispatcher_delegate->has_queued_events());
   EXPECT_EQ(child2.get(), details->window);
   EXPECT_EQ(nullptr, event_dispatcher_delegate->GetAndClearLastFocusedWindow());
 }
 
 TEST_F(EventDispatcherTest, TwoPointersActive) {
-  scoped_ptr<ServerWindow> child1(CreateChildWindow(WindowId(1, 3)));
-  scoped_ptr<ServerWindow> child2(CreateChildWindow(WindowId(1, 4)));
+  scoped_ptr<ServerWindow> child1 = CreateChildWindow(WindowId(1, 3));
+  scoped_ptr<ServerWindow> child2 = CreateChildWindow(WindowId(1, 4));
 
   root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
   child1->SetBounds(gfx::Rect(10, 10, 20, 20));
   child2->SetBounds(gfx::Rect(50, 51, 11, 12));
 
   TestEventDispatcherDelegate* event_dispatcher_delegate =
       test_event_dispatcher_delegate();
   EventDispatcher* dispatcher = event_dispatcher();
 
   // Press on child1.
@@ skipping 37 matching lines @@
   details = event_dispatcher_delegate->GetAndAdvanceDispatchedEventDetails();
   EXPECT_EQ(child1.get(), details->window);
   const ui::PointerEvent touch_event3(ui::TouchEvent(
       ui::ET_TOUCH_PRESSED, gfx::Point(54, 55), 2, base::TimeDelta()));
   dispatcher->ProcessEvent(touch_event3);
   details = event_dispatcher_delegate->GetAndAdvanceDispatchedEventDetails();
   EXPECT_EQ(child2.get(), details->window);
 }
 
 TEST_F(EventDispatcherTest, DestroyWindowWhileGettingEvents) {
-  scoped_ptr<ServerWindow> child(CreateChildWindow(WindowId(1, 3)));
+  scoped_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
 
   root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
   child->SetBounds(gfx::Rect(10, 10, 20, 20));
 
   TestEventDispatcherDelegate* event_dispatcher_delegate =
       test_event_dispatcher_delegate();
   EventDispatcher* dispatcher = event_dispatcher();
 
   // Press on child.
   const ui::PointerEvent touch_event1(ui::TouchEvent(
       ui::ET_TOUCH_PRESSED, gfx::Point(12, 13), 1, base::TimeDelta()));
   dispatcher->ProcessEvent(touch_event1);
   scoped_ptr<DispatchedEventDetails> details =
       event_dispatcher_delegate->GetAndAdvanceDispatchedEventDetails();
   EXPECT_FALSE(event_dispatcher_delegate->has_queued_events());
   EXPECT_EQ(child.get(), details->window);
 
   // Delete child, and continue the drag. Event should not be dispatched.
   child.reset();
 
   const ui::PointerEvent drag_event1(ui::TouchEvent(
       ui::ET_TOUCH_MOVED, gfx::Point(53, 54), 1, base::TimeDelta()));
   dispatcher->ProcessEvent(drag_event1);
   details = event_dispatcher_delegate->GetAndAdvanceDispatchedEventDetails();
   EXPECT_EQ(nullptr, details.get());
 }
 
 TEST_F(EventDispatcherTest, MouseInExtendedHitTestRegion) {
   ServerWindow* root = root_window();
-  scoped_ptr<ServerWindow> child(CreateChildWindow(WindowId(1, 3)));
+  scoped_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
 
   root->SetBounds(gfx::Rect(0, 0, 100, 100));
   child->SetBounds(gfx::Rect(10, 10, 20, 20));
 
   TestEventDispatcherDelegate* event_dispatcher_delegate =
       test_event_dispatcher_delegate();
   EventDispatcher* dispatcher = event_dispatcher();
 
   // Send event that is not over child.
   const ui::PointerEvent ui_event(ui::MouseEvent(
@@ skipping 29 matching lines @@
   ASSERT_EQ(child.get(), details->window);
   EXPECT_EQ(ui::ET_POINTER_DOWN, details->event->type());
   ASSERT_TRUE(details->event.get());
   ASSERT_TRUE(details->event->IsPointerEvent());
   EXPECT_EQ(gfx::Point(-2, -1), details->event->AsPointerEvent()->location());
 }
 
 // TODO(moshayedi): crbug.com/590226. Enable this after we support wheel events
 // in mus event dispatcher.
 TEST_F(EventDispatcherTest, DISABLED_WheelWhileDown) {
-  scoped_ptr<ServerWindow> child1(CreateChildWindow(WindowId(1, 3)));
-  scoped_ptr<ServerWindow> child2(CreateChildWindow(WindowId(1, 4)));
+  scoped_ptr<ServerWindow> child1 = CreateChildWindow(WindowId(1, 3));
+  scoped_ptr<ServerWindow> child2 = CreateChildWindow(WindowId(1, 4));
 
   root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
   child1->SetBounds(gfx::Rect(10, 10, 20, 20));
   child2->SetBounds(gfx::Rect(50, 51, 11, 12));
 
   MouseEventTest tests[] = {
       // Send a mouse down event over child1.
       {ui::MouseEvent(ui::ET_MOUSE_PRESSED, gfx::Point(15, 15),
                       gfx::Point(15, 15), base::TimeDelta(),
                       ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON),
        child1.get(), gfx::Point(15, 15), gfx::Point(5, 5), nullptr,
        gfx::Point(), gfx::Point()},
       // Send mouse wheel over child2, should go to child1 as it has capture.
       {ui::MouseWheelEvent(gfx::Vector2d(1, 0), gfx::Point(53, 54),
                            gfx::Point(53, 54), base::TimeDelta(), ui::EF_NONE,
                            ui::EF_NONE),
        child1.get(), gfx::Point(53, 54), gfx::Point(43, 44), nullptr,
        gfx::Point(), gfx::Point()},
   };
   RunMouseEventTests(event_dispatcher(), test_event_dispatcher_delegate(),
                      tests, arraysize(tests));
 }
 
 // Tests that when explicit capture has been set that all events go to the
 // designated window, and that when capture is cleared, events find the
 // appropriate target window.
 TEST_F(EventDispatcherTest, SetExplicitCapture) {
   ServerWindow* root = root_window();
-  scoped_ptr<ServerWindow> child(CreateChildWindow(WindowId(1, 3)));
+  scoped_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
 
   root->SetBounds(gfx::Rect(0, 0, 100, 100));
   child->SetBounds(gfx::Rect(10, 10, 20, 20));
 
   TestEventDispatcherDelegate* event_dispatcher_delegate =
       test_event_dispatcher_delegate();
   EventDispatcher* dispatcher = event_dispatcher();
 
   {
     // Send all pointer events to the child.
@@ skipping 73 matching lines @@
 
     ASSERT_TRUE(details);
     ASSERT_EQ(root, details->window);
   }
 }
 
 // This test verifies that explicit capture overrides and resets implicit
 // capture.
 TEST_F(EventDispatcherTest, ExplicitCaptureOverridesImplicitCapture) {
   ServerWindow* root = root_window();
-  scoped_ptr<ServerWindow> child(CreateChildWindow(WindowId(1, 3)));
+  scoped_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
 
   root->SetBounds(gfx::Rect(0, 0, 100, 100));
   child->SetBounds(gfx::Rect(10, 10, 20, 20));
 
   TestEventDispatcherDelegate* event_dispatcher_delegate =
       test_event_dispatcher_delegate();
   EventDispatcher* dispatcher = event_dispatcher();
 
   // Run some implicit capture tests.
   MouseEventTest tests[] = {
@@ skipping 101 matching lines @@
   // Setting the capture should clear the implicit pointers for the specified
   // window.
   dispatcher->SetCaptureWindow(root, true);
   EXPECT_FALSE(AreAnyPointersDown());
   EXPECT_FALSE(IsWindowPointerTarget(root));
 }
 
 // Tests that when explicit capture is changed, that the previous window with
 // capture is no longer being observed.
 TEST_F(EventDispatcherTest, UpdatingCaptureStopsObservingPreviousCapture) {
-  scoped_ptr<ServerWindow> child1(CreateChildWindow(WindowId(1, 3)));
-  scoped_ptr<ServerWindow> child2(CreateChildWindow(WindowId(1, 4)));
+  scoped_ptr<ServerWindow> child1 = CreateChildWindow(WindowId(1, 3));
+  scoped_ptr<ServerWindow> child2 = CreateChildWindow(WindowId(1, 4));
 
   root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
   child1->SetBounds(gfx::Rect(10, 10, 20, 20));
   child2->SetBounds(gfx::Rect(50, 51, 11, 12));
 
   EventDispatcher* dispatcher = event_dispatcher();
   ASSERT_FALSE(AreAnyPointersDown());
   ASSERT_FALSE(IsWindowPointerTarget(child1.get()));
   ASSERT_FALSE(IsWindowPointerTarget(child2.get()));
   dispatcher->SetCaptureWindow(child1.get(), false);
   dispatcher->SetCaptureWindow(child2.get(), false);
   EXPECT_EQ(child1.get(),
             test_event_dispatcher_delegate()->lost_capture_window());
 
   // If observing does not stop during the capture update this crashes.
   child1->AddObserver(dispatcher);
 }
 
 // Tests that destroying a window with explicit capture clears the capture
 // state.
 TEST_F(EventDispatcherTest, DestroyingCaptureWindowRemovesExplicitCapture) {
-  scoped_ptr<ServerWindow> child(CreateChildWindow(WindowId(1, 3)));
+  scoped_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
   child->SetBounds(gfx::Rect(10, 10, 20, 20));
 
   EventDispatcher* dispatcher = event_dispatcher();
   dispatcher->SetCaptureWindow(child.get(), false);
   EXPECT_EQ(child.get(), dispatcher->capture_window());
 
   ServerWindow* lost_capture_window = child.get();
   child.reset();
   EXPECT_EQ(nullptr, dispatcher->capture_window());
   EXPECT_EQ(lost_capture_window,
@@ skipping 21 matching lines @@
 
   // Events should target child and be in the client area.
   scoped_ptr<DispatchedEventDetails> details =
       event_dispatcher_delegate->GetAndAdvanceDispatchedEventDetails();
   EXPECT_FALSE(event_dispatcher_delegate->has_queued_events());
   ASSERT_EQ(root, details->window);
   EXPECT_TRUE(details->in_nonclient_area);
 }
 
 TEST_F(EventDispatcherTest, ProcessPointerEvents) {
-  scoped_ptr<ServerWindow> child(CreateChildWindow(WindowId(1, 3)));
+  scoped_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
 
   root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
   child->SetBounds(gfx::Rect(10, 10, 20, 20));
 
   {
     const ui::PointerEvent pointer_event(ui::MouseEvent(
         ui::ET_MOUSE_PRESSED, gfx::Point(20, 25), gfx::Point(20, 25),
         base::TimeDelta(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON));
     event_dispatcher()->ProcessEvent(pointer_event);
 
@@ skipping 25 matching lines @@
     ASSERT_TRUE(details->event);
     ASSERT_TRUE(details->event->IsPointerEvent());
 
     ui::PointerEvent* dispatched_event = details->event->AsPointerEvent();
     EXPECT_EQ(gfx::Point(25, 20), dispatched_event->root_location());
     EXPECT_EQ(gfx::Point(15, 10), dispatched_event->location());
     EXPECT_EQ(touch_id, dispatched_event->pointer_id());
   }
 }
 
+// Tests that events on a modal parent target the modal child.
+TEST_F(EventDispatcherTest, ModalWindowEventOnModalParent) {
+  scoped_ptr<ServerWindow> w1 = CreateChildWindow(WindowId(1, 3));
+  scoped_ptr<ServerWindow> w2 = CreateChildWindow(WindowId(1, 5));
+
+  root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
+  w1->SetBounds(gfx::Rect(10, 10, 30, 30));
+  w2->SetBounds(gfx::Rect(50, 10, 10, 10));
+
+  w1->AddTransientWindow(w2.get());
+  w2->SetAsModal();
+
+  // Send event that is over |w1|.
+  const ui::PointerEvent mouse_pressed(ui::MouseEvent(
+      ui::ET_MOUSE_PRESSED, gfx::Point(15, 15), gfx::Point(15, 15),
+      base::TimeDelta(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON));
+  event_dispatcher()->ProcessEvent(mouse_pressed);
+
+  scoped_ptr<DispatchedEventDetails> details =
+      test_event_dispatcher_delegate()->GetAndAdvanceDispatchedEventDetails();
+  ASSERT_TRUE(details);
+  EXPECT_EQ(w2.get(), details->window);
+  EXPECT_TRUE(details->in_nonclient_area);
+
+  ASSERT_TRUE(details->event);
+  ASSERT_TRUE(details->event->IsPointerEvent());
+
+  ui::PointerEvent* dispatched_event = details->event->AsPointerEvent();
+  EXPECT_EQ(gfx::Point(15, 15), dispatched_event->root_location());
+  EXPECT_EQ(gfx::Point(-35, 5), dispatched_event->location());
+}
+
+// Tests that events on a modal child target the modal child itself.
+TEST_F(EventDispatcherTest, ModalWindowEventOnModalChild) {
+  scoped_ptr<ServerWindow> w1 = CreateChildWindow(WindowId(1, 3));
+  scoped_ptr<ServerWindow> w2 = CreateChildWindow(WindowId(1, 5));
+
+  root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
+  w1->SetBounds(gfx::Rect(10, 10, 30, 30));
+  w2->SetBounds(gfx::Rect(50, 10, 10, 10));
+
+  w1->AddTransientWindow(w2.get());
+  w2->SetAsModal();
+
+  // Send event that is over |w2|.
+  const ui::PointerEvent mouse_pressed(ui::MouseEvent(
+      ui::ET_MOUSE_PRESSED, gfx::Point(55, 15), gfx::Point(55, 15),
+      base::TimeDelta(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON));
+  event_dispatcher()->ProcessEvent(mouse_pressed);
+
+  scoped_ptr<DispatchedEventDetails> details =
+      test_event_dispatcher_delegate()->GetAndAdvanceDispatchedEventDetails();
+  ASSERT_TRUE(details);
+  EXPECT_EQ(w2.get(), details->window);
+  EXPECT_FALSE(details->in_nonclient_area);
+
+  ASSERT_TRUE(details->event);
+  ASSERT_TRUE(details->event->IsPointerEvent());
+
+  ui::PointerEvent* dispatched_event = details->event->AsPointerEvent();
+  EXPECT_EQ(gfx::Point(55, 15), dispatched_event->root_location());
+  EXPECT_EQ(gfx::Point(5, 5), dispatched_event->location());
+}
+
+// Tests that events on an unrelated window are not affected by the modal
+// window.
+TEST_F(EventDispatcherTest, ModalWindowEventOnUnrelatedWindow) {
+  scoped_ptr<ServerWindow> w1 = CreateChildWindow(WindowId(1, 3));
+  scoped_ptr<ServerWindow> w2 = CreateChildWindow(WindowId(1, 5));
+  scoped_ptr<ServerWindow> w3 = CreateChildWindow(WindowId(1, 6));
+
+  root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
+  w1->SetBounds(gfx::Rect(10, 10, 30, 30));
+  w2->SetBounds(gfx::Rect(50, 10, 10, 10));
+  w3->SetBounds(gfx::Rect(70, 10, 10, 10));
+
+  w1->AddTransientWindow(w2.get());
+  w2->SetAsModal();
+
+  // Send event that is over |w3|.
+  const ui::PointerEvent mouse_pressed(ui::MouseEvent(
+      ui::ET_MOUSE_PRESSED, gfx::Point(75, 15), gfx::Point(75, 15),
+      base::TimeDelta(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON));
+  event_dispatcher()->ProcessEvent(mouse_pressed);
+
+  scoped_ptr<DispatchedEventDetails> details =
+      test_event_dispatcher_delegate()->GetAndAdvanceDispatchedEventDetails();
+  ASSERT_TRUE(details);
+  EXPECT_EQ(w3.get(), details->window);
+  EXPECT_FALSE(details->in_nonclient_area);
+
+  ASSERT_TRUE(details->event);
+  ASSERT_TRUE(details->event->IsPointerEvent());
+
+  ui::PointerEvent* dispatched_event = details->event->AsPointerEvent();
+  EXPECT_EQ(gfx::Point(75, 15), dispatched_event->root_location());
+  EXPECT_EQ(gfx::Point(5, 5), dispatched_event->location());
+}
+
+// Tests that events events on a descendant of a modal parent target the modal
+// child.
+TEST_F(EventDispatcherTest, ModalWindowEventOnDescendantOfModalParent) {
+  scoped_ptr<ServerWindow> w1 = CreateChildWindow(WindowId(1, 3));
+  scoped_ptr<ServerWindow> w11 =
+      CreateChildWindowWithParent(WindowId(1, 4), w1.get());
+  scoped_ptr<ServerWindow> w2 = CreateChildWindow(WindowId(1, 5));
+
+  root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
+  w1->SetBounds(gfx::Rect(10, 10, 30, 30));
+  w11->SetBounds(gfx::Rect(10, 10, 10, 10));
+  w2->SetBounds(gfx::Rect(50, 10, 10, 10));
+
+  w1->AddTransientWindow(w2.get());
+  w2->SetAsModal();
+
+  // Send event that is over |w11|.
+  const ui::PointerEvent mouse_pressed(ui::MouseEvent(
+      ui::ET_MOUSE_PRESSED, gfx::Point(25, 25), gfx::Point(25, 25),
+      base::TimeDelta(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON));
+  event_dispatcher()->ProcessEvent(mouse_pressed);
+
+  scoped_ptr<DispatchedEventDetails> details =
+      test_event_dispatcher_delegate()->GetAndAdvanceDispatchedEventDetails();
+  ASSERT_TRUE(details);
+  EXPECT_EQ(w2.get(), details->window);
+  EXPECT_TRUE(details->in_nonclient_area);
+
+  ASSERT_TRUE(details->event);
+  ASSERT_TRUE(details->event->IsPointerEvent());
+
+  ui::PointerEvent* dispatched_event = details->event->AsPointerEvent();
+  EXPECT_EQ(gfx::Point(25, 25), dispatched_event->root_location());
+  EXPECT_EQ(gfx::Point(-25, 15), dispatched_event->location());
+}
+
+// Tests that setting capture to a descendant of a modal parent fails.
+TEST_F(EventDispatcherTest, ModalWindowSetCaptureDescendantOfModalParent) {
+  scoped_ptr<ServerWindow> w1 = CreateChildWindow(WindowId(1, 3));
+  scoped_ptr<ServerWindow> w11 =
+      CreateChildWindowWithParent(WindowId(1, 4), w1.get());
+  scoped_ptr<ServerWindow> w2 = CreateChildWindow(WindowId(1, 5));
+
+  root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
+  w1->SetBounds(gfx::Rect(10, 10, 30, 30));
+  w11->SetBounds(gfx::Rect(10, 10, 10, 10));
+  w2->SetBounds(gfx::Rect(50, 10, 10, 10));
+
+  w1->AddTransientWindow(w2.get());
+  w2->SetAsModal();
+
+  EXPECT_FALSE(event_dispatcher()->SetCaptureWindow(w11.get(), false));
+  EXPECT_EQ(nullptr, event_dispatcher()->capture_window());
+}
+
+// Tests that setting capture to a window unrelated to a modal parent works.
+TEST_F(EventDispatcherTest, ModalWindowSetCaptureUnrelatedWindow) {
+  scoped_ptr<ServerWindow> w1 = CreateChildWindow(WindowId(1, 3));
+  scoped_ptr<ServerWindow> w2 = CreateChildWindow(WindowId(1, 5));
+  scoped_ptr<ServerWindow> w3 = CreateChildWindow(WindowId(1, 6));
+
+  root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
+  w1->SetBounds(gfx::Rect(10, 10, 30, 30));
+  w2->SetBounds(gfx::Rect(50, 10, 10, 10));
+  w3->SetBounds(gfx::Rect(70, 10, 10, 10));
+
+  w1->AddTransientWindow(w2.get());
+  w2->SetAsModal();
+
+  EXPECT_TRUE(event_dispatcher()->SetCaptureWindow(w3.get(), false));
+  EXPECT_EQ(w3.get(), event_dispatcher()->capture_window());
+}
+
 }  // namespace ws
 }  // namespace mus