mus-ws: Plumb FrameSinkId to Children

ui/aura/mus/window_tree_client.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 "ui/aura/mus/window_tree_client.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <utility>
@@ skipping 421 matching lines @@
 void WindowTreeClient::SetLocalPropertiesFromServerProperties(
     WindowMus* window,
     const ui::mojom::WindowData& window_data) {
   for (auto& pair : window_data.properties)
     window->SetPropertyFromServer(pair.first, &pair.second);
 }
 
 std::unique_ptr<WindowTreeHostMus> WindowTreeClient::CreateWindowTreeHost(
     WindowMusType window_mus_type,
     const ui::mojom::WindowData& window_data,
-    int64_t display_id) {
+    int64_t display_id,
+    const cc::FrameSinkId& frame_sink_id) {
   std::unique_ptr<WindowPortMus> window_port =
       CreateWindowPortMus(window_data, window_mus_type);
   roots_.insert(window_port.get());
   std::unique_ptr<WindowTreeHostMus> window_tree_host =
       base::MakeUnique<WindowTreeHostMus>(std::move(window_port), this,
-                                          display_id);
+                                          display_id, frame_sink_id);
   window_tree_host->InitHost();
   SetLocalPropertiesFromServerProperties(
       WindowMus::Get(window_tree_host->window()), window_data);
   if (window_data.visible) {
     SetWindowVisibleFromServer(WindowMus::Get(window_tree_host->window()),
                                true);
   }
   SetWindowBoundsFromServer(WindowMus::Get(window_tree_host->window()),
                             window_data.bounds);
+  DCHECK(frame_sink_id.is_valid());
+  WindowMus::Get(window_tree_host->window())

[sky, 2017/03/21 21:12:03]

How come you call this here and not in WindowTreeHostMus's constructor?

[Fady Samuel, 2017/03/21 22:03:29]

Oohh oops, I added this first then later decided to update the constructor since
it's used in more than one place and forgot to delete this redundant call.
Removed

+      ->SetFrameSinkIdFromServer(frame_sink_id);
   return window_tree_host;
 }
 
 WindowMus* WindowTreeClient::NewWindowFromWindowData(
     WindowMus* parent,
     const ui::mojom::WindowData& window_data) {
   // This function is only called for windows coming from other clients.
   std::unique_ptr<WindowPortMus> window_port_mus(
       CreateWindowPortMus(window_data, WindowMusType::OTHER));
   WindowPortMus* window_port_mus_ptr = window_port_mus.get();
@@ skipping 59 matching lines @@
   tree_->SetModalType(change_id, window->server_id(),
                       window->GetWindow()->GetProperty(client::kModalKey));
   return true;
 }
 
 void WindowTreeClient::OnEmbedImpl(ui::mojom::WindowTree* window_tree,
                                    ClientSpecificId client_id,
                                    ui::mojom::WindowDataPtr root_data,
                                    int64_t display_id,
                                    Id focused_window_id,
-                                   bool drawn) {
+                                   bool drawn,
+                                   const cc::FrameSinkId& frame_sink_id) {
   // WARNING: this is only called if WindowTreeClient was created as the
   // result of an embedding.
   client_id_ = client_id;
   WindowTreeConnectionEstablished(window_tree);
 
   DCHECK(roots_.empty());
-  std::unique_ptr<WindowTreeHostMus> window_tree_host =
-      CreateWindowTreeHost(WindowMusType::EMBED, *root_data, display_id);
+  std::unique_ptr<WindowTreeHostMus> window_tree_host = CreateWindowTreeHost(
+      WindowMusType::EMBED, *root_data, display_id, frame_sink_id);
 
   focus_synchronizer_->SetFocusFromServer(
       GetWindowByServerId(focused_window_id));
 
   delegate_->OnEmbed(std::move(window_tree_host));
 }
 
 WindowTreeHostMus* WindowTreeClient::WmNewDisplayAddedImpl(
     const display::Display& display,
     ui::mojom::WindowDataPtr root_data,
-    bool parent_drawn) {
+    bool parent_drawn,
+    const cc::FrameSinkId& frame_sink_id) {
   DCHECK(window_manager_delegate_);
 
   window_manager_delegate_->OnWmWillCreateDisplay(display);
 
-  std::unique_ptr<WindowTreeHostMus> window_tree_host =
-      CreateWindowTreeHost(WindowMusType::DISPLAY, *root_data, display.id());
+  std::unique_ptr<WindowTreeHostMus> window_tree_host = CreateWindowTreeHost(
+      WindowMusType::DISPLAY, *root_data, display.id(), frame_sink_id);
 
   WindowTreeHostMus* window_tree_host_ptr = window_tree_host.get();
   window_manager_delegate_->OnWmNewDisplay(std::move(window_tree_host),
                                            display);
   return window_tree_host_ptr;
 }
 
 std::unique_ptr<EventResultCallback>
 WindowTreeClient::CreateEventResultCallback(int32_t event_id) {
   return base::MakeUnique<EventResultCallback>(
@@ skipping 297 matching lines @@
     ui::mojom::EventTargetingPolicy policy) {
   DCHECK(tree_);
   tree_->SetEventTargetingPolicy(window->server_id(), policy);
 }
 
 void WindowTreeClient::OnEmbed(ClientSpecificId client_id,
                                ui::mojom::WindowDataPtr root_data,
                                ui::mojom::WindowTreePtr tree,
                                int64_t display_id,
                                Id focused_window_id,
-                               bool drawn) {
+                               bool drawn,
+                               const cc::FrameSinkId& frame_sink_id) {
   DCHECK(!tree_ptr_);
   tree_ptr_ = std::move(tree);
 
   is_from_embed_ = true;
 
   if (window_manager_delegate_) {
     tree_ptr_->GetWindowManagerClient(
         MakeRequest(&window_manager_internal_client_));
   }
 
   OnEmbedImpl(tree_ptr_.get(), client_id, std::move(root_data), display_id,
-              focused_window_id, drawn);
+              focused_window_id, drawn, frame_sink_id);
 }
 
 void WindowTreeClient::OnEmbeddedAppDisconnected(Id window_id) {
   WindowMus* window = GetWindowByServerId(window_id);
   if (window)
     window->NotifyEmbeddedAppDisconnected();
 }
 
 void WindowTreeClient::OnUnembed(Id window_id) {
   WindowMus* window = GetWindowByServerId(window_id);
@@ skipping 15 matching lines @@
                                new_capture_window);
   if (ApplyServerChangeToExistingInFlightChange(change))
     return;
 
   capture_synchronizer_->SetCaptureFromServer(new_capture_window);
 }
 
 void WindowTreeClient::OnTopLevelCreated(uint32_t change_id,
                                          ui::mojom::WindowDataPtr data,
                                          int64_t display_id,
-                                         bool drawn) {
+                                         bool drawn,
+                                         const cc::FrameSinkId& frame_sink_id) {
   // 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;
@@ skipping 43 matching lines @@
         GetOldestInFlightChangeMatching(property_change);
     if (current_change) {
       current_change->SetRevertValueFrom(property_change);
     } else {
       window->SetPropertyFromServer(pair.first, &pair.second);
     }
   }
 
   // Top level windows should not have a parent.
   DCHECK_EQ(0u, data->parent_id);
