Mus-WS / Aura-Mus: Propagate LocalSurfaceId on WindowTreeHost creation

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 422 matching lines @@
     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,
-    const cc::FrameSinkId& frame_sink_id) {
+    const cc::FrameSinkId& frame_sink_id,
+    const base::Optional<cc::LocalSurfaceId>& local_surface_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, 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, base::nullopt);
+  WindowMus* window = WindowMus::Get(window_tree_host->window());
+
+  SetWindowBoundsFromServer(window, window_data.bounds, local_surface_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 48 matching lines @@
     return false;
 
   const uint32_t change_id =
       ScheduleInFlightChange(base::MakeUnique<InFlightSetModalTypeChange>(
           window, static_cast<ui::ModalType>(old_value)));
   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,
-                                   const cc::FrameSinkId& frame_sink_id) {
+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,
+    const cc::FrameSinkId& frame_sink_id,
+    const base::Optional<cc::LocalSurfaceId>& local_surface_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, frame_sink_id);
+  std::unique_ptr<WindowTreeHostMus> window_tree_host =
+      CreateWindowTreeHost(WindowMusType::EMBED, *root_data, display_id,
+                           frame_sink_id, local_surface_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,
-    const cc::FrameSinkId& frame_sink_id) {
+    const cc::FrameSinkId& frame_sink_id,
+    const base::Optional<cc::LocalSurfaceId>& local_surface_id) {
   DCHECK(window_manager_delegate_);
 
   got_initial_displays_ = true;
 
   window_manager_delegate_->OnWmWillCreateDisplay(display);
 
-  std::unique_ptr<WindowTreeHostMus> window_tree_host = CreateWindowTreeHost(
-      WindowMusType::DISPLAY, *root_data, display.id(), frame_sink_id);
+  std::unique_ptr<WindowTreeHostMus> window_tree_host =
+      CreateWindowTreeHost(WindowMusType::DISPLAY, *root_data, display.id(),
+                           frame_sink_id, local_surface_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 295 matching lines @@
   tree_->SetCanAcceptDrops(window->server_id(), can_accept_drops);
 }
 
 void WindowTreeClient::SetEventTargetingPolicy(
     WindowMus* window,
     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,
-                               const cc::FrameSinkId& frame_sink_id) {
+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,
+    const cc::FrameSinkId& frame_sink_id,
+    const base::Optional<cc::LocalSurfaceId>& local_surface_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, frame_sink_id);
+              focused_window_id, drawn, frame_sink_id, local_surface_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 22 matching lines @@
 void WindowTreeClient::OnFrameSinkIdAllocated(
     Id window_id,
     const cc::FrameSinkId& frame_sink_id) {
   WindowMus* window = GetWindowByServerId(window_id);
   if (!window)
     return;
 
   window->SetFrameSinkIdFromServer(frame_sink_id);
 }
 
-void WindowTreeClient::OnTopLevelCreated(uint32_t change_id,
-                                         ui::mojom::WindowDataPtr data,
-                                         int64_t display_id,
-                                         bool drawn,
-                                         const cc::FrameSinkId& frame_sink_id) {
+void WindowTreeClient::OnTopLevelCreated(
+    uint32_t change_id,
+    ui::mojom::WindowDataPtr data,
+    int64_t display_id,
+    bool drawn,
+    const cc::FrameSinkId& frame_sink_id,
+    const base::Optional<cc::LocalSurfaceId>& local_surface_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 15 matching lines @@
     InFlightChange* current_change =
         GetOldestInFlightChangeMatching(visible_change);
     if (current_change)
       current_change->SetRevertValueFrom(visible_change);
     else
       SetWindowVisibleFromServer(window, true);
   }
 
   const gfx::Rect bounds(data->bounds);
   {
-    // TODO(fsamuel): Propagate a cc::LocalSurfaceId through here.
-    InFlightBoundsChange bounds_change(this, window, bounds, base::nullopt);
+    InFlightBoundsChange bounds_change(this, window, bounds, local_surface_id);
     InFlightChange* current_change =
         GetOldestInFlightChangeMatching(bounds_change);
     if (current_change)
       current_change->SetRevertValueFrom(bounds_change);
     else if (gfx::ConvertRectToPixel(ScaleFactorForDisplay(window->GetWindow()),
-                                     window->GetWindow()->bounds()) != bounds)
-      SetWindowBoundsFromServer(window, bounds, base::nullopt);
+                                     window->GetWindow()->bounds()) != bounds) {
+      SetWindowBoundsFromServer(window, bounds, local_surface_id);
+    }
   }
 
   // There is currently no API to bulk set properties, so we iterate over each
   // property individually.
   for (const auto& pair : data->properties) {
     std::unique_ptr<std::vector<uint8_t>> revert_value(
         base::MakeUnique<std::vector<uint8_t>>(pair.second));
     InFlightPropertyChange property_change(window, pair.first,
                                            std::move(revert_value));
     InFlightChange* current_change =
@@ skipping 379 matching lines @@
   // TODO(sky): having to block here is not ideal. http://crbug.com/594852.
   while (!got_initial_displays_ && valid_wait)
     valid_wait = binding_.WaitForIncomingMethodCall();
   return valid_wait;
 }
 
 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,
-                                         const cc::FrameSinkId& frame_sink_id) {
+void WindowTreeClient::WmNewDisplayAdded(
+    const display::Display& display,
+    ui::mojom::WindowDataPtr root_data,
+    bool parent_drawn,
+    const cc::FrameSinkId& frame_sink_id,
+    const base::Optional<cc::LocalSurfaceId>& local_surface_id) {
   WmNewDisplayAddedImpl(display, std::move(root_data), parent_drawn,
-                        frame_sink_id);
+                        frame_sink_id, local_surface_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 517 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