mus-ws: Plumb FrameSinkId to Children

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/lazy_instance.h"
 #include "services/ui/public/cpp/client_compositor_frame_sink.h"
@@ skipping 23 matching lines @@
   g_connections.Get().insert(std::make_pair(routing_id, connection));
 }
 
 // static
 void RendererWindowTreeClient::Destroy(int routing_id) {
   auto* client = Get(routing_id);
   if (client)
     client->DestroySelf();
 }
 
+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()) {
+    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::Bind(
-    ui::mojom::WindowTreeClientRequest request) {
-  binding_.Bind(std::move(request));
-}
-
-std::unique_ptr<cc::CompositorFrameSink>
-RendererWindowTreeClient::CreateCompositorFrameSink(
-    const cc::FrameSinkId& frame_sink_id,
+void RendererWindowTreeClient::RequestCompositorFrameSinkInternal(
     scoped_refptr<cc::ContextProvider> context_provider,
-    gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager) {
+    gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
+    const CompositorFrameSinkCallback& callback) {
   std::unique_ptr<ui::ClientCompositorFrameSinkBinding> frame_sink_binding;
   auto frame_sink = ui::ClientCompositorFrameSink::Create(
-      frame_sink_id, std::move(context_provider), gpu_memory_buffer_manager,
+      frame_sink_id_, std::move(context_provider), gpu_memory_buffer_manager,
       &frame_sink_binding);
-  if (tree_) {
-    tree_->AttachCompositorFrameSink(
-        root_window_id_, frame_sink_binding->TakeFrameSinkRequest(),
-        mojo::MakeProxy(frame_sink_binding->TakeFrameSinkClient()));
-  } else {
-    pending_frame_sink_ = std::move(frame_sink_binding);
-  }
-  return std::move(frame_sink);
+  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) {
+                                       bool drawn,
+                                       const cc::FrameSinkId& frame_sink_id) {
+  frame_sink_id_ = frame_sink_id;
   root_window_id_ = root->window_id;
   tree_ = std::move(tree);
-  if (pending_frame_sink_) {
-    tree_->AttachCompositorFrameSink(
-        root_window_id_, pending_frame_sink_->TakeFrameSinkRequest(),
-        mojo::MakeProxy(pending_frame_sink_->TakeFrameSinkClient()));
-    pending_frame_sink_ = nullptr;
+  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();
   }
 }
 
 void RendererWindowTreeClient::OnEmbeddedAppDisconnected(ui::Id window_id) {
   // TODO(sad): Embedded mus-client (oopif) is gone. Figure out what to do.
 }
 
 void RendererWindowTreeClient::OnUnembed(ui::Id window_id) {
   CHECK_EQ(window_id, root_window_id_);
   DestroySelf();
 }
 
 void RendererWindowTreeClient::OnCaptureChanged(ui::Id new_capture_window_id,
                                                 ui::Id old_capture_window_id) {}
 
-void RendererWindowTreeClient::OnTopLevelCreated(uint32_t change_id,
-                                                 ui::mojom::WindowDataPtr data,
-                                                 int64_t display_id,
-                                                 bool drawn) {
+void RendererWindowTreeClient::OnTopLevelCreated(
+    uint32_t change_id,
+    ui::mojom::WindowDataPtr data,
+    int64_t display_id,
+    bool drawn,
+    const cc::FrameSinkId& frame_sink_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) {}
 
 void RendererWindowTreeClient::OnClientAreaChanged(
@@ skipping 106 matching lines @@
                                                  bool success) {}
 
 void RendererWindowTreeClient::RequestClose(uint32_t window_id) {}
 
 void RendererWindowTreeClient::GetWindowManager(
     mojo::AssociatedInterfaceRequest<ui::mojom::WindowManager> internal) {
   NOTREACHED();
 }
 
 }  // namespace content