+
+  window->SetFrameSinkIdFromServer(frame_sink_id);
 }
 
 void WindowTreeClient::OnWindowBoundsChanged(
     Id window_id,
     const gfx::Rect& old_bounds,
     const gfx::Rect& new_bounds,
     const base::Optional<cc::LocalSurfaceId>& local_surface_id) {
   WindowMus* window = GetWindowByServerId(window_id);
   if (!window)
     return;
@@ skipping 348 matching lines @@
   // WindowTreeHost.
   GetWindowTreeHostMus(window->GetWindow())->OnCloseRequest();
 }
 
 void WindowTreeClient::OnConnect(ClientSpecificId client_id) {
   client_id_ = client_id;
 }
 
 void WindowTreeClient::WmNewDisplayAdded(const display::Display& display,
                                          ui::mojom::WindowDataPtr root_data,
-                                         bool parent_drawn) {
-  WmNewDisplayAddedImpl(display, std::move(root_data), parent_drawn);
+                                         bool parent_drawn,
+                                         const cc::FrameSinkId& frame_sink_id) {
+  WmNewDisplayAddedImpl(display, std::move(root_data), parent_drawn,
+                        frame_sink_id);
 }
 
 void WindowTreeClient::WmDisplayRemoved(int64_t display_id) {
   DCHECK(window_manager_delegate_);
   for (WindowMus* root : roots_) {
     DCHECK(root->GetWindow()->GetHost());
     WindowTreeHostMus* window_tree_host =
         static_cast<WindowTreeHostMus*>(root->GetWindow()->GetHost());
     if (window_tree_host->display_id() == display_id) {
       window_manager_delegate_->OnWmDisplayRemoved(window_tree_host);
@@ skipping 494 matching lines @@
   return ScheduleInFlightChange(base::MakeUnique<InFlightCaptureChange>(
       this, capture_synchronizer_.get(), window));
 }
 
 uint32_t WindowTreeClient::CreateChangeIdForFocus(WindowMus* window) {
   return ScheduleInFlightChange(base::MakeUnique<InFlightFocusChange>(
       this, focus_synchronizer_.get(), window));
 }
 
 }  // namespace aura