Only send the FrameSinkId to client when it is necessary

content/renderer/mus/renderer_window_tree_client.cc

 // Copyright 2017 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 "content/renderer/mus/renderer_window_tree_client.h"
 
 #include <map>
 
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
@@ skipping 35 matching lines @@
 void RendererWindowTreeClient::Bind(
     ui::mojom::WindowTreeClientRequest request) {
   binding_.Bind(std::move(request));
 }
 
 void RendererWindowTreeClient::RequestCompositorFrameSink(
     scoped_refptr<cc::ContextProvider> context_provider,
     gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
     const CompositorFrameSinkCallback& callback) {
   DCHECK(pending_compositor_frame_sink_callback_.is_null());
-  if (frame_sink_id_.is_valid()) {
+  if (tree_) {
     RequestCompositorFrameSinkInternal(std::move(context_provider),
                                        gpu_memory_buffer_manager, callback);
     return;
   }
 
   pending_context_provider_ = std::move(context_provider);
   pending_gpu_memory_buffer_manager_ = gpu_memory_buffer_manager;
   pending_compositor_frame_sink_callback_ = callback;
 }
 
 RendererWindowTreeClient::RendererWindowTreeClient(int routing_id)
     : routing_id_(routing_id), binding_(this) {
 }
 
 RendererWindowTreeClient::~RendererWindowTreeClient() {
   g_connections.Get().erase(routing_id_);
 }
 
 void RendererWindowTreeClient::RequestCompositorFrameSinkInternal(
     scoped_refptr<cc::ContextProvider> context_provider,
     gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
     const CompositorFrameSinkCallback& callback) {
   std::unique_ptr<ui::ClientCompositorFrameSinkBinding> frame_sink_binding;
+  bool enable_surface_synchronization =
+      base::CommandLine::ForCurrentProcess()->HasSwitch(
+          cc::switches::kEnableSurfaceSynchronization);
   auto frame_sink = ui::ClientCompositorFrameSink::Create(
-      frame_sink_id_, std::move(context_provider), gpu_memory_buffer_manager,
-      &frame_sink_binding);
+      std::move(context_provider), gpu_memory_buffer_manager,
+      &frame_sink_binding, enable_surface_synchronization);
   tree_->AttachCompositorFrameSink(
       root_window_id_, frame_sink_binding->TakeFrameSinkRequest(),
       mojo::MakeProxy(frame_sink_binding->TakeFrameSinkClient()));
   callback.Run(std::move(frame_sink));
 }
 
 void RendererWindowTreeClient::DestroySelf() {
   delete this;
 }
 
 void RendererWindowTreeClient::OnEmbed(
     ui::ClientSpecificId client_id,
     ui::mojom::WindowDataPtr root,
     ui::mojom::WindowTreePtr tree,
     int64_t display_id,
     ui::Id focused_window_id,
     bool drawn,
-    const cc::FrameSinkId& frame_sink_id,
     const base::Optional<cc::LocalSurfaceId>& local_surface_id) {
-  frame_sink_id_ = frame_sink_id;
   root_window_id_ = root->window_id;
   tree_ = std::move(tree);
   if (!pending_compositor_frame_sink_callback_.is_null()) {
     RequestCompositorFrameSinkInternal(std::move(pending_context_provider_),
                                        pending_gpu_memory_buffer_manager_,
                                        pending_compositor_frame_sink_callback_);
     pending_context_provider_ = nullptr;
     pending_gpu_memory_buffer_manager_ = nullptr;
     pending_compositor_frame_sink_callback_.Reset();
   }
@@ skipping 16 matching lines @@
     const cc::FrameSinkId& frame_sink_id) {
   // TODO(fsamuel): OOPIF's |frame_sink_id| is ready. The OOPIF can now be
   // embedded by the parent.
 }
 
 void RendererWindowTreeClient::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) {
   NOTREACHED();
 }
 
 void RendererWindowTreeClient::OnWindowBoundsChanged(
     ui::Id window_id,
     const gfx::Rect& old_bounds,
     const gfx::Rect& new_bounds,
     const base::Optional<cc::LocalSurfaceId>& local_surface_id) {
 }
@@ skipping 107 matching lines @@
                                                  bool success) {}
 
 void RendererWindowTreeClient::RequestClose(uint32_t window_id) {}
 
 void RendererWindowTreeClient::GetWindowManager(
     mojo::AssociatedInterfaceRequest<ui::mojom::WindowManager> internal) {
   NOTREACHED();
 }
 
 }  // namespace content