mus: Send display-id to client only for the root windows.

components/mus/ws/window_tree.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 "components/mus/ws/window_tree.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 85 matching lines @@
 
   if (roots_.empty())
     return;
 
   std::vector<const ServerWindow*> to_send;
   CHECK_EQ(1u, roots_.size());
   const ServerWindow* root = *roots_.begin();
   GetUnknownWindowsFrom(root, &to_send);
 
   Display* display = GetDisplay(root);
+  int64_t display_id =
+      display ? display->id() : display::Display::kInvalidDisplayID;
   const ServerWindow* focused_window =
       display ? display->GetFocusedWindow() : nullptr;
   if (focused_window)
     focused_window = access_policy_->GetWindowForFocusChange(focused_window);
   ClientWindowId focused_window_id;
   if (focused_window)
     IsWindowKnown(focused_window, &focused_window_id);
 
   const bool drawn = root->parent() && root->parent()->IsDrawn();
   client()->OnEmbed(id_, WindowToWindowData(to_send.front()), std::move(tree),
-                    focused_window_id.id, drawn);
+                    display_id, focused_window_id.id, drawn);
 }
 
 void WindowTree::ConfigureWindowManager() {
   DCHECK(!window_manager_internal_);
   window_manager_internal_ = binding_->GetWindowManager();
 }
 
 const ServerWindow* WindowTree::GetWindow(const WindowId& id) const {
   if (id_ == id.client_id) {
     auto iter = created_window_map_.find(id);
@@ skipping 241 matching lines @@
           std::move(waiting_for_top_level_window_info_));
   binding_->SetIncomingMethodCallProcessingPaused(false);
   // We were paused, so the id should still be valid.
   DCHECK(IsValidIdForNewWindow(
       waiting_for_top_level_window_info->client_window_id));
   client_id_to_window_id_map_[waiting_for_top_level_window_info
                                   ->client_window_id] = window->id();
   window_id_to_client_id_map_[window->id()] =
       waiting_for_top_level_window_info->client_window_id;
   roots_.insert(window);
+  Display* display = GetDisplay(window);
+  int64_t display_id =
+      display ? display->id() : display::Display::kInvalidDisplayID;
   const bool drawn = window->parent() && window->parent()->IsDrawn();
   client()->OnTopLevelCreated(client_change_id, WindowToWindowData(window),
-                              drawn);
+                              display_id, drawn);
 }
 
 void WindowTree::AddActivationParent(const ClientWindowId& window_id) {
   Display* host = GetDisplayForWindowManager();
   if (!host)
     return;
   ServerWindow* window = GetWindowByClientId(window_id);
   if (window)
     host->AddActivationParent(window);
 }
@@ skipping 453 matching lines @@
   Array<mojom::WindowDataPtr> array(windows.size());
   for (size_t i = 0; i < windows.size(); ++i)
     array[i] = WindowToWindowData(windows[i]);
   return array;
 }
 
 mojom::WindowDataPtr WindowTree::WindowToWindowData(
     const ServerWindow* window) {
   DCHECK(IsWindowKnown(window));
   const ServerWindow* parent = window->parent();
-
-  // Get the associated display before |parent| may be reset.
-  int64_t display_id = display::Display::kInvalidDisplayID;
-  const Display* display = display_manager()->GetDisplayContaining(window);
-  if (!display && parent)
-    display = display_manager()->GetDisplayContaining(parent);
-  if (display)
-    display_id = display->id();
-
   // If the parent isn't known, it means the parent is not visible to us (not
   // in roots), and should not be sent over.
   if (parent && !IsWindowKnown(parent))
     parent = nullptr;
   mojom::WindowDataPtr window_data(mojom::WindowData::New());
   window_data->parent_id =
       parent ? ClientWindowIdForWindow(parent).id : ClientWindowId().id;
   window_data->window_id =
       window ? ClientWindowIdForWindow(window).id : ClientWindowId().id;
   window_data->bounds = Rect::From(window->bounds());
   window_data->properties =
       mojo::Map<String, Array<uint8_t>>::From(window->properties());
   window_data->visible = window->visible();
-  window_data->display_id = display_id;
   return window_data;
 }
 
 void WindowTree::GetWindowTreeImpl(
     const ServerWindow* window,
     std::vector<const ServerWindow*>* windows) const {
   DCHECK(window);
 
   if (!access_policy_->CanGetWindowTree(window))
     return;
@@ skipping 619 matching lines @@
 }
 
 bool WindowTree::IsWindowRootOfAnotherTreeForAccessPolicy(
     const ServerWindow* window) const {
   WindowTree* tree = window_server_->GetTreeWithRoot(window);
   return tree && tree != this;
 }
 
 }  // namespace ws
 }  // namespace mus