Convert offscreen canvas to use FrameSinkManagerHost.

content/browser/renderer_host/offscreen_canvas_surface_impl.cc

 // Copyright 2016 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/browser/renderer_host/offscreen_canvas_surface_impl.h"
 
 #include <utility>
 
 #include "base/bind_helpers.h"
 #include "base/memory/ptr_util.h"
@@ skipping 10 matching lines @@
     const cc::FrameSinkId& frame_sink_id,
     cc::mojom::DisplayCompositorClientPtr client)
     : client_(std::move(client)),
       frame_sink_id_(frame_sink_id),
       parent_frame_sink_id_(parent_frame_sink_id) {
   OffscreenCanvasCompositorFrameSinkManager::GetInstance()
       ->RegisterOffscreenCanvasSurfaceInstance(frame_sink_id_, this);
 }
 
 OffscreenCanvasSurfaceImpl::~OffscreenCanvasSurfaceImpl() {
-  if (frame_sink_id_.is_valid()) {
-    OffscreenCanvasCompositorFrameSinkManager::GetInstance()
-        ->UnregisterOffscreenCanvasSurfaceInstance(frame_sink_id_);
+  if (has_registered_frame_sink_hierarchy_) {
+    content::GetDisplayCompositor()->UnregisterFrameSinkHierarchy(

[xlai (Olivia), 2017/04/03 15:42:59]

Previously this is done in destroy of OffscreenCanvasCompositorFrameSink.
What happened when CompositorFrameSink is torn down whilst the
OffscreenCanvasSurface is still alive (worker thread dead but main thread
alive)? Then you'll have a (parent_frame_sink_id, child_frame_sink_id) pair in
the frame sink hierarchy of the display compositor such that the parent one is
alive but the child one will point to no compositor frame sink. Will that cause
a problem?

[kylechar, 2017/04/03 16:00:19]

The GpuCompositorFrameSink in DisplayCompositor is only destroyed when both
interfaces (MojoCompositorFrameSink and MojoCompositorFrameSinkPrivate) are
closed. So there will be a GpuCompositorFrameSink until this gets torn down.

I think the only constraints this puts on things are:
1. Renderer closes the OffscreenCanvasSurface connection only after it has
stopped submitting CFs that embed the offscreen canvas SurfaceId. This is
because the heirarchy unregistered here.
2. Renderer doesn't close MojoCompositorFrameSink connection (which I guess
means destroying OffscreenCanvasFrameDispatcherImpl) and then create a new
MojoCompositorFrameSink connection again using the same OffscreenCanvasSurface.

The order in which MojoCompositorFrameSink and OffscreenCanvasSurface
connections are closed shouldn't matter, although I'd assume they would
generally be closed around the same time? It's also possible to have started and
created an OffscreenCanvasSurface connection but never create the
MojoCompositorFrameSink connection associated with it.

+        parent_frame_sink_id_, frame_sink_id_);
   }
+  OffscreenCanvasCompositorFrameSinkManager::GetInstance()
+      ->UnregisterOffscreenCanvasSurfaceInstance(frame_sink_id_);
 }
 
 // static
 void OffscreenCanvasSurfaceImpl::Create(
     const cc::FrameSinkId& parent_frame_sink_id,
     const cc::FrameSinkId& frame_sink_id,
     cc::mojom::DisplayCompositorClientPtr client,
     blink::mojom::OffscreenCanvasSurfaceRequest request) {
   std::unique_ptr<OffscreenCanvasSurfaceImpl> impl =
       base::MakeUnique<OffscreenCanvasSurfaceImpl>(
           parent_frame_sink_id, frame_sink_id, std::move(client));
   OffscreenCanvasSurfaceImpl* surface_service = impl.get();
   surface_service->binding_ =
       mojo::MakeStrongBinding(std::move(impl), std::move(request));
 }
 
+void OffscreenCanvasSurfaceImpl::CreateCompositorFrameSink(
+    cc::mojom::MojoCompositorFrameSinkClientPtr client,
+    cc::mojom::MojoCompositorFrameSinkRequest request) {
+  DCHECK(!compositor_frame_sink_private_.is_bound());
+
+  content::GetDisplayCompositor()->CreateCompositorFrameSink(
+      frame_sink_id_, std::move(request),
+      mojo::MakeRequest(&compositor_frame_sink_private_), std::move(client));
+
+  content::GetDisplayCompositor()->RegisterFrameSinkHierarchy(
+      parent_frame_sink_id_, frame_sink_id_);
+  has_registered_frame_sink_hierarchy_ = true;
+}
+
 void OffscreenCanvasSurfaceImpl::OnSurfaceCreated(
     const cc::SurfaceInfo& surface_info) {
   DCHECK_EQ(surface_info.id().frame_sink_id(), frame_sink_id_);
   if (!current_local_surface_id_.is_valid() ||
       surface_info.id().local_surface_id() != current_local_surface_id_) {
     current_local_surface_id_ = surface_info.id().local_surface_id();
     if (client_)
       client_->OnSurfaceCreated(surface_info);
   }
 }
 
 void OffscreenCanvasSurfaceImpl::Require(const cc::SurfaceId& surface_id,
                                          const cc::SurfaceSequence& sequence) {
   GetSurfaceManager()->RequireSequence(surface_id, sequence);
 }
 
 void OffscreenCanvasSurfaceImpl::Satisfy(const cc::SurfaceSequence& sequence) {
   GetSurfaceManager()->SatisfySequence(sequence);
 }
 
 }  // namespace content