WIP: Surface Synchronization System

services/ui/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 "services/ui/ws/event_dispatcher.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <queue>
@@ skipping 319 matching lines @@
   test_event_dispatcher_delegate_ =
       base::MakeUnique<TestEventDispatcherDelegate>(this);
   event_dispatcher_ =
       base::MakeUnique<EventDispatcher>(test_event_dispatcher_delegate_.get());
   test_event_dispatcher_delegate_->set_root(root_window_.get());
 }
 
 TEST_F(EventDispatcherTest, ProcessEvent) {
   std::unique_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
 
-  root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
-  child->SetBounds(gfx::Rect(10, 10, 20, 20));
+  root_window()->SetBounds(gfx::Rect(0, 0, 100, 100), cc::LocalFrameId());
+  child->SetBounds(gfx::Rect(10, 10, 20, 20), cc::LocalFrameId());
 
   // 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::TimeTicks(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON));
   event_dispatcher()->ProcessEvent(ui_event,
                                    EventDispatcher::AcceleratorMatchPhase::ANY);
 
   std::unique_ptr<DispatchedEventDetails> details =
       test_event_dispatcher_delegate()->GetAndAdvanceDispatchedEventDetails();
@@ skipping 191 matching lines @@
       event_dispatcher_delegate->GetAndAdvanceDispatchedEventDetails();
   ASSERT_TRUE(details);
   ASSERT_TRUE(details->accelerator);
   EXPECT_EQ(post_id, details->accelerator->id());
 }
 
 TEST_F(EventDispatcherTest, Capture) {
   ServerWindow* root = root_window();
   std::unique_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
 
-  root->SetBounds(gfx::Rect(0, 0, 100, 100));
-  child->SetBounds(gfx::Rect(10, 10, 20, 20));
+  root->SetBounds(gfx::Rect(0, 0, 100, 100), cc::LocalFrameId());
+  child->SetBounds(gfx::Rect(10, 10, 20, 20), cc::LocalFrameId());
 
   MouseEventTest tests[] = {
       // Send a mouse down event over child.
       {ui::MouseEvent(ui::ET_MOUSE_PRESSED, gfx::Point(20, 25),
                       gfx::Point(20, 25), base::TimeTicks(),
                       ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON),
        child.get(), gfx::Point(20, 25), gfx::Point(10, 15), nullptr,
        gfx::Point(), gfx::Point()},
 
       // Capture should be activated. Let's send a mouse move outside the bounds
@@ skipping 20 matching lines @@
        gfx::Point(50, 50), gfx::Point(50, 50)},
 
   };
   RunMouseEventTests(event_dispatcher(), test_event_dispatcher_delegate(),
                      tests, arraysize(tests));
 }
 
 TEST_F(EventDispatcherTest, CaptureMultipleMouseButtons) {
   std::unique_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
 
-  root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
-  child->SetBounds(gfx::Rect(10, 10, 20, 20));
+  root_window()->SetBounds(gfx::Rect(0, 0, 100, 100), cc::LocalFrameId());
+  child->SetBounds(gfx::Rect(10, 10, 20, 20), cc::LocalFrameId());
 
   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::TimeTicks(),
                       ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON),
        child.get(), gfx::Point(20, 25), gfx::Point(10, 15), nullptr,
        gfx::Point(), gfx::Point()},
 
       // Capture should be activated. Let's send a mouse move outside the bounds
