Rename content/browser/render_host/OffscreenCanvas*

Rename OffscreenCanvas* files in content to better match what they are,
a generic embedded frame sink for the renderer. The implementation was
originally written for offscreen canvas but now has multiple uses.

This CL is just a rename of classes, files and member variables. The
main renames are as follows:

OffscreenCanvasSurfaceImpl -> EmbeddedFrameSinkImpl
OffscreenCanvasProviderImpl -> EmbeddedFrameSinkProviderImpl
OffscreenCanvasProviderImplTest -> EmbeddedFrameSinkProviderImplTest
mojom::OffscreenCanvasProvider -> mojom::EmbeddedFrameSinkProvider
mojom::OffscreenCanvasSurfaceClient -> mojom::EmbeddedFrameSinkClient

Member variables and files are renamed to match as well.

Bug: none
Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_layout_tests_slimming_paint_v2
Change-Id: I6889c94aacc91a7787606b062822e8ad9461338b
Reviewed-on: https://chromium-review.googlesource.com/1020184
Commit-Queue: kylechar <kylechar@chromium.org>
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Reviewed-by: Fernando Serboncini <fserb@chromium.org>
Reviewed-by: Ken Buchanan <kenrb@chromium.org>
Reviewed-by: Antoine Labour <piman@chromium.org>
Reviewed-by: Olivia Lai <xlai@chromium.org>
Reviewed-by: Justin Novosad <junov@chromium.org>
Cr-Commit-Position: refs/heads/master@{#555490}

content/browser/BUILD.gn

@@ -204,8 +204,8 @@ jumbo_source_set("browser") {
     ":accessibility_buildflags",
     "//ipc",
     "//media/mojo/interfaces:remoting",
+    "//third_party/blink/public:embedded_frame_sink_mojo_bindings",
     "//third_party/blink/public:media_devices_mojo_bindings",
-    "//third_party/blink/public:offscreen_canvas_mojo_bindings",
     "//third_party/leveldatabase",
   ]
 
@@ -1215,6 +1215,10 @@ jumbo_source_set("browser") {
     "renderer_host/display_util.h",
     "renderer_host/dwrite_font_proxy_message_filter_win.cc",
     "renderer_host/dwrite_font_proxy_message_filter_win.h",
+    "renderer_host/embedded_frame_sink_impl.cc",
+    "renderer_host/embedded_frame_sink_impl.h",
+    "renderer_host/embedded_frame_sink_provider_impl.cc",
+    "renderer_host/embedded_frame_sink_provider_impl.h",
     "renderer_host/event_with_latency_info.h",
     "renderer_host/file_utilities_host_impl.cc",
     "renderer_host/file_utilities_host_impl.h",
@@ -1380,10 +1384,6 @@ jumbo_source_set("browser") {
     "renderer_host/media/video_capture_provider_switcher.h",
     "renderer_host/native_web_keyboard_event_aura.cc",
     "renderer_host/native_web_keyboard_event_mac.mm",
-    "renderer_host/offscreen_canvas_provider_impl.cc",
-    "renderer_host/offscreen_canvas_provider_impl.h",
-    "renderer_host/offscreen_canvas_surface_impl.cc",
-    "renderer_host/offscreen_canvas_surface_impl.h",
     "renderer_host/overscroll_configuration.cc",
     "renderer_host/overscroll_controller.cc",
     "renderer_host/overscroll_controller.h",

content/browser/DEPS

@@ -133,7 +133,7 @@ include_rules = [
   "+third_party/blink/public/platform/modules/mediasession/media_session.mojom.h",
   "+third_party/blink/public/platform/modules/mediastream/media_devices.mojom.h",
   "+third_party/blink/public/platform/modules/notifications/notification_service.mojom.h",
-  "+third_party/blink/public/platform/modules/offscreencanvas/offscreen_canvas_surface.mojom.h",
+  "+third_party/blink/public/platform/modules/frame_sinks/embedded_frame_sink.mojom.h",
   "+third_party/blink/public/platform/modules/payments/payment_app.mojom.h",
   "+third_party/blink/public/platform/modules/permissions/permission.mojom.h",
   "+third_party/blink/public/platform/modules/permissions/permission_status.mojom.h",

content/browser/renderer_host/OWNERS

@@ -27,9 +27,10 @@ per-file database_*=jsbell@chromium.org
 per-file database_*=michaeln@chromium.org
 per-file database_*=pwnall@chromium.org
 
-# Offscreen Canvas
-per-file offscreen_canvas*.*=xlai@chromium.org
-per-file offscreen_canvas*.*=xidachen@chromium.org
-per-file offscreen_canvas*.*=junov@chromium.org
+# Embedded Frame Sinks (eg. Offscreen Canvas)
+per-file embedded_frame_sink*.*=xlai@chromium.org
+per-file embedded_frame_sink*.*=xidachen@chromium.org
+per-file embedded_frame_sink*.*=junov@chromium.org
+per-file embedded_frame_sink*.*=kylechar@chromium.org
 
 # COMPONENT: Internals>Core

content/browser/renderer_host/offscreen_canvas_surface_impl.cc → content/browser/renderer_host/embedded_frame_sink_impl.cc

@@ -2,7 +2,7 @@
 // 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 "content/browser/renderer_host/embedded_frame_sink_impl.h"
 
 #include <memory>
 #include <utility>
@@ -14,11 +14,11 @@
 
 namespace content {
 
-OffscreenCanvasSurfaceImpl::OffscreenCanvasSurfaceImpl(
+EmbeddedFrameSinkImpl::EmbeddedFrameSinkImpl(
     viz::HostFrameSinkManager* host_frame_sink_manager,
     const viz::FrameSinkId& parent_frame_sink_id,
     const viz::FrameSinkId& frame_sink_id,
-    blink::mojom::OffscreenCanvasSurfaceClientPtr client,
+    blink::mojom::EmbeddedFrameSinkClientPtr client,
     DestroyCallback destroy_callback)
     : host_frame_sink_manager_(host_frame_sink_manager),
       client_(std::move(client)),
@@ -26,11 +26,11 @@ OffscreenCanvasSurfaceImpl::OffscreenCanvasSurfaceImpl(
       frame_sink_id_(frame_sink_id) {
   client_.set_connection_error_handler(std::move(destroy_callback));
   host_frame_sink_manager_->RegisterFrameSinkId(frame_sink_id_, this);
-  host_frame_sink_manager_->SetFrameSinkDebugLabel(
-      frame_sink_id_, "OffscreenCanvasSurfaceImpl");
+  host_frame_sink_manager_->SetFrameSinkDebugLabel(frame_sink_id_,
+                                                   "EmbeddedFrameSinkImpl");
 }
 
-OffscreenCanvasSurfaceImpl::~OffscreenCanvasSurfaceImpl() {
+EmbeddedFrameSinkImpl::~EmbeddedFrameSinkImpl() {
   if (has_created_compositor_frame_sink_) {
     host_frame_sink_manager_->UnregisterFrameSinkHierarchy(
         parent_frame_sink_id_, frame_sink_id_);
@@ -38,7 +38,7 @@ OffscreenCanvasSurfaceImpl::~OffscreenCanvasSurfaceImpl() {
   host_frame_sink_manager_->InvalidateFrameSinkId(frame_sink_id_);
 }
 
-void OffscreenCanvasSurfaceImpl::CreateCompositorFrameSink(
+void EmbeddedFrameSinkImpl::CreateCompositorFrameSink(
     viz::mojom::CompositorFrameSinkClientPtr client,
     viz::mojom::CompositorFrameSinkRequest request) {
   if (has_created_compositor_frame_sink_) {
@@ -46,7 +46,7 @@ void OffscreenCanvasSurfaceImpl::CreateCompositorFrameSink(
     return;
   }
 
-  // The request to create an embedded surface and the lifetime of the parent
+  // The request to create an embedded frame sink and the lifetime of the parent
   // are controlled by different IPC channels. It's possible the parent
   // FrameSinkId has been invalidated by the time this request has arrived. In
   // that case, drop the request since there is no embedder.
@@ -61,7 +61,7 @@ void OffscreenCanvasSurfaceImpl::CreateCompositorFrameSink(
   has_created_compositor_frame_sink_ = true;
 }
 
-void OffscreenCanvasSurfaceImpl::OnFirstSurfaceActivation(
+void EmbeddedFrameSinkImpl::OnFirstSurfaceActivation(
     const viz::SurfaceInfo& surface_info) {
   DCHECK_EQ(surface_info.id().frame_sink_id(), frame_sink_id_);
 
@@ -70,7 +70,7 @@ void OffscreenCanvasSurfaceImpl::OnFirstSurfaceActivation(
     client_->OnFirstSurfaceActivation(surface_info);
 }
 
-void OffscreenCanvasSurfaceImpl::OnFrameTokenChanged(uint32_t frame_token) {
+void EmbeddedFrameSinkImpl::OnFrameTokenChanged(uint32_t frame_token) {
   // TODO(yiyix, fsamuel): To complete plumbing of frame tokens for offscreen
   // canvas
 }

content/browser/renderer_host/offscreen_canvas_surface_impl.h → content/browser/renderer_host/embedded_frame_sink_impl.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CONTENT_BROWSER_RENDERER_HOST_OFFSCREEN_CANVAS_SURFACE_IMPL_H_
-#define CONTENT_BROWSER_RENDERER_HOST_OFFSCREEN_CANVAS_SURFACE_IMPL_H_
+#ifndef CONTENT_BROWSER_RENDERER_HOST_EMBEDDED_FRAME_SINK_IMPL_H_
+#define CONTENT_BROWSER_RENDERER_HOST_EMBEDDED_FRAME_SINK_IMPL_H_
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
@@ -12,7 +12,7 @@
 #include "components/viz/host/host_frame_sink_client.h"
 #include "content/common/content_export.h"
 #include "mojo/public/cpp/bindings/binding.h"
-#include "third_party/blink/public/platform/modules/offscreencanvas/offscreen_canvas_surface.mojom.h"
+#include "third_party/blink/public/platform/modules/frame_sinks/embedded_frame_sink.mojom.h"
 
 namespace viz {
 class HostFrameSinkManager;
@@ -20,32 +20,28 @@ class HostFrameSinkManager;
 
 namespace content {
 
-// The browser owned object for an embedded surface in a renderer process. Both
-// the embedder and embedded surface are in the same renderer. Holds a client
-// connection to the renderer that is notified when a new SurfaceId activates
-// for the embedded surface.
-class CONTENT_EXPORT OffscreenCanvasSurfaceImpl
-    : public viz::HostFrameSinkClient {
+// The browser owned object for an embedded frame sink in a renderer process.
+// Both the embedder and embedded frame sink are in the same renderer. Holds a
+// client connection to the renderer that is notified when a new SurfaceId
+// activates for the embedded frame sink.
+class CONTENT_EXPORT EmbeddedFrameSinkImpl : public viz::HostFrameSinkClient {
  public:
   using DestroyCallback = base::OnceCallback<void()>;
 
-  OffscreenCanvasSurfaceImpl(
-      viz::HostFrameSinkManager* host_frame_sink_manager,
-      const viz::FrameSinkId& parent_frame_sink_id,
-      const viz::FrameSinkId& frame_sink_id,
-      blink::mojom::OffscreenCanvasSurfaceClientPtr client,
-      DestroyCallback destroy_callback);
-  ~OffscreenCanvasSurfaceImpl() override;
+  EmbeddedFrameSinkImpl(viz::HostFrameSinkManager* host_frame_sink_manager,
+                        const viz::FrameSinkId& parent_frame_sink_id,
+                        const viz::FrameSinkId& frame_sink_id,
+                        blink::mojom::EmbeddedFrameSinkClientPtr client,
+                        DestroyCallback destroy_callback);
+  ~EmbeddedFrameSinkImpl() override;
 
   const viz::FrameSinkId& frame_sink_id() const { return frame_sink_id_; }
   const viz::LocalSurfaceId& local_surface_id() const {
     return local_surface_id_;
   }
 
-  // Creates a CompositorFrameSink connection to FrameSinkManagerImpl for an
-  // offscreen canvas client. The corresponding private interface will be owned
-  // here to control CompositorFrameSink lifetime. This should only ever be
-  // called once.
+  // Creates a CompositorFrameSink connection to FrameSinkManagerImpl. This
+  // should only ever be called once.
   void CreateCompositorFrameSink(
       viz::mojom::CompositorFrameSinkClientPtr client,
       viz::mojom::CompositorFrameSinkRequest request);
@@ -57,7 +53,7 @@ class CONTENT_EXPORT OffscreenCanvasSurfaceImpl
  private:
   viz::HostFrameSinkManager* const host_frame_sink_manager_;
 
-  blink::mojom::OffscreenCanvasSurfaceClientPtr client_;
+  blink::mojom::EmbeddedFrameSinkClientPtr client_;
 
   // Surface-related state
   const viz::FrameSinkId parent_frame_sink_id_;
@@ -66,9 +62,9 @@ class CONTENT_EXPORT OffscreenCanvasSurfaceImpl
 
   bool has_created_compositor_frame_sink_ = false;
 
-  DISALLOW_COPY_AND_ASSIGN(OffscreenCanvasSurfaceImpl);
+  DISALLOW_COPY_AND_ASSIGN(EmbeddedFrameSinkImpl);
 };
 
 }  // namespace content
 
-#endif  // CONTENT_BROWSER_RENDERER_HOST_OFFSCREEN_CANVAS_SURFACE_IMPL_H_
+#endif  // CONTENT_BROWSER_RENDERER_HOST_EMBEDDED_FRAME_SINK_IMPL_H_

content/browser/renderer_host/offscreen_canvas_provider_impl.cc → content/browser/renderer_host/embedded_frame_sink_provider_impl.cc

@@ -2,31 +2,31 @@
 // 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_provider_impl.h"
+#include "content/browser/renderer_host/embedded_frame_sink_provider_impl.h"
 
 #include "base/bind.h"
 #include "components/viz/host/host_frame_sink_manager.h"
-#include "content/browser/renderer_host/offscreen_canvas_surface_impl.h"
+#include "content/browser/renderer_host/embedded_frame_sink_impl.h"
 
 namespace content {
 
-OffscreenCanvasProviderImpl::OffscreenCanvasProviderImpl(
+EmbeddedFrameSinkProviderImpl::EmbeddedFrameSinkProviderImpl(
     viz::HostFrameSinkManager* host_frame_sink_manager,
     uint32_t renderer_client_id)
     : host_frame_sink_manager_(host_frame_sink_manager),
       renderer_client_id_(renderer_client_id) {}
 
-OffscreenCanvasProviderImpl::~OffscreenCanvasProviderImpl() = default;
+EmbeddedFrameSinkProviderImpl::~EmbeddedFrameSinkProviderImpl() = default;
 
-void OffscreenCanvasProviderImpl::Add(
-    blink::mojom::OffscreenCanvasProviderRequest request) {
+void EmbeddedFrameSinkProviderImpl::Add(
+    blink::mojom::EmbeddedFrameSinkProviderRequest request) {
   bindings_.AddBinding(this, std::move(request));
 }
 
-void OffscreenCanvasProviderImpl::CreateOffscreenCanvasSurface(
+void EmbeddedFrameSinkProviderImpl::RegisterEmbeddedFrameSink(
     const viz::FrameSinkId& parent_frame_sink_id,
     const viz::FrameSinkId& frame_sink_id,
-    blink::mojom::OffscreenCanvasSurfaceClientPtr client) {
+    blink::mojom::EmbeddedFrameSinkClientPtr client) {
   // TODO(kylechar): Kill the renderer too.
   if (parent_frame_sink_id.client_id() != renderer_client_id_) {
     DLOG(ERROR) << "Invalid parent client id " << parent_frame_sink_id;
@@ -37,16 +37,16 @@ void OffscreenCanvasProviderImpl::CreateOffscreenCanvasSurface(
     return;
   }
 
-  auto destroy_callback = base::BindOnce(
-      &OffscreenCanvasProviderImpl::DestroyOffscreenCanvasSurface,
-      base::Unretained(this), frame_sink_id);
+  auto destroy_callback =
+      base::BindOnce(&EmbeddedFrameSinkProviderImpl::DestroyEmbeddedFrameSink,
+                     base::Unretained(this), frame_sink_id);
 
-  canvas_map_[frame_sink_id] = std::make_unique<OffscreenCanvasSurfaceImpl>(
+  frame_sink_map_[frame_sink_id] = std::make_unique<EmbeddedFrameSinkImpl>(
       host_frame_sink_manager_, parent_frame_sink_id, frame_sink_id,
       std::move(client), std::move(destroy_callback));
 }
 
-void OffscreenCanvasProviderImpl::CreateCompositorFrameSink(
+void EmbeddedFrameSinkProviderImpl::CreateCompositorFrameSink(
     const viz::FrameSinkId& frame_sink_id,
     viz::mojom::CompositorFrameSinkClientPtr client,
     viz::mojom::CompositorFrameSinkRequest request) {
@@ -56,9 +56,9 @@ void OffscreenCanvasProviderImpl::CreateCompositorFrameSink(
     return;
   }
 
-  auto iter = canvas_map_.find(frame_sink_id);
-  if (iter == canvas_map_.end()) {
-    DLOG(ERROR) << "No OffscreenCanvasSurfaceImpl for " << frame_sink_id;
+  auto iter = frame_sink_map_.find(frame_sink_id);
+  if (iter == frame_sink_map_.end()) {
+    DLOG(ERROR) << "No EmbeddedFrameSinkImpl for " << frame_sink_id;
     return;
   }
 
@@ -66,21 +66,22 @@ void OffscreenCanvasProviderImpl::CreateCompositorFrameSink(
                                           std::move(request));
 }
 
-void OffscreenCanvasProviderImpl::CreateSimpleCompositorFrameSink(
+void EmbeddedFrameSinkProviderImpl::CreateSimpleCompositorFrameSink(
     const viz::FrameSinkId& parent_frame_sink_id,
     const viz::FrameSinkId& frame_sink_id,
-    blink::mojom::OffscreenCanvasSurfaceClientPtr surface_client,
-    viz::mojom::CompositorFrameSinkClientPtr client,
-    viz::mojom::CompositorFrameSinkRequest request) {
-  CreateOffscreenCanvasSurface(parent_frame_sink_id, frame_sink_id,
-                               std::move(surface_client));
-  CreateCompositorFrameSink(frame_sink_id, std::move(client),
-                            std::move(request));
+    blink::mojom::EmbeddedFrameSinkClientPtr embedded_frame_sink_client,
+    viz::mojom::CompositorFrameSinkClientPtr compositor_frame_sink_client,
+    viz::mojom::CompositorFrameSinkRequest compositor_frame_sink_request) {
+  RegisterEmbeddedFrameSink(parent_frame_sink_id, frame_sink_id,
+                            std::move(embedded_frame_sink_client));
+  CreateCompositorFrameSink(frame_sink_id,
+                            std::move(compositor_frame_sink_client),
+                            std::move(compositor_frame_sink_request));
 }
 
-void OffscreenCanvasProviderImpl::DestroyOffscreenCanvasSurface(
+void EmbeddedFrameSinkProviderImpl::DestroyEmbeddedFrameSink(
     viz::FrameSinkId frame_sink_id) {
-  canvas_map_.erase(frame_sink_id);
+  frame_sink_map_.erase(frame_sink_id);
 }
 
 }  // namespace content

content/browser/renderer_host/offscreen_canvas_provider_impl.h → content/browser/renderer_host/embedded_frame_sink_provider_impl.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CONTENT_BROWSER_RENDERER_HOST_OFFSCREEN_CANVAS_PROVIDER_IMPL_H_
-#define CONTENT_BROWSER_RENDERER_HOST_OFFSCREEN_CANVAS_PROVIDER_IMPL_H_
+#ifndef CONTENT_BROWSER_RENDERER_HOST_EMBEDDED_FRAME_SINK_PROVIDER_IMPL_H_
+#define CONTENT_BROWSER_RENDERER_HOST_EMBEDDED_FRAME_SINK_PROVIDER_IMPL_H_
 
 #include <memory>
 
@@ -11,7 +11,7 @@
 #include "components/viz/common/surfaces/frame_sink_id.h"
 #include "content/common/content_export.h"
 #include "mojo/public/cpp/bindings/binding_set.h"
-#include "third_party/blink/public/platform/modules/offscreencanvas/offscreen_canvas_surface.mojom.h"
+#include "third_party/blink/public/platform/modules/frame_sinks/embedded_frame_sink.mojom.h"
 
 namespace viz {
 class HostFrameSinkManager;
@@ -19,24 +19,24 @@ class HostFrameSinkManager;
 
 namespace content {
 
-class OffscreenCanvasSurfaceImpl;
+class EmbeddedFrameSinkImpl;
 
-// Creates OffscreenCanvasSurfaces and CompositorFrameSinks for a renderer.
-class CONTENT_EXPORT OffscreenCanvasProviderImpl
-    : public blink::mojom::OffscreenCanvasProvider {
+// Provides embedded frame sinks for a renderer.
+class CONTENT_EXPORT EmbeddedFrameSinkProviderImpl
+    : public blink::mojom::EmbeddedFrameSinkProvider {
  public:
-  OffscreenCanvasProviderImpl(
+  EmbeddedFrameSinkProviderImpl(
       viz::HostFrameSinkManager* host_frame_sink_manager,
       uint32_t renderer_client_id);
-  ~OffscreenCanvasProviderImpl() override;
+  ~EmbeddedFrameSinkProviderImpl() override;
 
-  void Add(blink::mojom::OffscreenCanvasProviderRequest request);
+  void Add(blink::mojom::EmbeddedFrameSinkProviderRequest request);
 
-  // blink::mojom::OffscreenCanvasProvider implementation.
-  void CreateOffscreenCanvasSurface(
+  // blink::mojom::EmbeddedFrameSinkProvider implementation.
+  void RegisterEmbeddedFrameSink(
       const viz::FrameSinkId& parent_frame_sink_id,
       const viz::FrameSinkId& frame_sink_id,
-      blink::mojom::OffscreenCanvasSurfaceClientPtr client) override;
+      blink::mojom::EmbeddedFrameSinkClientPtr client) override;
   void CreateCompositorFrameSink(
       const viz::FrameSinkId& frame_sink_id,
       viz::mojom::CompositorFrameSinkClientPtr client,
@@ -44,30 +44,31 @@ class CONTENT_EXPORT OffscreenCanvasProviderImpl
   void CreateSimpleCompositorFrameSink(
       const viz::FrameSinkId& parent_frame_sink_id,
       const viz::FrameSinkId& frame_sink_id,
-      blink::mojom::OffscreenCanvasSurfaceClientPtr surface_client,
-      viz::mojom::CompositorFrameSinkClientPtr client,
-      viz::mojom::CompositorFrameSinkRequest request) override;
+      blink::mojom::EmbeddedFrameSinkClientPtr embedded_frame_sink_client,
+      viz::mojom::CompositorFrameSinkClientPtr compositor_frame_sink_client,
+      viz::mojom::CompositorFrameSinkRequest compositor_frame_sink_request)
+      override;
 
  private:
-  friend class OffscreenCanvasProviderImplTest;
+  friend class EmbeddedFrameSinkProviderImplTest;
 
-  // Destroys the |canvas_map_| entry for |frame_sink_id|. Provided as a
-  // callback to each OffscreenCanvasSurfaceImpl so they can destroy themselves.
-  void DestroyOffscreenCanvasSurface(viz::FrameSinkId frame_sink_id);
+  // Destroys the |frame_sink_map_| entry for |frame_sink_id|. Provided as
+  // a callback to each EmbeddedFrameSinkImpl so they can destroy themselves.
+  void DestroyEmbeddedFrameSink(viz::FrameSinkId frame_sink_id);
 
   viz::HostFrameSinkManager* const host_frame_sink_manager_;
 
-  // FrameSinkIds for offscreen canvas must use the renderer client id.
+  // FrameSinkIds for embedded frame sinks must use the renderer client id.
   const uint32_t renderer_client_id_;
 
-  mojo::BindingSet<blink::mojom::OffscreenCanvasProvider> bindings_;
+  mojo::BindingSet<blink::mojom::EmbeddedFrameSinkProvider> bindings_;
 
-  base::flat_map<viz::FrameSinkId, std::unique_ptr<OffscreenCanvasSurfaceImpl>>
-      canvas_map_;
+  base::flat_map<viz::FrameSinkId, std::unique_ptr<EmbeddedFrameSinkImpl>>
+      frame_sink_map_;
 
-  DISALLOW_COPY_AND_ASSIGN(OffscreenCanvasProviderImpl);
+  DISALLOW_COPY_AND_ASSIGN(EmbeddedFrameSinkProviderImpl);
 };
 
 }  // namespace content
 
-#endif  // CONTENT_BROWSER_RENDERER_HOST_OFFSCREEN_CANVAS_PROVIDER_IMPL_H_
+#endif  // CONTENT_BROWSER_RENDERER_HOST_EMBEDDED_FRAME_SINK_PROVIDER_IMPL_H_

content/browser/renderer_host/render_process_host_impl.cc

@@ -109,12 +109,12 @@
 #include "content/browser/permissions/permission_service_impl.h"
 #include "content/browser/push_messaging/push_messaging_manager.h"
 #include "content/browser/renderer_host/clipboard_host_impl.h"
+#include "content/browser/renderer_host/embedded_frame_sink_provider_impl.h"
 #include "content/browser/renderer_host/file_utilities_host_impl.h"
 #include "content/browser/renderer_host/media/media_stream_manager.h"
 #include "content/browser/renderer_host/media/peer_connection_tracker_host.h"
 #include "content/browser/renderer_host/media/render_frame_audio_input_stream_factory.h"
 #include "content/browser/renderer_host/media/video_capture_host.h"
-#include "content/browser/renderer_host/offscreen_canvas_provider_impl.h"
 #include "content/browser/renderer_host/pepper/pepper_message_filter.h"
 #include "content/browser/renderer_host/pepper/pepper_renderer_connection.h"
 #include "content/browser/renderer_host/render_message_filter.h"
@@ -1910,7 +1910,7 @@ void RenderProcessHostImpl::RegisterMojoInterfaces() {
 
   AddUIThreadInterface(
       registry.get(),
-      base::Bind(&RenderProcessHostImpl::CreateOffscreenCanvasProvider,
+      base::Bind(&RenderProcessHostImpl::CreateEmbeddedFrameSinkProvider,
                  base::Unretained(this)));
 
   AddUIThreadInterface(registry.get(),
@@ -2099,16 +2099,17 @@ void RenderProcessHostImpl::GetBlobURLLoaderFactory(
       std::move(request));
 }
 
-void RenderProcessHostImpl::CreateOffscreenCanvasProvider(
-    blink::mojom::OffscreenCanvasProviderRequest request) {
+void RenderProcessHostImpl::CreateEmbeddedFrameSinkProvider(
+    blink::mojom::EmbeddedFrameSinkProviderRequest request) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  if (!offscreen_canvas_provider_) {
+  if (!embedded_frame_sink_provider_) {
     // The client id gets converted to a uint32_t in FrameSinkId.
     uint32_t renderer_client_id = base::checked_cast<uint32_t>(id_);
-    offscreen_canvas_provider_ = std::make_unique<OffscreenCanvasProviderImpl>(
-        GetHostFrameSinkManager(), renderer_client_id);
+    embedded_frame_sink_provider_ =
+        std::make_unique<EmbeddedFrameSinkProviderImpl>(
+            GetHostFrameSinkManager(), renderer_client_id);
   }
-  offscreen_canvas_provider_->Add(std::move(request));
+  embedded_frame_sink_provider_->Add(std::move(request));
 }
 
 void RenderProcessHostImpl::BindFrameSinkProvider(

content/browser/renderer_host/render_process_host_impl.h

@@ -28,9 +28,9 @@
 #include "content/browser/cache_storage/cache_storage_dispatcher_host.h"
 #include "content/browser/child_process_launcher.h"
 #include "content/browser/dom_storage/session_storage_namespace_impl.h"
+#include "content/browser/renderer_host/embedded_frame_sink_provider_impl.h"
 #include "content/browser/renderer_host/frame_sink_provider_impl.h"
 #include "content/browser/renderer_host/media/renderer_audio_output_stream_factory_context_impl.h"
-#include "content/browser/renderer_host/offscreen_canvas_provider_impl.h"
 #include "content/common/associated_interface_registry_impl.h"
 #include "content/common/associated_interfaces.mojom.h"
 #include "content/common/child_control.mojom.h"
@@ -484,8 +484,8 @@ class CONTENT_EXPORT RenderProcessHostImpl
 
   void BindRouteProvider(mojom::RouteProviderAssociatedRequest request);
 
-  void CreateOffscreenCanvasProvider(
-      blink::mojom::OffscreenCanvasProviderRequest request);
+  void CreateEmbeddedFrameSinkProvider(
+      blink::mojom::EmbeddedFrameSinkProviderRequest request);
   void BindFrameSinkProvider(mojom::FrameSinkProviderRequest request);
   void BindCompositingModeReporter(
       viz::mojom::CompositingModeReporterRequest request);
@@ -818,7 +818,7 @@ class CONTENT_EXPORT RenderProcessHostImpl
   std::unique_ptr<PushMessagingManager, BrowserThread::DeleteOnIOThread>
       push_messaging_manager_;
 
-  std::unique_ptr<OffscreenCanvasProviderImpl> offscreen_canvas_provider_;
+  std::unique_ptr<EmbeddedFrameSinkProviderImpl> embedded_frame_sink_provider_;
 
   mojom::ChildControlPtr child_control_interface_;
   mojom::RouteProviderAssociatedPtr remote_route_provider_;

content/public/app/mojo/content_browser_manifest.json

@@ -34,11 +34,11 @@
           "blink::mojom::BlobRegistry",
           "blink::mojom::BroadcastChannelProvider",
           "blink::mojom::ClipboardHost",
+          "blink::mojom::EmbeddedFrameSinkProvider",
           "blink::mojom::FileUtilitiesHost",
           "blink::mojom::LockManager",
           "blink::mojom::Hyphenation",
           "blink::mojom::MimeRegistry",
-          "blink::mojom::OffscreenCanvasProvider",
           "blink::mojom::ReportingServiceProxy",
           "blink::mojom::WebDatabaseHost",
           "content::mojom::AppCacheBackend",

content/test/BUILD.gn

@@ -1408,6 +1408,7 @@ test("content_unittests") {
     "../browser/renderer_host/compositor_resize_lock_unittest.cc",
     "../browser/renderer_host/cursor_manager_unittest.cc",
     "../browser/renderer_host/dwrite_font_proxy_message_filter_win_unittest.cc",
+    "../browser/renderer_host/embedded_frame_sink_provider_impl_unittest.cc",
     "../browser/renderer_host/frame_token_message_queue_unittest.cc",
     "../browser/renderer_host/input/fling_controller_unittest.cc",
     "../browser/renderer_host/input/gesture_event_queue_unittest.cc",
@@ -1454,7 +1455,6 @@ test("content_unittests") {
     "../browser/renderer_host/media/video_capture_controller_unittest.cc",
     "../browser/renderer_host/media/video_capture_manager_unittest.cc",
     "../browser/renderer_host/media/video_capture_unittest.cc",
-    "../browser/renderer_host/offscreen_canvas_provider_impl_unittest.cc",
     "../browser/renderer_host/overscroll_controller_unittest.cc",
     "../browser/renderer_host/render_process_host_unittest.cc",
     "../browser/renderer_host/render_view_host_unittest.cc",

third_party/blink/public/BUILD.gn

@@ -859,20 +859,20 @@ mojom("media_devices_mojo_bindings") {
   export_header = "content/common/content_export.h"
 }
 
-# The offscreen_canvas_mojo_bindings is separated from the rest of mojom files
-# because its deps contain too many files in Chromium that would pollute the
-# include paths in generated mojom-blink files for other services.
-mojom("offscreen_canvas_mojo_bindings") {
+# The embedded_frame_sink_mojo_bindings is separated from the rest of mojom
+# files because its deps contain too many files in Chromium that would pollute
+# the include paths in generated mojom-blink files for other services.
+mojom("embedded_frame_sink_mojo_bindings") {
   visibility = [ "//content/*" ]
   visibility_blink = [ "//third_party/blink/renderer/platform" ]
   sources = [
-    "platform/modules/offscreencanvas/offscreen_canvas_surface.mojom",
+    "platform/modules/frame_sinks/embedded_frame_sink.mojom",
   ]
   deps = [
     "//services/viz/public/interfaces",
   ]
 
-  component_output_prefix = "blink_offscreen_canvas_mojo_bindings"
+  component_output_prefix = "blink_embedded_frame_sink_mojo_bindings"
 
   # See comment above
   export_class_attribute = "CONTENT_EXPORT"
@@ -927,11 +927,11 @@ group("generate_mojo_bindings") {
     # variant of the generated files.
     ":core_mojo_bindings__generator",
     ":core_mojo_bindings_blink__generator",
+    ":embedded_frame_sink_mojo_bindings_blink__generator",
     ":media_devices_mojo_bindings__generator",
     ":media_devices_mojo_bindings_blink__generator",
     ":mojo_bindings__generator",
     ":mojo_bindings_blink__generator",
-    ":offscreen_canvas_mojo_bindings_blink__generator",
   ]
 }
 

third_party/blink/public/platform/modules/offscreencanvas/offscreen_canvas_surface.mojom → third_party/blink/public/platform/modules/frame_sinks/embedded_frame_sink.mojom

@@ -8,22 +8,27 @@ import "services/viz/public/interfaces/compositing/compositor_frame_sink.mojom";
 import "services/viz/public/interfaces/compositing/frame_sink_id.mojom";
 import "services/viz/public/interfaces/compositing/surface_info.mojom";
 
-// Closing this interface will destroy the corresponding CompositorFrameSink.
-interface OffscreenCanvasSurfaceClient {
+// Interface back to the embedder so it can be notified about surface
+// activations. Closing this interface will destroy the corresponding
+// CompositorFrameSink if one exists.
+interface EmbeddedFrameSinkClient {
   OnFirstSurfaceActivation(viz.mojom.SurfaceInfo surface_info);
 };
 
-// Creates OffscreenCanvasSurface and CompositorFrameSink instances for use
-// with offscreen canvas.
-interface OffscreenCanvasProvider {
-  // Create an OffscreenCanvasSurface for |frame_sink_id|. |client| will observe
-  // any changes to the SurfaceId associated with |frame_sink_id|.
-  CreateOffscreenCanvasSurface(viz.mojom.FrameSinkId parent_frame_sink_id,
-                               viz.mojom.FrameSinkId frame_sink_id,
-                               OffscreenCanvasSurfaceClient client);
+// Provides embedded CompositorFrameSinks for the renderer. The renderer should
+// first call RegisterEmbeddedFrameSink() to register an EmbeddedFrameSinkClient
+// for the embedder and then call CreateCompositorFrameSink() to get the
+// embedded CompositorFrameSink. The EmbeddedFrameSinkClient will be notified
+// about surface activations.
+interface EmbeddedFrameSinkProvider {
+  // Registers an embedded frame sink for |frame_sink_id|. The FrameSinkId of
+  // the parent must be specified at this time.
+  RegisterEmbeddedFrameSink(viz.mojom.FrameSinkId parent_frame_sink_id,
+                            viz.mojom.FrameSinkId frame_sink_id,
+                            EmbeddedFrameSinkClient client);
 
-  // Create an CompositorFrameSink for |frame_sink_id|. This must happen
-  // after creating an OffsreenCanvasSurface for |frame_sink_id|.
+  // Create a CompositorFrameSink for |frame_sink_id|. This must happen after
+  // calling RegisterEmbeddedFrameSink() for |frame_sink_id|.
   CreateCompositorFrameSink(viz.mojom.FrameSinkId frame_sink_id,
                             viz.mojom.CompositorFrameSinkClient client,
                             viz.mojom.CompositorFrameSink& sink);
@@ -32,7 +37,7 @@ interface OffscreenCanvasProvider {
   // through both function above).
   CreateSimpleCompositorFrameSink(viz.mojom.FrameSinkId parent_frame_sink_id,
                                   viz.mojom.FrameSinkId frame_sink_id,
-                                  OffscreenCanvasSurfaceClient surface_client,
+                                  EmbeddedFrameSinkClient surface_client,
                                   viz.mojom.CompositorFrameSinkClient client,
                                   viz.mojom.CompositorFrameSink& sink);
 };

third_party/blink/renderer/platform/BUILD.gn

@@ -1554,7 +1554,7 @@ jumbo_component("platform") {
     "//mojo/public/cpp/bindings:wtf_support",
     "//services/service_manager/public/cpp",
     "//third_party:freetype_harfbuzz",
-    "//third_party/blink/public:offscreen_canvas_mojo_bindings_blink",
+    "//third_party/blink/public:embedded_frame_sink_mojo_bindings_blink",
     "//third_party/ced",
     "//third_party/icu",
     "//ui/gfx",

third_party/blink/renderer/platform/graphics/begin_frame_provider.cc

@@ -17,7 +17,7 @@ BeginFrameProvider::BeginFrameProvider(
     BeginFrameProviderClient* client)
     : needs_begin_frame_(false),
       cfs_binding_(this),
-      ocs_binding_(this),
+      efs_binding_(this),
       frame_sink_id_(begin_frame_provider_params.frame_sink_id),
       parent_frame_sink_id_(begin_frame_provider_params.parent_frame_sink_id),
       begin_frame_client_(client) {}
@@ -25,23 +25,23 @@ BeginFrameProvider::BeginFrameProvider(
 void BeginFrameProvider::CreateCompositorFrameSink() {
   DCHECK(frame_sink_id_.is_valid());
 
-  mojom::blink::OffscreenCanvasProviderPtr canvas_provider;
+  mojom::blink::EmbeddedFrameSinkProviderPtr provider;
   Platform::Current()->GetInterfaceProvider()->GetInterface(
-      mojo::MakeRequest(&canvas_provider));
+      mojo::MakeRequest(&provider));
 
   scoped_refptr<base::SingleThreadTaskRunner> task_runner;
   auto* scheduler = blink::Platform::Current()->CurrentThread()->Scheduler();
   if (scheduler)
     task_runner = scheduler->CompositorTaskRunner();
 
-  mojom::blink::OffscreenCanvasSurfaceClientPtr ocs_client;
-  ocs_binding_.Bind(mojo::MakeRequest(&ocs_client), task_runner);
+  mojom::blink::EmbeddedFrameSinkClientPtr efs_client;
+  efs_binding_.Bind(mojo::MakeRequest(&efs_client), task_runner);
 
   viz::mojom::blink::CompositorFrameSinkClientPtr client;
   cfs_binding_.Bind(mojo::MakeRequest(&client), task_runner);
 
-  canvas_provider->CreateSimpleCompositorFrameSink(
-      parent_frame_sink_id_, frame_sink_id_, std::move(ocs_client),
+  provider->CreateSimpleCompositorFrameSink(
+      parent_frame_sink_id_, frame_sink_id_, std::move(efs_client),
       std::move(client), mojo::MakeRequest(&compositor_frame_sink_));
 }
 

third_party/blink/renderer/platform/graphics/begin_frame_provider.h

@@ -7,7 +7,7 @@
 
 #include "mojo/public/cpp/bindings/binding.h"
 #include "services/viz/public/interfaces/compositing/compositor_frame_sink.mojom-blink.h"
-#include "third_party/blink/public/platform/modules/offscreencanvas/offscreen_canvas_surface.mojom-blink.h"
+#include "third_party/blink/public/platform/modules/frame_sinks/embedded_frame_sink.mojom-blink.h"
 #include "third_party/blink/renderer/platform/graphics/begin_frame_provider.h"
 #include "third_party/blink/renderer/platform/platform_export.h"
 
@@ -26,7 +26,7 @@ class PLATFORM_EXPORT BeginFrameProviderClient {
 
 class PLATFORM_EXPORT BeginFrameProvider
     : public viz::mojom::blink::CompositorFrameSinkClient,
-      public mojom::blink::OffscreenCanvasSurfaceClient {
+      public mojom::blink::EmbeddedFrameSinkClient {
  public:
   explicit BeginFrameProvider(
       const BeginFrameProviderParams& begin_frame_provider_params,
@@ -57,7 +57,7 @@ class PLATFORM_EXPORT BeginFrameProvider
     NOTIMPLEMENTED();
   }
 
-  // viz::mojom::blink::OffscreenCanvasSurfaceClient implementation.
+  // viz::mojom::blink::EmbeddedFrameSinkClient implementation.
   void OnFirstSurfaceActivation(const viz::SurfaceInfo& surface_info) final {
     NOTIMPLEMENTED();
   }
@@ -68,7 +68,7 @@ class PLATFORM_EXPORT BeginFrameProvider
   bool needs_begin_frame_;
 
   mojo::Binding<viz::mojom::blink::CompositorFrameSinkClient> cfs_binding_;
-  mojo::Binding<mojom::blink::OffscreenCanvasSurfaceClient> ocs_binding_;
+  mojo::Binding<mojom::blink::EmbeddedFrameSinkClient> efs_binding_;
   const viz::FrameSinkId frame_sink_id_;
   const viz::FrameSinkId parent_frame_sink_id_;
   viz::mojom::blink::CompositorFrameSinkPtr compositor_frame_sink_;

third_party/blink/renderer/platform/graphics/offscreen_canvas_frame_dispatcher.cc

@@ -10,7 +10,7 @@
 #include "components/viz/common/quads/texture_draw_quad.h"
 #include "components/viz/common/resources/resource_format.h"
 #include "third_party/blink/public/platform/interface_provider.h"
-#include "third_party/blink/public/platform/modules/offscreencanvas/offscreen_canvas_surface.mojom-blink.h"
+#include "third_party/blink/public/platform/modules/frame_sinks/embedded_frame_sink.mojom-blink.h"
 #include "third_party/blink/public/platform/platform.h"
 #include "third_party/blink/public/platform/web_graphics_context_3d_provider.h"
 #include "third_party/blink/renderer/platform/cross_thread_functional.h"
@@ -50,7 +50,7 @@ OffscreenCanvasFrameDispatcher::OffscreenCanvasFrameDispatcher(
     current_local_surface_id_ =
         parent_local_surface_id_allocator_.GetCurrentLocalSurfaceId();
     DCHECK(!sink_.is_bound());
-    mojom::blink::OffscreenCanvasProviderPtr provider;
+    mojom::blink::EmbeddedFrameSinkProviderPtr provider;
     Platform::Current()->GetInterfaceProvider()->GetInterface(
         mojo::MakeRequest(&provider));
 

third_party/blink/renderer/platform/graphics/surface_layer_bridge.cc

@@ -12,7 +12,7 @@
 #include "components/viz/common/surfaces/surface_info.h"
 #include "media/base/media_switches.h"
 #include "third_party/blink/public/platform/interface_provider.h"
-#include "third_party/blink/public/platform/modules/offscreencanvas/offscreen_canvas_surface.mojom-blink.h"
+#include "third_party/blink/public/platform/modules/frame_sinks/embedded_frame_sink.mojom-blink.h"
 #include "third_party/blink/public/platform/platform.h"
 #include "third_party/blink/public/platform/web_compositor_support.h"
 #include "third_party/blink/public/platform/web_layer.h"
@@ -30,16 +30,16 @@ SurfaceLayerBridge::SurfaceLayerBridge(WebLayerTreeView* layer_tree_view,
       frame_sink_id_(Platform::Current()->GenerateFrameSinkId()),
       parent_frame_sink_id_(layer_tree_view ? layer_tree_view->GetFrameSinkId()
                                             : viz::FrameSinkId()) {
-  mojom::blink::OffscreenCanvasProviderPtr provider;
+  mojom::blink::EmbeddedFrameSinkProviderPtr provider;
   Platform::Current()->GetInterfaceProvider()->GetInterface(
       mojo::MakeRequest(&provider));
   // TODO(xlai): Ensure OffscreenCanvas commit() is still functional when a
   // frame-less HTML canvas's document is reparenting under another frame.
   // See crbug.com/683172.
-  blink::mojom::blink::OffscreenCanvasSurfaceClientPtr client;
+  blink::mojom::blink::EmbeddedFrameSinkClientPtr client;
   binding_.Bind(mojo::MakeRequest(&client));
-  provider->CreateOffscreenCanvasSurface(parent_frame_sink_id_, frame_sink_id_,
-                                         std::move(client));
+  provider->RegisterEmbeddedFrameSink(parent_frame_sink_id_, frame_sink_id_,
+                                      std::move(client));
 }
 
 SurfaceLayerBridge::~SurfaceLayerBridge() {

third_party/blink/renderer/platform/graphics/surface_layer_bridge.h

@@ -9,7 +9,7 @@
 #include "base/memory/scoped_refptr.h"
 #include "components/viz/common/surfaces/surface_id.h"
 #include "mojo/public/cpp/bindings/binding.h"
-#include "third_party/blink/public/platform/modules/offscreencanvas/offscreen_canvas_surface.mojom-blink.h"
+#include "third_party/blink/public/platform/modules/frame_sinks/embedded_frame_sink.mojom-blink.h"
 #include "third_party/blink/public/platform/web_surface_layer_bridge.h"
 #include "third_party/blink/renderer/platform/platform_export.h"
 
@@ -29,7 +29,7 @@ class WebLayerTreeView;
 // The SurfaceLayerBridge facilitates communication about changes to a Surface
 // between the Render and Browser processes.
 class PLATFORM_EXPORT SurfaceLayerBridge
-    : public blink::mojom::blink::OffscreenCanvasSurfaceClient,
+    : public blink::mojom::blink::EmbeddedFrameSinkClient,
       public WebSurfaceLayerBridge {
  public:
   SurfaceLayerBridge(WebLayerTreeView*, WebSurfaceLayerBridgeObserver*);
@@ -37,7 +37,7 @@ class PLATFORM_EXPORT SurfaceLayerBridge
 
   void CreateSolidColorLayer();
 
-  // Implementation of blink::mojom::blink::OffscreenCanvasSurfaceClient
+  // Implementation of blink::mojom::blink::EmbeddedFrameSinkClient
   void OnFirstSurfaceActivation(const viz::SurfaceInfo&) override;
 
   // Implementation of WebSurfaceLayerBridge.
@@ -53,7 +53,7 @@ class PLATFORM_EXPORT SurfaceLayerBridge
 
   WebSurfaceLayerBridgeObserver* observer_;
 
-  mojo::Binding<blink::mojom::blink::OffscreenCanvasSurfaceClient> binding_;
+  mojo::Binding<blink::mojom::blink::EmbeddedFrameSinkClient> binding_;
 
   const viz::FrameSinkId frame_sink_id_;
   viz::SurfaceId current_surface_id_;

third_party/blink/renderer/platform/graphics/video_frame_submitter.cc

@@ -14,7 +14,7 @@
 #include "media/base/video_frame.h"
 #include "services/viz/public/interfaces/compositing/compositor_frame_sink.mojom-blink.h"
 #include "third_party/blink/public/platform/interface_provider.h"
-#include "third_party/blink/public/platform/modules/offscreencanvas/offscreen_canvas_surface.mojom-blink.h"
+#include "third_party/blink/public/platform/modules/frame_sinks/embedded_frame_sink.mojom-blink.h"
 #include "third_party/blink/public/platform/platform.h"
 
 namespace blink {
@@ -93,14 +93,13 @@ void VideoFrameSubmitter::StartSubmitting(const viz::FrameSinkId& id) {
   DCHECK_CALLED_ON_VALID_THREAD(media_thread_checker_);
   DCHECK(id.is_valid());
 
-  // TODO(lethalantidote): Class to be renamed.
-  mojom::blink::OffscreenCanvasProviderPtr canvas_provider;
+  mojom::blink::EmbeddedFrameSinkProviderPtr provider;
   Platform::Current()->GetInterfaceProvider()->GetInterface(
-      mojo::MakeRequest(&canvas_provider));
+      mojo::MakeRequest(&provider));
 
   viz::mojom::blink::CompositorFrameSinkClientPtr client;
   binding_.Bind(mojo::MakeRequest(&client));
-  canvas_provider->CreateCompositorFrameSink(
+  provider->CreateCompositorFrameSink(
       id, std::move(client), mojo::MakeRequest(&compositor_frame_sink_));
 
   scoped_refptr<media::VideoFrame> video_frame = provider_->GetCurrentFrame();