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

components/mus/public/cpp/lib/window_tree_client_impl.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/public/cpp/lib/window_tree_client_impl.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <utility>
@@ skipping 32 matching lines @@
 Window* AddWindowToClient(WindowTreeClientImpl* client,
                           Window* parent,
                           const mojom::WindowDataPtr& window_data) {
   // We don't use the ctor that takes a WindowTreeConnection here, since it
   // will call back to the service and attempt to create a new window.
   Window* window = WindowPrivate::LocalCreate();
   WindowPrivate private_window(window);
   private_window.set_connection(client);
   private_window.set_server_id(window_data->window_id);
   private_window.set_visible(window_data->visible);
-  private_window.LocalSetDisplay(window_data->display_id);
   private_window.set_properties(
       window_data->properties
           .To<std::map<std::string, std::vector<uint8_t>>>());
   client->AddWindow(window);
   private_window.LocalSetBounds(gfx::Rect(),
                                 window_data->bounds.To<gfx::Rect>());
   if (parent)
     WindowPrivate(parent).LocalAddChild(window);
   return window;
 }
@@ skipping 475 matching lines @@
     roots_.insert(window);
     tree_->NewTopLevelWindow(change_id, server_id(window),
                              std::move(transport_properties));
   }
   return window;
 }
 
 void WindowTreeClientImpl::OnEmbedImpl(mojom::WindowTree* window_tree,
                                        ClientSpecificId client_id,
                                        mojom::WindowDataPtr root_data,
+                                       int64_t display_id,
                                        Id focused_window_id,
                                        bool drawn) {
   // WARNING: this is only called if WindowTreeClientImpl was created as the
   // result of an embedding.
   tree_ = window_tree;
   client_id_ = client_id;
 
   DCHECK(roots_.empty());
   Window* root = AddWindowToClient(this, nullptr, root_data);
+  WindowPrivate(root).LocalSetDisplay(display_id);
   roots_.insert(root);
 
   focused_window_ = GetWindowByServerId(focused_window_id);
 
   WindowPrivate(root).LocalSetParentDrawn(drawn);
 
   delegate_->OnEmbed(root);
 
   if (focused_window_) {
     FOR_EACH_OBSERVER(WindowTreeConnectionObserver, observers_,
@@ skipping 83 matching lines @@
 }
 
 void WindowTreeClientImpl::RemoveObserver(
     WindowTreeConnectionObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void WindowTreeClientImpl::OnEmbed(ClientSpecificId client_id,
                                    mojom::WindowDataPtr root_data,
                                    mojom::WindowTreePtr tree,
+                                   int64_t display_id,
                                    Id focused_window_id,
                                    bool drawn) {
   DCHECK(!tree_ptr_);
   tree_ptr_ = std::move(tree);
   tree_ptr_.set_connection_error_handler([this]() { delete this; });
 
   if (window_manager_delegate_) {
     tree_ptr_->GetWindowManagerClient(GetProxy(&window_manager_internal_client_,
                                                tree_ptr_.associated_group()));
   }
 
-  OnEmbedImpl(tree_ptr_.get(), client_id, std::move(root_data),
+  OnEmbedImpl(tree_ptr_.get(), client_id, std::move(root_data), display_id,
               focused_window_id, drawn);
 }
 
 void WindowTreeClientImpl::OnEmbeddedAppDisconnected(Id window_id) {
   Window* window = GetWindowByServerId(window_id);
   if (window) {
     FOR_EACH_OBSERVER(WindowObserver, *WindowPrivate(window).observers(),
                       OnWindowEmbeddedAppDisconnected(window));
   }
 }
@@ skipping 14 matching lines @@
 
   InFlightCaptureChange reset_change(this, nullptr);
   if (ApplyServerChangeToExistingInFlightChange(reset_change))
     return;
 
   LocalSetCapture(nullptr);
 }
 
 void WindowTreeClientImpl::OnTopLevelCreated(uint32_t change_id,
                                              mojom::WindowDataPtr data,
+                                             int64_t display_id,
                                              bool drawn) {
   // The server ack'd the top level window we created and supplied the state
   // of the window at the time the server created it. For properties we do not
   // have changes in flight for we can update them immediately. For properties
   // with changes in flight we set the revert value from the server.
 
   if (!in_flight_map_.count(change_id)) {
     // The window may have been destroyed locally before the server could finish
     // creating the window, and before the server received the notification that
     // the window has been destroyed.
     return;
   }
   std::unique_ptr<InFlightChange> change(std::move(in_flight_map_[change_id]));
   in_flight_map_.erase(change_id);
 
   Window* window = change->window();
   WindowPrivate window_private(window);
 
   // Drawn state and display-id always come from the server (they can't be
   // modified locally).
   window_private.LocalSetParentDrawn(drawn);
-  window_private.LocalSetDisplay(data->display_id);
+  window_private.LocalSetDisplay(display_id);
 
   // The default visibilty is false, we only need update visibility if it
   // differs from that.
   if (data->visible) {
     InFlightVisibleChange visible_change(window, data->visible);
     InFlightChange* current_change =
         GetOldestInFlightChangeMatching(visible_change);
     if (current_change)
       current_change->SetRevertValueFrom(visible_change);
     else
@@ skipping 394 matching lines @@
     const gfx::Vector2d& offset,
     const gfx::Insets& hit_area) {
   if (window_manager_internal_client_) {
     window_manager_internal_client_->SetUnderlaySurfaceOffsetAndExtendedHitArea(
         server_id(window), offset.x(), offset.y(),
         mojo::Insets::From(hit_area));
   }
 }
 
 }  // namespace mus