@@ skipping 21 matching lines @@
        gfx::Point(), gfx::Point()},
 
   };
   RunMouseEventTests(event_dispatcher(), test_event_dispatcher_delegate(),
                      tests, arraysize(tests));
 }
 
 TEST_F(EventDispatcherTest, ClientAreaGoesToOwner) {
   std::unique_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
 
-  root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
-  child->SetBounds(gfx::Rect(10, 10, 20, 20));
+  root_window()->SetBounds(gfx::Rect(0, 0, 100, 100), cc::LocalFrameId());
+  child->SetBounds(gfx::Rect(10, 10, 20, 20), cc::LocalFrameId());
 
   child->SetClientArea(gfx::Insets(5, 5, 5, 5), std::vector<gfx::Rect>());
 
   TestEventDispatcherDelegate* event_dispatcher_delegate =
       test_event_dispatcher_delegate();
   EventDispatcher* dispatcher = event_dispatcher();
 
   // Start move loop by sending mouse event over non-client area.
   const ui::PointerEvent press_event(ui::MouseEvent(
       ui::ET_MOUSE_PRESSED, gfx::Point(12, 12), gfx::Point(12, 12),
@@ skipping 51 matching lines @@
   details = event_dispatcher_delegate->GetAndAdvanceDispatchedEventDetails();
   EXPECT_FALSE(event_dispatcher_delegate->has_queued_events());
   ASSERT_EQ(child.get(), details->window);
   EXPECT_TRUE(details->IsClientArea());
   EXPECT_EQ(ui::ET_POINTER_DOWN, details->event->type());
 }
 
 TEST_F(EventDispatcherTest, AdditionalClientArea) {
   std::unique_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
 
-  root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
-  child->SetBounds(gfx::Rect(10, 10, 20, 20));
+  root_window()->SetBounds(gfx::Rect(0, 0, 100, 100), cc::LocalFrameId());
+  child->SetBounds(gfx::Rect(10, 10, 20, 20), cc::LocalFrameId());
 
   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::TimeTicks(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON));
   event_dispatcher()->ProcessEvent(press_event,
                                    EventDispatcher::AcceleratorMatchPhase::ANY);
 
   // Events should target child and be in the client area.
   std::unique_ptr<DispatchedEventDetails> details =
       event_dispatcher_delegate->GetAndAdvanceDispatchedEventDetails();
   EXPECT_FALSE(event_dispatcher_delegate->has_queued_events());
   ASSERT_EQ(child.get(), details->window);
   EXPECT_TRUE(details->IsClientArea());
 }
 
 TEST_F(EventDispatcherTest, HitTestMask) {
   std::unique_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
 
-  root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
-  child->SetBounds(gfx::Rect(10, 10, 20, 20));
+  root_window()->SetBounds(gfx::Rect(0, 0, 100, 100), cc::LocalFrameId());
+  child->SetBounds(gfx::Rect(10, 10, 20, 20), cc::LocalFrameId());
   child->SetHitTestMask(gfx::Rect(2, 2, 16, 16));
 
   // Move in the masked area.
   const ui::PointerEvent move1(ui::MouseEvent(
       ui::ET_MOUSE_MOVED, gfx::Point(11, 11), gfx::Point(11, 11),
       base::TimeTicks(), ui::EF_LEFT_MOUSE_BUTTON, 0));
   event_dispatcher()->ProcessEvent(move1,
                                    EventDispatcher::AcceleratorMatchPhase::ANY);
 
   // Event went through the child window and hit the root.
@@ skipping 20 matching lines @@
   std::unique_ptr<DispatchedEventDetails> details3 =
       test_event_dispatcher_delegate()->GetAndAdvanceDispatchedEventDetails();
   EXPECT_EQ(child.get(), details3->window);
   EXPECT_TRUE(details3->IsClientArea());
 }
 
 TEST_F(EventDispatcherTest, DontFocusOnSecondDown) {
   std::unique_ptr<ServerWindow> child1 = CreateChildWindow(WindowId(1, 3));
   std::unique_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));
+  root_window()->SetBounds(gfx::Rect(0, 0, 100, 100), cc::LocalFrameId());
+  child1->SetBounds(gfx::Rect(10, 10, 20, 20), cc::LocalFrameId());
+  child2->SetBounds(gfx::Rect(50, 51, 11, 12), cc::LocalFrameId());
 
   TestEventDispatcherDelegate* event_dispatcher_delegate =
       test_event_dispatcher_delegate();
   EventDispatcher* dispatcher = event_dispatcher();
 
   // Press on child1. First press event should change focus.
   const ui::PointerEvent press_event(ui::MouseEvent(
       ui::ET_MOUSE_PRESSED, gfx::Point(12, 12), gfx::Point(12, 12),
       base::TimeTicks(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON));
   dispatcher->ProcessEvent(press_event,
@@ skipping 14 matching lines @@
   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) {
   std::unique_ptr<ServerWindow> child1 = CreateChildWindow(WindowId(1, 3));
   std::unique_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));
+  root_window()->SetBounds(gfx::Rect(0, 0, 100, 100), cc::LocalFrameId());
+  child1->SetBounds(gfx::Rect(10, 10, 20, 20), cc::LocalFrameId());
+  child2->SetBounds(gfx::Rect(50, 51, 11, 12), cc::LocalFrameId());
 
   TestEventDispatcherDelegate* event_dispatcher_delegate =
       test_event_dispatcher_delegate();
   EventDispatcher* dispatcher = event_dispatcher();
 
   // Press on child1.
   const ui::PointerEvent touch_event1(ui::TouchEvent(
       ui::ET_TOUCH_PRESSED, gfx::Point(12, 13), 1, base::TimeTicks()));
   dispatcher->ProcessEvent(touch_event1,
                            EventDispatcher::AcceleratorMatchPhase::ANY);
