Aura-Mus: Allocate a LocalSurfaceId on size change

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 461 matching lines @@
   // 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();
   Window* window = new Window(nullptr, std::move(window_port_mus));
   WindowMus* window_mus = window_port_mus_ptr;
   SetWindowTypeFromProperties(window, window_data.properties);
   window->Init(ui::LAYER_NOT_DRAWN);
   SetLocalPropertiesFromServerProperties(window_mus, window_data);
   window_mus->SetBoundsFromServer(
-      gfx::ConvertRectToDIP(ScaleFactorForDisplay(window), window_data.bounds));
+      gfx::ConvertRectToDIP(ScaleFactorForDisplay(window), window_data.bounds),
+      base::nullopt);
   if (parent)
     parent->AddChildFromServer(window_port_mus_ptr);
   if (window_data.visible)
     window_mus->SetVisibleFromServer(true);
   return window_port_mus_ptr;
 }
 
 void WindowTreeClient::SetWindowTree(ui::mojom::WindowTreePtr window_tree_ptr) {
   tree_ptr_ = std::move(window_tree_ptr);
 
@@ skipping 106 matching lines @@
     // WindowTreeHost expects bounds to be in pixels.
     GetWindowTreeHostMus(window)->SetBoundsFromServer(revert_bounds_in_pixels);
     if (enable_surface_synchronization_ && local_surface_id &&
         local_surface_id->is_valid()) {
       window->GetWindow()->GetHost()->compositor()->SetLocalSurfaceId(
           *local_surface_id);
     }
     return;
   }
 
-  window->SetBoundsFromServer(gfx::ConvertRectToDIP(
-      ScaleFactorForDisplay(window->GetWindow()), revert_bounds_in_pixels));
+  window->SetBoundsFromServer(
+      gfx::ConvertRectToDIP(ScaleFactorForDisplay(window->GetWindow()),
+                            revert_bounds_in_pixels),
+      local_surface_id);
 }
 
 void WindowTreeClient::SetWindowVisibleFromServer(WindowMus* window,
                                                   bool visible) {
   if (!IsRoot(window)) {
     window->SetVisibleFromServer(visible);
     return;
   }
 
   std::unique_ptr<WindowMusChangeData> data =
       window->PrepareForServerVisibilityChange(visible);
   WindowTreeHostMus* window_tree_host = GetWindowTreeHostMus(window);
   if (visible)
     window_tree_host->Show();
   else
     window_tree_host->Hide();
 }
 
 void WindowTreeClient::ScheduleInFlightBoundsChange(
     WindowMus* window,
     const gfx::Rect& old_bounds,
     const gfx::Rect& new_bounds) {
-  // TODO(fsamuel): Allocate a new LocalSurfaceId on size change.
   const uint32_t change_id =
       ScheduleInFlightChange(base::MakeUnique<InFlightBoundsChange>(
-          this, window, old_bounds, base::nullopt));
+          this, window, old_bounds, window->GetLocalSurfaceId()));
+  base::Optional<cc::LocalSurfaceId> local_surface_id;
+  if ((window->window_mus_type() == WindowMusType::TOP_LEVEL_IN_WM ||
+       window->window_mus_type() == WindowMusType::EMBED_IN_OWNER)) {
+    local_surface_id = window->GetOrAllocateLocalSurfaceId(new_bounds.size());
+  }
   tree_->SetWindowBounds(change_id, window->server_id(), new_bounds,
-                         base::nullopt);
+                         local_surface_id);
 }
 
 void WindowTreeClient::OnWindowMusCreated(WindowMus* window) {
   if (window->server_id() != kInvalidServerId)
     return;
 
   window->set_server_id(MakeTransportId(client_id_, next_window_id_++));
   RegisterWindowMus(window);
 
   DCHECK(window_manager_delegate_ || !IsRoot(window));
@@ skipping 1292 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