WIP: Surface Synchronization System

services/ui/ws/window_tree_unittest.cc

 // Copyright 2014 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/window_tree.h"
 
 #include <stdint.h>
 
 #include <string>
 #include <vector>
@@ skipping 194 matching lines @@
                                          ServerWindow** window) {
   ServerWindow* embed_window = window_event_targeting_helper_.CreatePrimaryTree(
       gfx::Rect(0, 0, 100, 100), gfx::Rect(0, 0, 50, 50));
   window_event_targeting_helper_.CreateSecondaryTree(
       embed_window, gfx::Rect(20, 20, 20, 20), out_client, window_tree, window);
 }
 
 // Verifies focus correctly changes on pointer events.
 TEST_F(WindowTreeTest, FocusOnPointer) {
   const ClientWindowId embed_window_id = BuildClientWindowId(wm_tree(), 1);
-  EXPECT_TRUE(
-      wm_tree()->NewWindow(embed_window_id, ServerWindow::Properties()));
+  EXPECT_TRUE(wm_tree()->NewWindow(embed_window_id, ServerWindow::Properties(),
+                                   cc::LocalFrameId()));
   ServerWindow* embed_window = wm_tree()->GetWindowByClientId(embed_window_id);
   ASSERT_TRUE(embed_window);
   EXPECT_TRUE(wm_tree()->SetWindowVisibility(embed_window_id, true));
   ASSERT_TRUE(FirstRoot(wm_tree()));
   const ClientWindowId wm_root_id = FirstRootId(wm_tree());
   EXPECT_TRUE(wm_tree()->AddWindow(wm_root_id, embed_window_id));
   ServerWindow* wm_root = FirstRoot(wm_tree());
   ASSERT_TRUE(wm_root);
-  wm_root->SetBounds(gfx::Rect(0, 0, 100, 100));
+  wm_root->SetBounds(gfx::Rect(0, 0, 100, 100), cc::LocalFrameId());
   EnableHitTest(wm_root);
-  display()->root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
+  display()->root_window()->SetBounds(gfx::Rect(0, 0, 100, 100),
+                                      cc::LocalFrameId());
   mojom::WindowTreeClientPtr client;
   mojom::WindowTreeClientRequest client_request(&client);
   wm_client()->Bind(std::move(client_request));
   const uint32_t embed_flags = 0;
   wm_tree()->Embed(embed_window_id, std::move(client), embed_flags);
   WindowTree* tree1 = window_server()->GetTreeWithRoot(embed_window);
   ASSERT_TRUE(tree1 != nullptr);
   ASSERT_NE(tree1, wm_tree());
 
-  embed_window->SetBounds(gfx::Rect(0, 0, 50, 50));
+  embed_window->SetBounds(gfx::Rect(0, 0, 50, 50), cc::LocalFrameId());
 
   const ClientWindowId child1_id(BuildClientWindowId(tree1, 1));
-  EXPECT_TRUE(tree1->NewWindow(child1_id, ServerWindow::Properties()));
+  EXPECT_TRUE(tree1->NewWindow(child1_id, ServerWindow::Properties(),
+                               cc::LocalFrameId()));
   EXPECT_TRUE(tree1->AddWindow(ClientWindowIdForWindow(tree1, embed_window),
                                child1_id));
   ServerWindow* child1 = tree1->GetWindowByClientId(child1_id);
   ASSERT_TRUE(child1);
   child1->SetVisible(true);
-  child1->SetBounds(gfx::Rect(20, 20, 20, 20));
+  child1->SetBounds(gfx::Rect(20, 20, 20, 20), cc::LocalFrameId());
   EnableHitTest(child1);
 
   TestWindowTreeClient* tree1_client = last_window_tree_client();
   tree1_client->tracker()->changes()->clear();
   wm_client()->tracker()->changes()->clear();
 
   // Focus should not go to |child1| yet, since the parent still doesn't allow
   // active children.
   DispatchEventAndAckImmediately(CreatePointerDownEvent(21, 22));
   Display* display1 = tree1->GetDisplay(embed_window);
@@ skipping 294 matching lines @@
   ServerWindow* window = nullptr;
   EXPECT_NO_FATAL_FAILURE(SetupEventTargeting(&embed_client, &tree, &window));
 
   // Put the cursor just outside the bounds of the window.
   DispatchEventAndAckImmediately(CreateMouseMoveEvent(41, 41));
   window->SetPredefinedCursor(mojom::Cursor::IBEAM);
   EXPECT_EQ(mojom::Cursor::CURSOR_NULL, cursor_id());
 
   // Expand the bounds of the window so they now include where the cursor now
   // is.
-  window->SetBounds(gfx::Rect(20, 20, 25, 25));
+  window->SetBounds(gfx::Rect(20, 20, 25, 25), cc::LocalFrameId());
   EXPECT_EQ(mojom::Cursor::IBEAM, cursor_id());
 
   // Contract the bounds again.
-  window->SetBounds(gfx::Rect(20, 20, 20, 20));
+  window->SetBounds(gfx::Rect(20, 20, 20, 20), cc::LocalFrameId());
   EXPECT_EQ(mojom::Cursor::CURSOR_NULL, cursor_id());
 }
 
 TEST_F(WindowTreeTest, WindowReorderingChangesCursor) {
   TestWindowTreeClient* embed_client = nullptr;
   WindowTree* tree = nullptr;
   ServerWindow* window1 = nullptr;
   EXPECT_NO_FATAL_FAILURE(SetupEventTargeting(&embed_client, &tree, &window1));
 
   // Create a second window right over the first.
   const ClientWindowId embed_window_id(FirstRootId(tree));
   const ClientWindowId child2_id(BuildClientWindowId(tree, 2));
-  EXPECT_TRUE(tree->NewWindow(child2_id, ServerWindow::Properties()));
+  EXPECT_TRUE(tree->NewWindow(child2_id, ServerWindow::Properties(),
+                              cc::LocalFrameId()));
   ServerWindow* child2 = tree->GetWindowByClientId(child2_id);
   ASSERT_TRUE(child2);
   EXPECT_TRUE(tree->AddWindow(embed_window_id, child2_id));
   child2->SetVisible(true);
-  child2->SetBounds(gfx::Rect(20, 20, 20, 20));
+  child2->SetBounds(gfx::Rect(20, 20, 20, 20), cc::LocalFrameId());
   EnableHitTest(child2);
 
   // Give each window a different cursor.
   window1->SetPredefinedCursor(mojom::Cursor::IBEAM);
   child2->SetPredefinedCursor(mojom::Cursor::HAND);
 
   // We expect window2 to be over window1 now.
   DispatchEventAndAckImmediately(CreateMouseMoveEvent(22, 22));
   EXPECT_EQ(mojom::Cursor::HAND, cursor_id());
 
   // But when we put window2 at the bottom, we should adapt window1's cursor.
   child2->parent()->StackChildAtBottom(child2);
   EXPECT_EQ(mojom::Cursor::IBEAM, cursor_id());
 }
 
 TEST_F(WindowTreeTest, EventAck) {
   const ClientWindowId embed_window_id = BuildClientWindowId(wm_tree(), 1);
-  EXPECT_TRUE(
-      wm_tree()->NewWindow(embed_window_id, ServerWindow::Properties()));
+  EXPECT_TRUE(wm_tree()->NewWindow(embed_window_id, ServerWindow::Properties(),
+                                   cc::LocalFrameId()));
   EXPECT_TRUE(wm_tree()->SetWindowVisibility(embed_window_id, true));
   ASSERT_TRUE(FirstRoot(wm_tree()));
   EXPECT_TRUE(wm_tree()->AddWindow(FirstRootId(wm_tree()), embed_window_id));
   ASSERT_EQ(1u, display()->root_window()->children().size());
   ServerWindow* wm_root = FirstRoot(wm_tree());
   ASSERT_TRUE(wm_root);
-  wm_root->SetBounds(gfx::Rect(0, 0, 100, 100));
+  wm_root->SetBounds(gfx::Rect(0, 0, 100, 100), cc::LocalFrameId());
   EnableHitTest(wm_root);
 
   wm_client()->tracker()->changes()->clear();
   DispatchEventWithoutAck(CreateMouseMoveEvent(21, 22));
   ASSERT_EQ(1u, wm_client()->tracker()->changes()->size());
   EXPECT_EQ("InputEvent window=0,3 event_action=17",
             ChangesToDescription1(*wm_client()->tracker()->changes())[0]);
   wm_client()->tracker()->changes()->clear();
 
   // Send another event. This event shouldn't reach the client.
@@ skipping 27 matching lines @@
       ->NewTopLevelWindow(initial_change_id, embed_window_id2_in_child.id,
                           properties);
 
   // The binding should be paused until the wm acks the change.
   uint32_t wm_change_id = 0u;
   ASSERT_TRUE(wm_internal.did_call_create_top_level_window(&wm_change_id));
   EXPECT_TRUE(child_binding->is_paused());
 
   // Create the window for |embed_window_id2_in_child|.
   const ClientWindowId embed_window_id2 = BuildClientWindowId(wm_tree(), 2);
-  EXPECT_TRUE(
-      wm_tree()->NewWindow(embed_window_id2, ServerWindow::Properties()));
+  EXPECT_TRUE(wm_tree()->NewWindow(embed_window_id2, ServerWindow::Properties(),
+                                   cc::LocalFrameId()));
   EXPECT_TRUE(wm_tree()->SetWindowVisibility(embed_window_id2, true));
   EXPECT_TRUE(wm_tree()->AddWindow(FirstRootId(wm_tree()), embed_window_id2));
 
   // Ack the change, which should resume the binding.
   child_binding->client()->tracker()->changes()->clear();
   static_cast<mojom::WindowManagerClient*>(wm_tree())
       ->OnWmCreatedTopLevelWindow(wm_change_id, embed_window_id2.id);
   EXPECT_FALSE(child_binding->is_paused());
   EXPECT_EQ("TopLevelCreated id=17 window_id=" +
                 WindowIdToString(
@@ skipping 24 matching lines @@
 }
 
 // Tests that only the capture window can release capture.
 TEST_F(WindowTreeTest, ExplicitSetCapture) {
   TestWindowTreeClient* embed_client = nullptr;
   WindowTree* tree = nullptr;
   ServerWindow* window = nullptr;
   EXPECT_NO_FATAL_FAILURE(SetupEventTargeting(&embed_client, &tree, &window));
   const ServerWindow* root_window = *tree->roots().begin();
   tree->AddWindow(FirstRootId(tree), ClientWindowIdForWindow(tree, window));
-  window->SetBounds(gfx::Rect(0, 0, 100, 100));
+  window->SetBounds(gfx::Rect(0, 0, 100, 100), cc::LocalFrameId());
   ASSERT_TRUE(tree->GetDisplay(window));
 
   // Set capture.
   mojom::WindowTree* mojom_window_tree = static_cast<mojom::WindowTree*>(tree);
   uint32_t change_id = 42;
   mojom_window_tree->SetCapture(change_id, WindowIdToTransportId(window->id()));
   Display* display = tree->GetDisplay(window);
   EXPECT_EQ(window, GetCaptureWindow(display));
 
   // Only the capture window should be able to release capture
   mojom_window_tree->ReleaseCapture(++change_id,
                                     WindowIdToTransportId(root_window->id()));
   EXPECT_EQ(window, GetCaptureWindow(display));
   mojom_window_tree->ReleaseCapture(++change_id,
                                     WindowIdToTransportId(window->id()));
   EXPECT_EQ(nullptr, GetCaptureWindow(display));
 }
 
 // Tests that while a client is interacting with input, that capture is not
 // allowed for invisible windows.
 TEST_F(WindowTreeTest, CaptureWindowMustBeVisible) {
   TestWindowTreeClient* embed_client = nullptr;
   WindowTree* tree = nullptr;
   ServerWindow* window = nullptr;
   EXPECT_NO_FATAL_FAILURE(SetupEventTargeting(&embed_client, &tree, &window));
   tree->AddWindow(FirstRootId(tree), ClientWindowIdForWindow(tree, window));
-  window->SetBounds(gfx::Rect(0, 0, 100, 100));
+  window->SetBounds(gfx::Rect(0, 0, 100, 100), cc::LocalFrameId());
   ASSERT_TRUE(tree->GetDisplay(window));
 
   DispatchEventWithoutAck(CreatePointerDownEvent(10, 10));
   window->SetVisible(false);
   EXPECT_FALSE(tree->SetCapture(ClientWindowIdForWindow(tree, window)));
   EXPECT_NE(window, GetCaptureWindow(tree->GetDisplay(window)));
 }
 
 // Tests that showing a modal window releases the capture if the capture is on a
 // descendant of the modal parent.
 TEST_F(WindowTreeTest, ShowModalWindowWithDescendantCapture) {
   TestWindowTreeClient* embed_client = nullptr;
   WindowTree* tree = nullptr;
   ServerWindow* w1 = nullptr;
   EXPECT_NO_FATAL_FAILURE(SetupEventTargeting(&embed_client, &tree, &w1));
 
-  w1->SetBounds(gfx::Rect(10, 10, 30, 30));
+  w1->SetBounds(gfx::Rect(10, 10, 30, 30), cc::LocalFrameId());
   const ServerWindow* root_window = *tree->roots().begin();
   ClientWindowId root_window_id = ClientWindowIdForWindow(tree, root_window);
   ClientWindowId w1_id = ClientWindowIdForWindow(tree, w1);
   Display* display = tree->GetDisplay(w1);
 
   // Create |w11| as a child of |w1| and make it visible.
   ClientWindowId w11_id = BuildClientWindowId(tree, 11);
-  ASSERT_TRUE(tree->NewWindow(w11_id, ServerWindow::Properties()));
+  ASSERT_TRUE(
+      tree->NewWindow(w11_id, ServerWindow::Properties(), cc::LocalFrameId()));
   ServerWindow* w11 = tree->GetWindowByClientId(w11_id);
-  w11->SetBounds(gfx::Rect(10, 10, 10, 10));
+  w11->SetBounds(gfx::Rect(10, 10, 10, 10), cc::LocalFrameId());
   ASSERT_TRUE(tree->AddWindow(w1_id, w11_id));
   ASSERT_TRUE(tree->SetWindowVisibility(w11_id, true));
 
   // Create |w2| as a child of |root_window| and modal to |w1| and leave it
   // hidden.
   ClientWindowId w2_id = BuildClientWindowId(tree, 2);
-  ASSERT_TRUE(tree->NewWindow(w2_id, ServerWindow::Properties()));
+  ASSERT_TRUE(
+      tree->NewWindow(w2_id, ServerWindow::Properties(), cc::LocalFrameId()));
   ServerWindow* w2 = tree->GetWindowByClientId(w2_id);
-  w2->SetBounds(gfx::Rect(50, 10, 10, 10));
+  w2->SetBounds(gfx::Rect(50, 10, 10, 10), cc::LocalFrameId());
   ASSERT_TRUE(tree->AddWindow(root_window_id, w2_id));
   ASSERT_TRUE(tree->AddTransientWindow(w1_id, w2_id));
   ASSERT_TRUE(tree->SetModal(w2_id));
 
   // Set capture to |w11|.
   DispatchEventWithoutAck(CreatePointerDownEvent(25, 25));
   ASSERT_TRUE(tree->SetCapture(w11_id));
   EXPECT_EQ(w11, GetCaptureWindow(display));
   AckPreviousEvent();
 
   // Make |w2| visible. This should release capture as capture is set to a
   // descendant of the modal parent.
   ASSERT_TRUE(tree->SetWindowVisibility(w2_id, true));
   EXPECT_EQ(nullptr, GetCaptureWindow(display));
 }
 
 // Tests that setting a visible window as modal releases the capture if the
 // capture is on a descendant of the modal parent.
 TEST_F(WindowTreeTest, VisibleWindowToModalWithDescendantCapture) {
   TestWindowTreeClient* embed_client = nullptr;
   WindowTree* tree = nullptr;
   ServerWindow* w1 = nullptr;
   EXPECT_NO_FATAL_FAILURE(SetupEventTargeting(&embed_client, &tree, &w1));
 
-  w1->SetBounds(gfx::Rect(10, 10, 30, 30));
+  w1->SetBounds(gfx::Rect(10, 10, 30, 30), cc::LocalFrameId());
   const ServerWindow* root_window = *tree->roots().begin();
   ClientWindowId root_window_id = ClientWindowIdForWindow(tree, root_window);
   ClientWindowId w1_id = ClientWindowIdForWindow(tree, w1);
   Display* display = tree->GetDisplay(w1);
 
   // Create |w11| as a child of |w1| and make it visible.
   ClientWindowId w11_id = BuildClientWindowId(tree, 11);
-  ASSERT_TRUE(tree->NewWindow(w11_id, ServerWindow::Properties()));
+  ASSERT_TRUE(
+      tree->NewWindow(w11_id, ServerWindow::Properties(), cc::LocalFrameId()));
   ServerWindow* w11 = tree->GetWindowByClientId(w11_id);
-  w11->SetBounds(gfx::Rect(10, 10, 10, 10));
+  w11->SetBounds(gfx::Rect(10, 10, 10, 10), cc::LocalFrameId());
   ASSERT_TRUE(tree->AddWindow(w1_id, w11_id));
   ASSERT_TRUE(tree->SetWindowVisibility(w11_id, true));
 
   // Create |w2| as a child of |root_window| and make it visible.
   ClientWindowId w2_id = BuildClientWindowId(tree, 2);
-  ASSERT_TRUE(tree->NewWindow(w2_id, ServerWindow::Properties()));
+  ASSERT_TRUE(
+      tree->NewWindow(w2_id, ServerWindow::Properties(), cc::LocalFrameId()));
   ServerWindow* w2 = tree->GetWindowByClientId(w2_id);
-  w2->SetBounds(gfx::Rect(50, 10, 10, 10));
+  w2->SetBounds(gfx::Rect(50, 10, 10, 10), cc::LocalFrameId());
   ASSERT_TRUE(tree->AddWindow(root_window_id, w2_id));
   ASSERT_TRUE(tree->SetWindowVisibility(w2_id, true));
 
   // Set capture to |w11|.
   DispatchEventWithoutAck(CreatePointerDownEvent(25, 25));
   ASSERT_TRUE(tree->SetCapture(w11_id));
   EXPECT_EQ(w11, GetCaptureWindow(display));
   AckPreviousEvent();
 
   // Set |w2| modal to |w1|. This should release the capture as the capture is
   // set to a descendant of the modal parent.
   ASSERT_TRUE(tree->AddTransientWindow(w1_id, w2_id));
   ASSERT_TRUE(tree->SetModal(w2_id));
   EXPECT_EQ(nullptr, GetCaptureWindow(display));
 }
 
 // Tests that showing a modal window does not change capture if the capture is
 // not on a descendant of the modal parent.
 TEST_F(WindowTreeTest, ShowModalWindowWithNonDescendantCapture) {
   TestWindowTreeClient* embed_client = nullptr;
   WindowTree* tree = nullptr;
   ServerWindow* w1 = nullptr;
   EXPECT_NO_FATAL_FAILURE(SetupEventTargeting(&embed_client, &tree, &w1));
 
-  w1->SetBounds(gfx::Rect(10, 10, 30, 30));
+  w1->SetBounds(gfx::Rect(10, 10, 30, 30), cc::LocalFrameId());
   const ServerWindow* root_window = *tree->roots().begin();
   ClientWindowId root_window_id = ClientWindowIdForWindow(tree, root_window);
   ClientWindowId w1_id = ClientWindowIdForWindow(tree, w1);
   Display* display = tree->GetDisplay(w1);
 
   // Create |w2| as a child of |root_window| and modal to |w1| and leave it
   // hidden..
   ClientWindowId w2_id = BuildClientWindowId(tree, 2);
-  ASSERT_TRUE(tree->NewWindow(w2_id, ServerWindow::Properties()));
+  ASSERT_TRUE(
+      tree->NewWindow(w2_id, ServerWindow::Properties(), cc::LocalFrameId()));
   ServerWindow* w2 = tree->GetWindowByClientId(w2_id);
-  w2->SetBounds(gfx::Rect(50, 10, 10, 10));
+  w2->SetBounds(gfx::Rect(50, 10, 10, 10), cc::LocalFrameId());
   ASSERT_TRUE(tree->AddWindow(root_window_id, w2_id));
   ASSERT_TRUE(tree->AddTransientWindow(w1_id, w2_id));
   ASSERT_TRUE(tree->SetModal(w2_id));
 
   // Create |w3| as a child of |root_window| and make it visible.
   ClientWindowId w3_id = BuildClientWindowId(tree, 3);
-  ASSERT_TRUE(tree->NewWindow(w3_id, ServerWindow::Properties()));
+  ASSERT_TRUE(
+      tree->NewWindow(w3_id, ServerWindow::Properties(), cc::LocalFrameId()));
   ServerWindow* w3 = tree->GetWindowByClientId(w3_id);
-  w3->SetBounds(gfx::Rect(70, 10, 10, 10));
+  w3->SetBounds(gfx::Rect(70, 10, 10, 10), cc::LocalFrameId());
   ASSERT_TRUE(tree->AddWindow(root_window_id, w3_id));
   ASSERT_TRUE(tree->SetWindowVisibility(w3_id, true));
 
   // Set capture to |w3|.
   DispatchEventWithoutAck(CreatePointerDownEvent(25, 25));
   ASSERT_TRUE(tree->SetCapture(w3_id));
   EXPECT_EQ(w3, GetCaptureWindow(display));
   AckPreviousEvent();
 
   // Make |w2| visible. This should not change the capture as the capture is not
   // set to a descendant of the modal parent.
   ASSERT_TRUE(tree->SetWindowVisibility(w2_id, true));
   EXPECT_EQ(w3, GetCaptureWindow(display));
 }
 
 // Tests that setting a visible window as modal does not change the capture if
 // the capture is not set to a descendant of the modal parent.
 TEST_F(WindowTreeTest, VisibleWindowToModalWithNonDescendantCapture) {
   TestWindowTreeClient* embed_client = nullptr;
   WindowTree* tree = nullptr;
   ServerWindow* w1 = nullptr;
   EXPECT_NO_FATAL_FAILURE(SetupEventTargeting(&embed_client, &tree, &w1));
 
-  w1->SetBounds(gfx::Rect(10, 10, 30, 30));
+  w1->SetBounds(gfx::Rect(10, 10, 30, 30), cc::LocalFrameId());
   const ServerWindow* root_window = *tree->roots().begin();
   ClientWindowId root_window_id = ClientWindowIdForWindow(tree, root_window);
   ClientWindowId w1_id = ClientWindowIdForWindow(tree, w1);
   Display* display = tree->GetDisplay(w1);
 
   // Create |w2| and |w3| as children of |root_window| and make them visible.
   ClientWindowId w2_id = BuildClientWindowId(tree, 2);
-  ASSERT_TRUE(tree->NewWindow(w2_id, ServerWindow::Properties()));
+  ASSERT_TRUE(
+      tree->NewWindow(w2_id, ServerWindow::Properties(), cc::LocalFrameId()));
   ServerWindow* w2 = tree->GetWindowByClientId(w2_id);
-  w2->SetBounds(gfx::Rect(50, 10, 10, 10));
+  w2->SetBounds(gfx::Rect(50, 10, 10, 10), cc::LocalFrameId());
   ASSERT_TRUE(tree->AddWindow(root_window_id, w2_id));
   ASSERT_TRUE(tree->SetWindowVisibility(w2_id, true));
 
   ClientWindowId w3_id = BuildClientWindowId(tree, 3);
-  ASSERT_TRUE(tree->NewWindow(w3_id, ServerWindow::Properties()));
+  ASSERT_TRUE(
+      tree->NewWindow(w3_id, ServerWindow::Properties(), cc::LocalFrameId()));
   ServerWindow* w3 = tree->GetWindowByClientId(w3_id);
-  w3->SetBounds(gfx::Rect(70, 10, 10, 10));
+  w3->SetBounds(gfx::Rect(70, 10, 10, 10), cc::LocalFrameId());
   ASSERT_TRUE(tree->AddWindow(root_window_id, w3_id));
   ASSERT_TRUE(tree->SetWindowVisibility(w3_id, true));
 
   // Set capture to |w3|.
   DispatchEventWithoutAck(CreatePointerDownEvent(25, 25));
   ASSERT_TRUE(tree->SetCapture(w3_id));
   EXPECT_EQ(w3, GetCaptureWindow(display));
   AckPreviousEvent();
 
   // Set |w2| modal to |w1|. This should not release the capture as the capture
   // is not set to a descendant of the modal parent.
   ASSERT_TRUE(tree->AddTransientWindow(w1_id, w2_id));
   ASSERT_TRUE(tree->SetModal(w2_id));
   EXPECT_EQ(w3, GetCaptureWindow(display));
 }
 
 // Tests that showing a system modal window releases the capture.
 TEST_F(WindowTreeTest, ShowSystemModalWindowWithCapture) {
   TestWindowTreeClient* embed_client = nullptr;
   WindowTree* tree = nullptr;
   ServerWindow* w1 = nullptr;
   EXPECT_NO_FATAL_FAILURE(SetupEventTargeting(&embed_client, &tree, &w1));
 
-  w1->SetBounds(gfx::Rect(10, 10, 10, 10));
+  w1->SetBounds(gfx::Rect(10, 10, 10, 10), cc::LocalFrameId());
   const ServerWindow* root_window = *tree->roots().begin();
   ClientWindowId root_window_id = ClientWindowIdForWindow(tree, root_window);
   ClientWindowId w1_id = ClientWindowIdForWindow(tree, w1);
   Display* display = tree->GetDisplay(w1);
 
   // Create a system modal window |w2| as a child of |root_window| and leave it
   // hidden.
   ClientWindowId w2_id = BuildClientWindowId(tree, 2);
-  ASSERT_TRUE(tree->NewWindow(w2_id, ServerWindow::Properties()));
+  ASSERT_TRUE(
+      tree->NewWindow(w2_id, ServerWindow::Properties(), cc::LocalFrameId()));
   ServerWindow* w2 = tree->GetWindowByClientId(w2_id);
-  w2->SetBounds(gfx::Rect(30, 10, 10, 10));
+  w2->SetBounds(gfx::Rect(30, 10, 10, 10), cc::LocalFrameId());
   ASSERT_TRUE(tree->AddWindow(root_window_id, w2_id));
   ASSERT_TRUE(tree->SetModal(w2_id));
 
   // Set capture to |w1|.
   DispatchEventWithoutAck(CreatePointerDownEvent(15, 15));
   ASSERT_TRUE(tree->SetCapture(w1_id));
   EXPECT_EQ(w1, GetCaptureWindow(display));
   AckPreviousEvent();
 
   // Make |w2| visible. This should release capture as it is system modal
   // window.
   ASSERT_TRUE(tree->SetWindowVisibility(w2_id, true));
   EXPECT_EQ(nullptr, GetCaptureWindow(display));
 }
 
 // Tests that setting a visible window as modal to system releases the capture.
 TEST_F(WindowTreeTest, VisibleWindowToSystemModalWithCapture) {
   TestWindowTreeClient* embed_client = nullptr;
   WindowTree* tree = nullptr;
   ServerWindow* w1 = nullptr;
   EXPECT_NO_FATAL_FAILURE(SetupEventTargeting(&embed_client, &tree, &w1));
 
-  w1->SetBounds(gfx::Rect(10, 10, 10, 10));
+  w1->SetBounds(gfx::Rect(10, 10, 10, 10), cc::LocalFrameId());
   const ServerWindow* root_window = *tree->roots().begin();
   ClientWindowId root_window_id = ClientWindowIdForWindow(tree, root_window);
   ClientWindowId w1_id = ClientWindowIdForWindow(tree, w1);
   Display* display = tree->GetDisplay(w1);
 
   // Create |w2| as a child of |root_window| and make it visible.
   ClientWindowId w2_id = BuildClientWindowId(tree, 2);
-  ASSERT_TRUE(tree->NewWindow(w2_id, ServerWindow::Properties()));
+  ASSERT_TRUE(
+      tree->NewWindow(w2_id, ServerWindow::Properties(), cc::LocalFrameId()));
   ServerWindow* w2 = tree->GetWindowByClientId(w2_id);
-  w2->SetBounds(gfx::Rect(30, 10, 10, 10));
+  w2->SetBounds(gfx::Rect(30, 10, 10, 10), cc::LocalFrameId());
   ASSERT_TRUE(tree->AddWindow(root_window_id, w2_id));
   ASSERT_TRUE(tree->SetWindowVisibility(w2_id, true));
 
   // Set capture to |w1|.
   DispatchEventWithoutAck(CreatePointerDownEvent(15, 15));
   ASSERT_TRUE(tree->SetCapture(w1_id));
   EXPECT_EQ(w1, GetCaptureWindow(display));
   AckPreviousEvent();
 
   // Make |w2| modal to system. This should release capture.
   ASSERT_TRUE(tree->SetModal(w2_id));
   EXPECT_EQ(nullptr, GetCaptureWindow(display));
 }
 
 // Tests that moving the capture window to a modal parent releases the capture
 // as capture cannot be blocked by a modal window.
 TEST_F(WindowTreeTest, MoveCaptureWindowToModalParent) {
   TestWindowTreeClient* embed_client = nullptr;
   WindowTree* tree = nullptr;
   ServerWindow* w1 = nullptr;
   EXPECT_NO_FATAL_FAILURE(SetupEventTargeting(&embed_client, &tree, &w1));
 
-  w1->SetBounds(gfx::Rect(10, 10, 30, 30));
+  w1->SetBounds(gfx::Rect(10, 10, 30, 30), cc::LocalFrameId());
   const ServerWindow* root_window = *tree->roots().begin();
   ClientWindowId root_window_id = ClientWindowIdForWindow(tree, root_window);
   ClientWindowId w1_id = ClientWindowIdForWindow(tree, w1);
   Display* display = tree->GetDisplay(w1);
 
   // Create |w2| and |w3| as children of |root_window| and make them visible.
   ClientWindowId w2_id = BuildClientWindowId(tree, 2);
-  ASSERT_TRUE(tree->NewWindow(w2_id, ServerWindow::Properties()));
+  ASSERT_TRUE(
+      tree->NewWindow(w2_id, ServerWindow::Properties(), cc::LocalFrameId()));
   ServerWindow* w2 = tree->GetWindowByClientId(w2_id);
-  w2->SetBounds(gfx::Rect(50, 10, 10, 10));
+  w2->SetBounds(gfx::Rect(50, 10, 10, 10), cc::LocalFrameId());
   ASSERT_TRUE(tree->AddWindow(root_window_id, w2_id));
   ASSERT_TRUE(tree->SetWindowVisibility(w2_id, true));
 
   ClientWindowId w3_id = BuildClientWindowId(tree, 3);
-  ASSERT_TRUE(tree->NewWindow(w3_id, ServerWindow::Properties()));
+  ASSERT_TRUE(
+      tree->NewWindow(w3_id, ServerWindow::Properties(), cc::LocalFrameId()));
   ServerWindow* w3 = tree->GetWindowByClientId(w3_id);
-  w3->SetBounds(gfx::Rect(70, 10, 10, 10));
+  w3->SetBounds(gfx::Rect(70, 10, 10, 10), cc::LocalFrameId());
   ASSERT_TRUE(tree->AddWindow(root_window_id, w3_id));
   ASSERT_TRUE(tree->SetWindowVisibility(w3_id, true));
 
   // Set |w2| modal to |w1|.
   ASSERT_TRUE(tree->AddTransientWindow(w1_id, w2_id));
   ASSERT_TRUE(tree->SetModal(w2_id));
 
   // Set capture to |w3|.
   DispatchEventWithoutAck(CreatePointerDownEvent(25, 25));
   ASSERT_TRUE(tree->SetCapture(w3_id));
@@ skipping 82 matching lines @@
       ->NewTopLevelWindow(initial_change_id, embed_window_id2_in_child.id,
                           properties);
 
   // The binding should be paused until the wm acks the change.
   uint32_t wm_change_id = 0u;
   ASSERT_TRUE(wm_internal.did_call_create_top_level_window(&wm_change_id));
   EXPECT_TRUE(child_binding->is_paused());
 
   // Create the window for |embed_window_id2_in_child|.
   const ClientWindowId embed_window_id2 = BuildClientWindowId(wm_tree(), 2);
-  EXPECT_TRUE(
-      wm_tree()->NewWindow(embed_window_id2, ServerWindow::Properties()));
+  EXPECT_TRUE(wm_tree()->NewWindow(embed_window_id2, ServerWindow::Properties(),
+                                   cc::LocalFrameId()));
   EXPECT_TRUE(wm_tree()->SetWindowVisibility(embed_window_id2, true));
   EXPECT_TRUE(wm_tree()->AddWindow(FirstRootId(wm_tree()), embed_window_id2));
 
   // Ack the change, which should resume the binding.
   child_binding->client()->tracker()->changes()->clear();
   static_cast<mojom::WindowManagerClient*>(wm_tree())
       ->OnWmCreatedTopLevelWindow(wm_change_id, embed_window_id2.id);
   EXPECT_FALSE(child_binding->is_paused());
 
   // The child_tree is the one that has to make this call; the
@@ skipping 23 matching lines @@
       ->NewTopLevelWindow(initial_change_id, embed_window_id2_in_child.id,
                           properties);
 
   // The binding should be paused until the wm acks the change.
   uint32_t wm_change_id = 0u;
   ASSERT_TRUE(wm_internal.did_call_create_top_level_window(&wm_change_id));
   EXPECT_TRUE(child_binding->is_paused());
 
   // Create the window for |embed_window_id2_in_child|.
   const ClientWindowId embed_window_id2 = BuildClientWindowId(wm_tree(), 2);
-  EXPECT_TRUE(
-      wm_tree()->NewWindow(embed_window_id2, ServerWindow::Properties()));
+  EXPECT_TRUE(wm_tree()->NewWindow(embed_window_id2, ServerWindow::Properties(),
+                                   cc::LocalFrameId()));
   EXPECT_TRUE(wm_tree()->SetWindowVisibility(embed_window_id2, true));
   EXPECT_TRUE(wm_tree()->AddWindow(FirstRootId(wm_tree()), embed_window_id2));
 
   // Ack the change, which should resume the binding.
   child_binding->client()->tracker()->changes()->clear();
   static_cast<mojom::WindowManagerClient*>(wm_tree())
       ->OnWmCreatedTopLevelWindow(wm_change_id, embed_window_id2.id);
   EXPECT_FALSE(child_binding->is_paused());
 
   // The child_tree is the one that has to make this call; the
@@ skipping 33 matching lines @@
       ->NewTopLevelWindow(initial_change_id, embed_window_id2_in_child.id,
                           properties);
 
   // The binding should be paused until the wm acks the change.
   uint32_t wm_change_id = 0u;
   ASSERT_TRUE(wm_internal.did_call_create_top_level_window(&wm_change_id));
   EXPECT_TRUE(child_binding->is_paused());
 
   // Create the window for |embed_window_id2_in_child|.
   const ClientWindowId embed_window_id2 = BuildClientWindowId(wm_tree(), 2);
-  EXPECT_TRUE(
-      wm_tree()->NewWindow(embed_window_id2, ServerWindow::Properties()));
+  EXPECT_TRUE(wm_tree()->NewWindow(embed_window_id2, ServerWindow::Properties(),
+                                   cc::LocalFrameId()));
   EXPECT_TRUE(wm_tree()->SetWindowVisibility(embed_window_id2, true));
   EXPECT_TRUE(wm_tree()->AddWindow(FirstRootId(wm_tree()), embed_window_id2));
 
   // Ack the change, which should resume the binding.
   child_binding->client()->tracker()->changes()->clear();
   static_cast<mojom::WindowManagerClient*>(wm_tree())
       ->OnWmCreatedTopLevelWindow(wm_change_id, embed_window_id2.id);
   EXPECT_FALSE(child_binding->is_paused());
 
   // Making this call from the wm_tree() must be invalid.
@@ skipping 23 matching lines @@
       ->NewTopLevelWindow(initial_change_id, embed_window_id2_in_child.id,
                           properties);
 
   // The binding should be paused until the wm acks the change.
   uint32_t wm_change_id = 0u;
   ASSERT_TRUE(wm_internal.did_call_create_top_level_window(&wm_change_id));
   EXPECT_TRUE(child_binding->is_paused());
 
   // Create the window for |embed_window_id2_in_child|.
   const ClientWindowId embed_window_id2 = BuildClientWindowId(wm_tree(), 2);
-  EXPECT_TRUE(
-      wm_tree()->NewWindow(embed_window_id2, ServerWindow::Properties()));
+  EXPECT_TRUE(wm_tree()->NewWindow(embed_window_id2, ServerWindow::Properties(),
+                                   cc::LocalFrameId()));
   EXPECT_TRUE(wm_tree()->SetWindowVisibility(embed_window_id2, true));
   EXPECT_TRUE(wm_tree()->AddWindow(FirstRootId(wm_tree()), embed_window_id2));
 
   // Ack the change, which should resume the binding.
   child_binding->client()->tracker()->changes()->clear();
   static_cast<mojom::WindowManagerClient*>(wm_tree())
       ->OnWmCreatedTopLevelWindow(wm_change_id, embed_window_id2.id);
   EXPECT_FALSE(child_binding->is_paused());
 
   // The child_tree is the one that has to make this call; the
   const uint32_t change_id = 7;
   static_cast<mojom::WindowTree*>(child_tree)
       ->PerformWindowMove(change_id, embed_window_id2_in_child.id,
                           mojom::MoveLoopSource::MOUSE, gfx::Point(0, 0));
 
   ServerWindow* server_window =
       wm_tree()->GetWindowByClientId(embed_window_id2);
   gfx::Rect old_bounds = server_window->bounds();
-  server_window->SetBounds(gfx::Rect(10, 10, 20, 20));
+  server_window->SetBounds(gfx::Rect(10, 10, 20, 20), cc::LocalFrameId());
 
   // Cancel the move loop.
   const uint32_t kFirstWMChange = 1;
   static_cast<mojom::WindowManagerClient*>(wm_tree())->WmResponse(
       kFirstWMChange, false);
 
   // Canceling the move loop should have reverted the bounds.
   EXPECT_EQ(old_bounds, server_window->bounds());
 }
 
@@ skipping 34 matching lines @@
   ServerWindow* window = window_event_targeting_helper_.CreatePrimaryTree(
       gfx::Rect(0, 0, 100, 100), gfx::Rect(0, 0, 50, 50));
   TestWindowTreeClient* embed_client = last_window_tree_client();
   WindowTree* owning_tree =
       window_server()->GetTreeWithId(window->id().client_id);
   WindowTree* embed_tree = window_server()->GetTreeWithRoot(window);
   ASSERT_NE(owning_tree, embed_tree);
 
   const ClientWindowId embed_child_window_id =
       BuildClientWindowId(embed_tree, 2);
-  ASSERT_TRUE(
-      embed_tree->NewWindow(embed_child_window_id, ServerWindow::Properties()));
+  ASSERT_TRUE(embed_tree->NewWindow(
+      embed_child_window_id, ServerWindow::Properties(), cc::LocalFrameId()));
   EXPECT_TRUE(embed_tree->SetWindowVisibility(embed_child_window_id, true));
   EXPECT_TRUE(
       embed_tree->AddWindow(FirstRootId(embed_tree), embed_child_window_id));
   wm_client()->tracker()->changes()->clear();
   embed_client->tracker()->changes()->clear();
   EXPECT_TRUE(embed_tree->SetCapture(embed_child_window_id));
   ASSERT_TRUE(!wm_client()->tracker()->changes()->empty());
   EXPECT_EQ("OnCaptureChanged new_window=2,1 old_window=null",
             ChangesToDescription1(*wm_client()->tracker()->changes())[0]);
   EXPECT_TRUE(embed_client->tracker()->changes()->empty());
@@ skipping 30 matching lines @@
     window_server->user_id_tracker()->AddUserId(kTestUserId1);
     screen_manager.AddDisplay();
 
     AddWindowManager(window_server, kTestUserId1);
     window_server->user_id_tracker()->SetActiveUserId(kTestUserId1);
     TestWindowTreeBinding* test_binding =
         ws_test_helper.window_server_delegate()->last_binding();
     ASSERT_TRUE(test_binding);
     WindowTree* tree = test_binding->tree();
     const ClientWindowId window_id = BuildClientWindowId(tree, 2);
-    ASSERT_TRUE(tree->NewWindow(window_id, ServerWindow::Properties()));
+    ASSERT_TRUE(tree->NewWindow(window_id, ServerWindow::Properties(),
+                                cc::LocalFrameId()));
 
     // Release the client so that it survices shutdown.
     client = test_binding->ReleaseClient();
     client->tracker()->changes()->clear();
   }
 
   // Client should not have got any messages after shutdown.
   EXPECT_TRUE(client->tracker()->changes()->empty());
 }
 
 }  // namespace test
 }  // namespace ws
 }  // namespace ui