@@ skipping 42 matching lines @@
       ui::ET_TOUCH_PRESSED, gfx::Point(54, 55), 2, base::TimeTicks()));
   dispatcher->ProcessEvent(touch_event3,
                            EventDispatcher::AcceleratorMatchPhase::ANY);
   details = event_dispatcher_delegate->GetAndAdvanceDispatchedEventDetails();
   EXPECT_EQ(child2.get(), details->window);
 }
 
 TEST_F(EventDispatcherTest, DestroyWindowWhileGettingEvents) {
   std::unique_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
 
-  root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
-  child->SetBounds(gfx::Rect(10, 10, 20, 20));
+  root_window()->SetBounds(gfx::Rect(0, 0, 100, 100), cc::LocalFrameId());
+  child->SetBounds(gfx::Rect(10, 10, 20, 20), cc::LocalFrameId());
 
   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::TimeTicks()));
   dispatcher->ProcessEvent(touch_event1,
                            EventDispatcher::AcceleratorMatchPhase::ANY);
@@ skipping 10 matching lines @@
   dispatcher->ProcessEvent(drag_event1,
                            EventDispatcher::AcceleratorMatchPhase::ANY);
   details = event_dispatcher_delegate->GetAndAdvanceDispatchedEventDetails();
   EXPECT_EQ(nullptr, details.get());
 }
 
 TEST_F(EventDispatcherTest, MouseInExtendedHitTestRegion) {
   ServerWindow* root = root_window();
   std::unique_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
 
-  root->SetBounds(gfx::Rect(0, 0, 100, 100));
-  child->SetBounds(gfx::Rect(10, 10, 20, 20));
+  root->SetBounds(gfx::Rect(0, 0, 100, 100), cc::LocalFrameId());
+  child->SetBounds(gfx::Rect(10, 10, 20, 20), cc::LocalFrameId());
 
   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(
       ui::ET_MOUSE_PRESSED, gfx::Point(8, 9), gfx::Point(8, 9),
       base::TimeTicks(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON));
   dispatcher->ProcessEvent(ui_event,
@@ skipping 30 matching lines @@
   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());
 }
 
 TEST_F(EventDispatcherTest, WheelWhileDown) {
   std::unique_ptr<ServerWindow> child1 = CreateChildWindow(WindowId(1, 3));
   std::unique_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));
