Aura-Mus: Plumb LocalSurfaceId to ui::Compositor

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>
 #include <vector>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
+#include "base/command_line.h"
 #include "base/memory/ptr_util.h"
 #include "base/threading/thread.h"
+#include "cc/base/switches.h"
 #include "components/discardable_memory/client/client_discardable_shared_memory_manager.h"
 #include "mojo/public/cpp/bindings/map.h"
 #include "services/service_manager/public/cpp/connector.h"
 #include "services/ui/common/accelerator_util.h"
 #include "services/ui/public/cpp/gpu/gpu.h"
 #include "services/ui/public/cpp/property_type_converters.h"
 #include "services/ui/public/interfaces/constants.mojom.h"
 #include "services/ui/public/interfaces/window_manager.mojom.h"
 #include "services/ui/public/interfaces/window_manager_window_tree_factory.mojom.h"
 #include "ui/aura/client/aura_constants.h"
@@ skipping 189 matching lines @@
     if (create_discardable_memory) {
       discardable_memory::mojom::DiscardableSharedMemoryManagerPtr manager_ptr;
       connector->BindInterface(ui::mojom::kServiceName, &manager_ptr);
       discardable_shared_memory_manager_ = base::MakeUnique<
           discardable_memory::ClientDiscardableSharedMemoryManager>(
           std::move(manager_ptr), std::move(io_task_runner));
       base::DiscardableMemoryAllocator::SetInstance(
           discardable_shared_memory_manager_.get());
     }
   }
+  enable_surface_synchronization_ =
+      base::CommandLine::ForCurrentProcess()->HasSwitch(
+          cc::switches::kEnableSurfaceSynchronization);
 }
 
 WindowTreeClient::~WindowTreeClient() {
   in_destructor_ = true;
 
   if (discardable_shared_memory_manager_)
     base::DiscardableMemoryAllocator::SetInstance(nullptr);
 
   for (WindowTreeClientObserver& observer : observers_)
     observer.OnWillDestroyClient(this);
@@ skipping 350 matching lines @@
   DCHECK(cursor_location_mapping_);
 }
 
 void WindowTreeClient::SetWindowBoundsFromServer(
     WindowMus* window,
     const gfx::Rect& revert_bounds_in_pixels,
     const base::Optional<cc::LocalSurfaceId>& local_surface_id) {
   if (IsRoot(window)) {
     // WindowTreeHost expects bounds to be in pixels.
     GetWindowTreeHostMus(window)->SetBoundsFromServer(revert_bounds_in_pixels);
-    // TODO(fsamuel): Propagate |local_surface_id| to ui::Compositor.
+    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));
 }
 
 void WindowTreeClient::SetWindowVisibleFromServer(WindowMus* window,
                                                   bool visible) {
   if (!IsRoot(window)) {
@@ skipping 1325 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