mus-ws: Plumb FrameSinkId to Children

content/renderer/mus/renderer_window_tree_client.h

 // 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.
 
 #ifndef CONTENT_RENDERER_MUS_RENDERER_WINDOW_TREE_CLIENT_H_
 #define CONTENT_RENDERER_MUS_RENDERER_WINDOW_TREE_CLIENT_H_
 
 #include "base/macros.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "services/ui/common/types.h"
 #include "services/ui/public/interfaces/window_tree.mojom.h"
 
 namespace cc {
 class CompositorFrameSink;
 class ContextProvider;
 }
 
 namespace gpu {
 class GpuMemoryBufferManager;
 }
 
-namespace ui {
-class ClientCompositorFrameSinkBinding;
-}
-
 namespace content {
 
 // ui.mojom.WindowTreeClient implementation for RenderWidget. This lives and
 // operates on the renderer's main thread.
 class RendererWindowTreeClient : public ui::mojom::WindowTreeClient {
  public:
   // Creates a RendererWindowTreeClient instance for the RenderWidget instance
   // associated with |routing_id| (if one doesn't already exist). The instance
   // self-destructs when the connection to mus is lost, or when the window is
   // closed.
   static void CreateIfNecessary(int routing_id);
 
   // Destroys the client instance, if one exists. Otherwise, does nothing.
   static void Destroy(int routing_id);
 
   // Returns the RendererWindowTreeClient associated with |routing_id|. Returns
   // nullptr if none exists.
   static RendererWindowTreeClient* Get(int routing_id);
 
   void Bind(ui::mojom::WindowTreeClientRequest request);
 
-  std::unique_ptr<cc::CompositorFrameSink> CreateCompositorFrameSink(
-      const cc::FrameSinkId& frame_sink_id,
+  using CompositorFrameSinkCallback =
+      base::Callback<void(std::unique_ptr<cc::CompositorFrameSink>)>;
+  void RequestCompositorFrameSink(
       scoped_refptr<cc::ContextProvider> context_provider,
-      gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager);
+      gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
+      const CompositorFrameSinkCallback& callback);
 
  private:
   explicit RendererWindowTreeClient(int routing_id);
   ~RendererWindowTreeClient() override;
 
+  void RequestCompositorFrameSinkInternal(
+      scoped_refptr<cc::ContextProvider> context_provider,
+      gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
+      const CompositorFrameSinkCallback& callback);
+
   void DestroySelf();
 
   // ui::mojom::WindowTreeClient:
   // Note: A number of the following are currently not-implemented. Some of
   // these will remain unimplemented in the long-term. Some of the
   // implementations would require some amount of refactoring out of
   // RenderWidget and related classes (e.g. resize, input, ime etc.).
   void OnEmbed(ui::ClientSpecificId client_id,
                ui::mojom::WindowDataPtr root,
                ui::mojom::WindowTreePtr tree,
                int64_t display_id,
                ui::Id focused_window_id,
-               bool drawn) override;
+               bool drawn,
+               const cc::FrameSinkId& frame_sink_id) override;
   void OnEmbeddedAppDisconnected(ui::Id window_id) override;
   void OnUnembed(ui::Id window_id) override;
   void OnCaptureChanged(ui::Id new_capture_window_id,
                         ui::Id old_capture_window_id) override;
   void OnTopLevelCreated(uint32_t change_id,
                          ui::mojom::WindowDataPtr data,
                          int64_t display_id,
-                         bool drawn) override;
+                         bool drawn,
+                         const cc::FrameSinkId& frame_sink_id) override;
   void OnWindowBoundsChanged(
       ui::Id window_id,
       const gfx::Rect& old_bounds,
       const gfx::Rect& new_bounds,
       const base::Optional<cc::LocalSurfaceId>& local_frame_id) override;
   void OnClientAreaChanged(
       uint32_t window_id,
       const gfx::Insets& new_client_area,
       const std::vector<gfx::Rect>& new_additional_client_areas) override;
   void OnTransientWindowAdded(uint32_t window_id,
@@ skipping 55 matching lines @@
                                   uint32_t action_taken) override;
   void OnDragDropDone() override;
   void OnChangeCompleted(uint32_t change_id, bool success) override;
   void RequestClose(uint32_t window_id) override;
   void GetWindowManager(
       mojo::AssociatedInterfaceRequest<ui::mojom::WindowManager> internal)
       override;
 
   const int routing_id_;
   ui::Id root_window_id_;
+  cc::FrameSinkId frame_sink_id_;
+  scoped_refptr<cc::ContextProvider> pending_context_provider_;
+  gpu::GpuMemoryBufferManager* pending_gpu_memory_buffer_manager_ = nullptr;
+  CompositorFrameSinkCallback pending_compositor_frame_sink_callback_;
   ui::mojom::WindowTreePtr tree_;
-  std::unique_ptr<ui::ClientCompositorFrameSinkBinding> pending_frame_sink_;
   mojo::Binding<ui::mojom::WindowTreeClient> binding_;
 
   DISALLOW_COPY_AND_ASSIGN(RendererWindowTreeClient);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_MUS_RENDERER_WINDOW_TREE_CLIENT_H_