+  root_window()->SetBounds(gfx::Rect(0, 0, 100, 100), cc::LocalFrameId());
+  child1->SetBounds(gfx::Rect(10, 10, 20, 20), cc::LocalFrameId());
+  child2->SetBounds(gfx::Rect(50, 51, 11, 12), cc::LocalFrameId());
 
   MouseEventTest tests[] = {
       // Send a mouse down event over child1.
       {ui::MouseEvent(ui::ET_MOUSE_PRESSED, gfx::Point(15, 15),
                       gfx::Point(15, 15), base::TimeTicks(),
                       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::TimeTicks(), 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();
   std::unique_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
 
-  root->SetBounds(gfx::Rect(0, 0, 100, 100));
-  child->SetBounds(gfx::Rect(10, 10, 20, 20));
+  root->SetBounds(gfx::Rect(0, 0, 100, 100), cc::LocalFrameId());
+  child->SetBounds(gfx::Rect(10, 10, 20, 20), cc::LocalFrameId());
 
   TestEventDispatcherDelegate* event_dispatcher_delegate =
       test_event_dispatcher_delegate();
   EventDispatcher* dispatcher = event_dispatcher();
 
   {
     // Send all pointer events to the child.
     dispatcher->SetCaptureWindow(child.get(), kClientAreaId);
 
     // The mouse press should go to the child even though its outside its
@@ skipping 79 matching lines @@
     ASSERT_EQ(root, details->window);
   }
 }
 
 // This test verifies that explicit capture overrides and resets implicit
 // capture.
 TEST_F(EventDispatcherTest, ExplicitCaptureOverridesImplicitCapture) {
   ServerWindow* root = root_window();
   std::unique_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
 
-  root->SetBounds(gfx::Rect(0, 0, 100, 100));
-  child->SetBounds(gfx::Rect(10, 10, 20, 20));
+  root->SetBounds(gfx::Rect(0, 0, 100, 100), cc::LocalFrameId());
+  child->SetBounds(gfx::Rect(10, 10, 20, 20), cc::LocalFrameId());
 
   TestEventDispatcherDelegate* event_dispatcher_delegate =
       test_event_dispatcher_delegate();
   EventDispatcher* dispatcher = event_dispatcher();
 
   // Run some implicit capture tests.
   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::TimeTicks(),
@@ skipping 66 matching lines @@
   details = event_dispatcher_delegate->GetAndAdvanceDispatchedEventDetails();
   ASSERT_TRUE(details);
   ASSERT_EQ(root, details->window);
   ASSERT_TRUE(details->IsNonclientArea());
 }
 
 // Tests that setting capture does delete active pointer targets for the capture
 // window.
 TEST_F(EventDispatcherTest, CaptureUpdatesActivePointerTargets) {
   ServerWindow* root = root_window();
-  root->SetBounds(gfx::Rect(0, 0, 100, 100));
+  root->SetBounds(gfx::Rect(0, 0, 100, 100), cc::LocalFrameId());
 
   EventDispatcher* dispatcher = event_dispatcher();
   {
     const ui::PointerEvent press_event(ui::MouseEvent(
         ui::ET_MOUSE_PRESSED, gfx::Point(5, 5), gfx::Point(5, 5),
         base::TimeTicks(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON));
     dispatcher->ProcessEvent(press_event,
                              EventDispatcher::AcceleratorMatchPhase::ANY);
 
     std::unique_ptr<DispatchedEventDetails> details =
@@ skipping 18 matching lines @@
   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) {
   std::unique_ptr<ServerWindow> child1 = CreateChildWindow(WindowId(1, 3));
   std::unique_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));
+  root_window()->SetBounds(gfx::Rect(0, 0, 100, 100), cc::LocalFrameId());
+  child1->SetBounds(gfx::Rect(10, 10, 20, 20), cc::LocalFrameId());
+  child2->SetBounds(gfx::Rect(50, 51, 11, 12), cc::LocalFrameId());
 
   EventDispatcher* dispatcher = event_dispatcher();
   ASSERT_FALSE(AreAnyPointersDown());
   ASSERT_FALSE(IsWindowPointerTarget(child1.get()));
   ASSERT_FALSE(IsWindowPointerTarget(child2.get()));
   dispatcher->SetCaptureWindow(child1.get(), kClientAreaId);
   dispatcher->SetCaptureWindow(child2.get(), kClientAreaId);
   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) {
   std::unique_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
-  child->SetBounds(gfx::Rect(10, 10, 20, 20));
+  child->SetBounds(gfx::Rect(10, 10, 20, 20), cc::LocalFrameId());
 
   EventDispatcher* dispatcher = event_dispatcher();
   dispatcher->SetCaptureWindow(child.get(), kClientAreaId);
   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,
             test_event_dispatcher_delegate()->lost_capture_window());
 }
 
 // Tests that when |client_id| is set for a window performing capture, that this
 // preference is used regardless of whether an event targets the client region.
 TEST_F(EventDispatcherTest, CaptureInNonClientAreaOverridesActualPoint) {
   ServerWindow* root = root_window();
-  root->SetBounds(gfx::Rect(0, 0, 100, 100));
+  root->SetBounds(gfx::Rect(0, 0, 100, 100), cc::LocalFrameId());
 
   root->SetClientArea(gfx::Insets(5, 5, 5, 5), std::vector<gfx::Rect>());
   EventDispatcher* dispatcher = event_dispatcher();
   dispatcher->SetCaptureWindow(root, kNonclientAreaId);
 
   TestEventDispatcherDelegate* event_dispatcher_delegate =
       test_event_dispatcher_delegate();
   // Press in the client area, it should be marked as non client.
   const ui::PointerEvent press_event(ui::MouseEvent(
       ui::ET_MOUSE_PRESSED, gfx::Point(6, 6), gfx::Point(6, 6),
       base::TimeTicks(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON));
   event_dispatcher()->ProcessEvent(press_event,
                                    EventDispatcher::AcceleratorMatchPhase::ANY);
 
   // Events should target child and be in the client area.
   std::unique_ptr<DispatchedEventDetails> details =
       event_dispatcher_delegate->GetAndAdvanceDispatchedEventDetails();
   EXPECT_FALSE(event_dispatcher_delegate->has_queued_events());
   ASSERT_EQ(root, details->window);
   EXPECT_TRUE(details->IsNonclientArea());
 }
 
 TEST_F(EventDispatcherTest, ProcessPointerEvents) {
   std::unique_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
 
-  root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
-  child->SetBounds(gfx::Rect(10, 10, 20, 20));
+  root_window()->SetBounds(gfx::Rect(0, 0, 100, 100), cc::LocalFrameId());
+  child->SetBounds(gfx::Rect(10, 10, 20, 20), cc::LocalFrameId());
 
   {
     const ui::PointerEvent pointer_event(ui::MouseEvent(
         ui::ET_MOUSE_PRESSED, gfx::Point(20, 25), gfx::Point(20, 25),
         base::TimeTicks(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON));
     event_dispatcher()->ProcessEvent(
         pointer_event, EventDispatcher::AcceleratorMatchPhase::ANY);
 
     std::unique_ptr<DispatchedEventDetails> details =
         test_event_dispatcher_delegate()->GetAndAdvanceDispatchedEventDetails();
@@ skipping 27 matching lines @@
     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());
   }
 }
 
 TEST_F(EventDispatcherTest, ResetClearsPointerDown) {
   std::unique_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
 
-  root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
-  child->SetBounds(gfx::Rect(10, 10, 20, 20));
+  root_window()->SetBounds(gfx::Rect(0, 0, 100, 100), cc::LocalFrameId());
+  child->SetBounds(gfx::Rect(10, 10, 20, 20), cc::LocalFrameId());
 
   // 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::TimeTicks(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON));
   event_dispatcher()->ProcessEvent(ui_event,
                                    EventDispatcher::AcceleratorMatchPhase::ANY);
 
   std::unique_ptr<DispatchedEventDetails> details =
       test_event_dispatcher_delegate()->GetAndAdvanceDispatchedEventDetails();
   ASSERT_TRUE(details);
   ASSERT_EQ(child.get(), details->window);
 
   EXPECT_TRUE(AreAnyPointersDown());
 
   event_dispatcher()->Reset();
   EXPECT_FALSE(test_event_dispatcher_delegate()->has_queued_events());
   EXPECT_FALSE(AreAnyPointersDown());
 }
 
 TEST_F(EventDispatcherTest, ResetClearsCapture) {
   ServerWindow* root = root_window();
-  root->SetBounds(gfx::Rect(0, 0, 100, 100));
+  root->SetBounds(gfx::Rect(0, 0, 100, 100), cc::LocalFrameId());
 
   root->SetClientArea(gfx::Insets(5, 5, 5, 5), std::vector<gfx::Rect>());
   EventDispatcher* dispatcher = event_dispatcher();
   dispatcher->SetCaptureWindow(root, kNonclientAreaId);
 
   event_dispatcher()->Reset();
   EXPECT_FALSE(test_event_dispatcher_delegate()->has_queued_events());
   EXPECT_EQ(nullptr, event_dispatcher()->capture_window());
 }
 
 // Tests that events on a modal parent target the modal child.
 TEST_F(EventDispatcherTest, ModalWindowEventOnModalParent) {
   std::unique_ptr<ServerWindow> w1 = CreateChildWindow(WindowId(1, 3));
   std::unique_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));
+  root_window()->SetBounds(gfx::Rect(0, 0, 100, 100), cc::LocalFrameId());
+  w1->SetBounds(gfx::Rect(10, 10, 30, 30), cc::LocalFrameId());
+  w2->SetBounds(gfx::Rect(50, 10, 10, 10), cc::LocalFrameId());
 
   w1->AddTransientWindow(w2.get());
   w2->SetModal();
 
   // 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::TimeTicks(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON));
   event_dispatcher()->ProcessEvent(mouse_pressed,
                                    EventDispatcher::AcceleratorMatchPhase::ANY);
@@ skipping 10 matching lines @@
   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) {
   std::unique_ptr<ServerWindow> w1 = CreateChildWindow(WindowId(1, 3));
   std::unique_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));
+  root_window()->SetBounds(gfx::Rect(0, 0, 100, 100), cc::LocalFrameId());
+  w1->SetBounds(gfx::Rect(10, 10, 30, 30), cc::LocalFrameId());
+  w2->SetBounds(gfx::Rect(50, 10, 10, 10), cc::LocalFrameId());
 
   w1->AddTransientWindow(w2.get());
   w2->SetModal();
 
   // 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::TimeTicks(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON));
   event_dispatcher()->ProcessEvent(mouse_pressed,
                                    EventDispatcher::AcceleratorMatchPhase::ANY);
@@ skipping 12 matching lines @@
   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) {
   std::unique_ptr<ServerWindow> w1 = CreateChildWindow(WindowId(1, 3));
   std::unique_ptr<ServerWindow> w2 = CreateChildWindow(WindowId(1, 5));
   std::unique_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));
+  root_window()->SetBounds(gfx::Rect(0, 0, 100, 100), cc::LocalFrameId());
+  w1->SetBounds(gfx::Rect(10, 10, 30, 30), cc::LocalFrameId());
+  w2->SetBounds(gfx::Rect(50, 10, 10, 10), cc::LocalFrameId());
+  w3->SetBounds(gfx::Rect(70, 10, 10, 10), cc::LocalFrameId());
 
   w1->AddTransientWindow(w2.get());
   w2->SetModal();
 
   // 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::TimeTicks(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON));
   event_dispatcher()->ProcessEvent(mouse_pressed,
                                    EventDispatcher::AcceleratorMatchPhase::ANY);
@@ skipping 13 matching lines @@
 }
 
 // Tests that events events on a descendant of a modal parent target the modal
 // child.
 TEST_F(EventDispatcherTest, ModalWindowEventOnDescendantOfModalParent) {
   std::unique_ptr<ServerWindow> w1 = CreateChildWindow(WindowId(1, 3));
   std::unique_ptr<ServerWindow> w11 =
       CreateChildWindowWithParent(WindowId(1, 4), w1.get());
   std::unique_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));
+  root_window()->SetBounds(gfx::Rect(0, 0, 100, 100), cc::LocalFrameId());
+  w1->SetBounds(gfx::Rect(10, 10, 30, 30), cc::LocalFrameId());
+  w11->SetBounds(gfx::Rect(10, 10, 10, 10), cc::LocalFrameId());
+  w2->SetBounds(gfx::Rect(50, 10, 10, 10), cc::LocalFrameId());
 
   w1->AddTransientWindow(w2.get());
   w2->SetModal();
 
   // 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::TimeTicks(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON));
   event_dispatcher()->ProcessEvent(mouse_pressed,
                                    EventDispatcher::AcceleratorMatchPhase::ANY);
 
   std::unique_ptr<DispatchedEventDetails> details =
       test_event_dispatcher_delegate()->GetAndAdvanceDispatchedEventDetails();
   ASSERT_TRUE(details);
   EXPECT_EQ(w2.get(), details->window);
   EXPECT_TRUE(details->IsNonclientArea());
 
   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 events on a system modal window target the modal window itself.
 TEST_F(EventDispatcherTest, ModalWindowEventOnSystemModal) {
   std::unique_ptr<ServerWindow> w1 = CreateChildWindow(WindowId(1, 3));
 
-  root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
-  w1->SetBounds(gfx::Rect(10, 10, 30, 30));
+  root_window()->SetBounds(gfx::Rect(0, 0, 100, 100), cc::LocalFrameId());
+  w1->SetBounds(gfx::Rect(10, 10, 30, 30), cc::LocalFrameId());
   w1->SetModal();
 
   // 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::TimeTicks(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON));
   event_dispatcher()->ProcessEvent(mouse_pressed,
                                    EventDispatcher::AcceleratorMatchPhase::ANY);
 
   std::unique_ptr<DispatchedEventDetails> details =
       test_event_dispatcher_delegate()->GetAndAdvanceDispatchedEventDetails();
   ASSERT_TRUE(details);
   EXPECT_EQ(w1.get(), details->window);
   EXPECT_TRUE(details->IsClientArea());
 
   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(5, 5), dispatched_event->location());
 }
 
 // Tests that events outside of system modal window target the modal window.
 TEST_F(EventDispatcherTest, ModalWindowEventOutsideSystemModal) {
   std::unique_ptr<ServerWindow> w1 = CreateChildWindow(WindowId(1, 3));
 
-  root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
-  w1->SetBounds(gfx::Rect(10, 10, 30, 30));
+  root_window()->SetBounds(gfx::Rect(0, 0, 100, 100), cc::LocalFrameId());
+  w1->SetBounds(gfx::Rect(10, 10, 30, 30), cc::LocalFrameId());
   w1->SetModal();
   event_dispatcher()->AddSystemModalWindow(w1.get());
 
   // Send event that is over |w1|.
   const ui::PointerEvent mouse_pressed(ui::MouseEvent(
       ui::ET_MOUSE_PRESSED, gfx::Point(45, 15), gfx::Point(45, 15),
       base::TimeTicks(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON));
   event_dispatcher()->ProcessEvent(mouse_pressed,
                                    EventDispatcher::AcceleratorMatchPhase::ANY);
 
@@ skipping 11 matching lines @@
   EXPECT_EQ(gfx::Point(35, 5), dispatched_event->location());
 }
 
 // Tests that setting capture to a descendant of a modal parent fails.
 TEST_F(EventDispatcherTest, ModalWindowSetCaptureDescendantOfModalParent) {
   std::unique_ptr<ServerWindow> w1 = CreateChildWindow(WindowId(1, 3));
   std::unique_ptr<ServerWindow> w11 =
       CreateChildWindowWithParent(WindowId(1, 4), w1.get());
   std::unique_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));
+  root_window()->SetBounds(gfx::Rect(0, 0, 100, 100), cc::LocalFrameId());
+  w1->SetBounds(gfx::Rect(10, 10, 30, 30), cc::LocalFrameId());
+  w11->SetBounds(gfx::Rect(10, 10, 10, 10), cc::LocalFrameId());
+  w2->SetBounds(gfx::Rect(50, 10, 10, 10), cc::LocalFrameId());
 
   w1->AddTransientWindow(w2.get());
   w2->SetModal();
 
   EXPECT_FALSE(event_dispatcher()->SetCaptureWindow(w11.get(), kClientAreaId));
   EXPECT_EQ(nullptr, event_dispatcher()->capture_window());
 }
 
 // Tests that setting capture to a window unrelated to a modal parent works.
 TEST_F(EventDispatcherTest, ModalWindowSetCaptureUnrelatedWindow) {
   std::unique_ptr<ServerWindow> w1 = CreateChildWindow(WindowId(1, 3));
   std::unique_ptr<ServerWindow> w2 = CreateChildWindow(WindowId(1, 4));
   std::unique_ptr<ServerWindow> w3 = 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));
-  w3->SetBounds(gfx::Rect(70, 10, 10, 10));
+  root_window()->SetBounds(gfx::Rect(0, 0, 100, 100), cc::LocalFrameId());
+  w1->SetBounds(gfx::Rect(10, 10, 30, 30), cc::LocalFrameId());
+  w2->SetBounds(gfx::Rect(50, 10, 10, 10), cc::LocalFrameId());
+  w3->SetBounds(gfx::Rect(70, 10, 10, 10), cc::LocalFrameId());
 
   w1->AddTransientWindow(w2.get());
   w2->SetModal();
 
   EXPECT_TRUE(event_dispatcher()->SetCaptureWindow(w3.get(), kClientAreaId));
   EXPECT_EQ(w3.get(), event_dispatcher()->capture_window());
 }
 
 // Tests that setting capture fails when there is a system modal window.
 TEST_F(EventDispatcherTest, ModalWindowSystemSetCapture) {
   std::unique_ptr<ServerWindow> w1 = CreateChildWindow(WindowId(1, 3));
   std::unique_ptr<ServerWindow> w2 = CreateChildWindow(WindowId(1, 4));
 
-  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));
+  root_window()->SetBounds(gfx::Rect(0, 0, 100, 100), cc::LocalFrameId());
+  w1->SetBounds(gfx::Rect(10, 10, 30, 30), cc::LocalFrameId());
+  w2->SetBounds(gfx::Rect(50, 10, 10, 10), cc::LocalFrameId());
 
   event_dispatcher()->AddSystemModalWindow(w2.get());
 
   EXPECT_FALSE(event_dispatcher()->SetCaptureWindow(w1.get(), kClientAreaId));
   EXPECT_EQ(nullptr, event_dispatcher()->capture_window());
 }
 
 // Tests having multiple system modal windows.
 TEST_F(EventDispatcherTest, ModalWindowMultipleSystemModals) {
   std::unique_ptr<ServerWindow> w1 = CreateChildWindow(WindowId(1, 3));
@@ skipping 38 matching lines @@
 }
 
 TEST_F(EventDispatcherTest, CaptureNotResetOnParentChange) {
   std::unique_ptr<ServerWindow> w1 = CreateChildWindow(WindowId(1, 3));
   DisableHitTest(w1.get());
   std::unique_ptr<ServerWindow> w11 =
       CreateChildWindowWithParent(WindowId(1, 4), w1.get());
   std::unique_ptr<ServerWindow> w2 = CreateChildWindow(WindowId(1, 5));
   DisableHitTest(w2.get());
 
-  root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
-  w1->SetBounds(gfx::Rect(0, 0, 100, 100));
-  w11->SetBounds(gfx::Rect(10, 10, 10, 10));
-  w2->SetBounds(gfx::Rect(0, 0, 100, 100));
+  root_window()->SetBounds(gfx::Rect(0, 0, 100, 100), cc::LocalFrameId());
+  w1->SetBounds(gfx::Rect(0, 0, 100, 100), cc::LocalFrameId());
+  w11->SetBounds(gfx::Rect(10, 10, 10, 10), cc::LocalFrameId());
+  w2->SetBounds(gfx::Rect(0, 0, 100, 100), cc::LocalFrameId());
 
   // Send event that is over |w11|.
   const ui::PointerEvent mouse_pressed(ui::MouseEvent(
       ui::ET_MOUSE_PRESSED, gfx::Point(15, 15), gfx::Point(15, 15),
       base::TimeTicks(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON));
   event_dispatcher()->ProcessEvent(mouse_pressed,
                                    EventDispatcher::AcceleratorMatchPhase::ANY);
   event_dispatcher()->SetCaptureWindow(w11.get(), kClientAreaId);
 
   std::unique_ptr<DispatchedEventDetails> details =
@@ skipping 23 matching lines @@
             test_event_dispatcher_delegate()->lost_capture_window());
   EXPECT_EQ(child.get(), event_dispatcher()->capture_window());
   EXPECT_EQ(kClientAreaId, event_dispatcher()->capture_window_client_id());
 }
 
 TEST_F(EventDispatcherTest, MoveMouseFromNoTargetToValidTarget) {
   ServerWindow* root = root_window();
   DisableHitTest(root);
   std::unique_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
 
-  root->SetBounds(gfx::Rect(0, 0, 100, 100));
-  child->SetBounds(gfx::Rect(10, 10, 20, 20));
+  root->SetBounds(gfx::Rect(0, 0, 100, 100), cc::LocalFrameId());
+  child->SetBounds(gfx::Rect(10, 10, 20, 20), cc::LocalFrameId());
 
   MouseEventTest tests[] = {
       // Send a mouse down over the root, but not the child. No event should
       // be generated.
       {ui::MouseEvent(ui::ET_MOUSE_MOVED, gfx::Point(5, 5), gfx::Point(5, 5),
                       base::TimeTicks(), 0, 0),
        nullptr, gfx::Point(), gfx::Point(), nullptr, gfx::Point(),
        gfx::Point()},
 
       // Move into child.
       {ui::MouseEvent(ui::ET_MOUSE_MOVED, gfx::Point(12, 12),
                       gfx::Point(12, 12), base::TimeTicks(), 0, 0),
        child.get(), gfx::Point(12, 12), gfx::Point(2, 2), nullptr, gfx::Point(),
        gfx::Point()}};
   RunMouseEventTests(event_dispatcher(), test_event_dispatcher_delegate(),
                      tests, arraysize(tests));
 }
 
 TEST_F(EventDispatcherTest, NoTargetToTargetWithMouseDown) {
   ServerWindow* root = root_window();
   DisableHitTest(root);
   std::unique_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
 
-  root->SetBounds(gfx::Rect(0, 0, 100, 100));
-  child->SetBounds(gfx::Rect(10, 10, 20, 20));
+  root->SetBounds(gfx::Rect(0, 0, 100, 100), cc::LocalFrameId());
+  child->SetBounds(gfx::Rect(10, 10, 20, 20), cc::LocalFrameId());
 
   MouseEventTest tests[] = {
       // Mouse over the root, but not the child. No event should be generated.
       {ui::MouseEvent(ui::ET_MOUSE_MOVED, gfx::Point(5, 5), gfx::Point(5, 5),
                       base::TimeTicks(), 0, 0),
        nullptr, gfx::Point(), gfx::Point(), nullptr, gfx::Point(),
        gfx::Point()},
 
       // Press in same location, still no target.
       {ui::MouseEvent(ui::ET_MOUSE_PRESSED, gfx::Point(5, 5), gfx::Point(5, 5),
@@ skipping 11 matching lines @@
   RunMouseEventTests(event_dispatcher(), test_event_dispatcher_delegate(),
                      tests, arraysize(tests));
 }
 
 TEST_F(EventDispatcherTest, DontSendExitToSameClientWhenCaptureChanges) {
   ServerWindow* root = root_window();
   DisableHitTest(root);
   std::unique_ptr<ServerWindow> c1 = CreateChildWindow(WindowId(1, 3));
   std::unique_ptr<ServerWindow> c2 = CreateChildWindow(WindowId(1, 4));
 
-  root->SetBounds(gfx::Rect(0, 0, 100, 100));
-  c1->SetBounds(gfx::Rect(10, 10, 20, 20));
-  c2->SetBounds(gfx::Rect(15, 15, 20, 20));
+  root->SetBounds(gfx::Rect(0, 0, 100, 100), cc::LocalFrameId());
+  c1->SetBounds(gfx::Rect(10, 10, 20, 20), cc::LocalFrameId());
+  c2->SetBounds(gfx::Rect(15, 15, 20, 20), cc::LocalFrameId());
 
   MouseEventTest tests[] = {
       // Mouse over |c2|.
       {ui::MouseEvent(ui::ET_MOUSE_MOVED, gfx::Point(16, 16),
                       gfx::Point(16, 16), base::TimeTicks(), 0, 0),
        c2.get(), gfx::Point(16, 16), gfx::Point(1, 1), nullptr, gfx::Point(),
        gfx::Point()},
 
       // Press in same location.
       {ui::MouseEvent(ui::ET_MOUSE_PRESSED, gfx::Point(16, 16),
                       gfx::Point(16, 16), base::TimeTicks(),
                       ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON),
        c2.get(), gfx::Point(16, 16), gfx::Point(1, 1), nullptr, gfx::Point(),
        gfx::Point()}};
   RunMouseEventTests(event_dispatcher(), test_event_dispatcher_delegate(),
                      tests, arraysize(tests));
 
   // Set capture on |c1|. No events should be sent as |c1| is in the same
   // client.
   event_dispatcher()->SetCaptureWindow(c1.get(), kClientAreaId);
   EXPECT_FALSE(test_event_dispatcher_delegate()->has_queued_events());
 }
 
 }  // namespace test
 }  // namespace ws
 }  // namespace ui