Remove WebCanvasCaptureHandler

This is a follow up of [1]. Basically, WebCanvasCaptureHandler is now
only referenced within Blink, with its use is scattered between
renderer/modules/ and renderer/core/html/canvas.

For the of later, we can not simple replace the existing uses of
WebCanvasCaptureHandler in CanvasDrawListener by CanvasCaptureHandler
because renderer/core/html/canvas can not include renderer/modules/.

As per haraken's advice in [2], this CL makes CanvasDrawListener
pure virtual, and implements the methods as needed in
modules/mediacapturefromelement:

- AutoCanvasDrawListener: has the base implementation of the 3 method
  that used to live in html/canvas/CanvasDrawListener.

- OnRequestCanvasDrawListener: inherits from AutoCanvasDrawListener and
reimplements SendNewFrame.

- TimedCanvasDrawListener: inherits from OnRequestCanvasDrawListener
(but does not override any method).

This allows us not to duplicate any code among these 3 classes,
and eliminate WebCanvasCaptureHandler altogether.

[1] https://crrev.com/c/1600898 (Onion soup canvas_capture_handler.cc/h)
[2] https://crrev.com/c/1600898/1//COMMIT_MSG#34

BUG=787261,919392

Change-Id: I88113cc9cfe38a453ac028528f34eaea3448ea2e
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1603722Reviewed-by: Kentaro Hara <haraken@chromium.org>
Reviewed-by: Guido Urdaneta <guidou@chromium.org>
Commit-Queue: Antonio Gomes <tonikitoo@igalia.com>
Cr-Commit-Position: refs/heads/master@{#658944}

third_party/blink/public/BUILD.gn

@@ -202,7 +202,6 @@ source_set("blink_headers") {
     "platform/web_cache.h",
     "platform/web_callbacks.h",
     "platform/web_canonical_cookie.h",
-    "platform/web_canvas_capture_handler.h",
     "platform/web_client_hints_type.h",
     "platform/web_coalesced_input_event.h",
     "platform/web_common.h",

third_party/blink/public/platform/web_canvas_capture_handler.h

-// Copyright 2015 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 THIRD_PARTY_BLINK_PUBLIC_PLATFORM_WEB_CANVAS_CAPTURE_HANDLER_H_
-#define THIRD_PARTY_BLINK_PUBLIC_PLATFORM_WEB_CANVAS_CAPTURE_HANDLER_H_
-
-#include "third_party/blink/public/platform/web_common.h"
-
-#include "third_party/skia/include/core/SkImage.h"
-#include "third_party/skia/include/core/SkRefCnt.h"
-
-namespace blink {
-
-class WebGraphicsContext3DProvider;
-
-// Platform interface of a CanvasCaptureHandler.
-class BLINK_PLATFORM_EXPORT WebCanvasCaptureHandler {
- public:
-  virtual ~WebCanvasCaptureHandler() = default;
-  virtual void SendNewFrame(sk_sp<SkImage>,
-                            blink::WebGraphicsContext3DProvider*) {}
-  virtual bool NeedsNewFrame() const { return false; }
-};
-
-}  // namespace blink
-
-#endif  // WebMediaRecorderHandler_h

third_party/blink/renderer/core/html/canvas/canvas_draw_listener.cc

@@ -4,30 +4,10 @@
 
 #include "third_party/blink/renderer/core/html/canvas/canvas_draw_listener.h"
 
-#include "third_party/blink/renderer/platform/graphics/web_graphics_context_3d_provider_wrapper.h"
-#include "third_party/skia/include/core/SkImage.h"
-
 namespace blink {
 
 CanvasDrawListener::~CanvasDrawListener() = default;
 
-void CanvasDrawListener::SendNewFrame(
-    sk_sp<SkImage> image,
-    base::WeakPtr<WebGraphicsContext3DProviderWrapper> context_provider) {
-  handler_->SendNewFrame(
-      image, context_provider ? context_provider->ContextProvider() : nullptr);
-}
-
-bool CanvasDrawListener::NeedsNewFrame() const {
-  return frame_capture_requested_ && handler_->NeedsNewFrame();
-}
-
-void CanvasDrawListener::RequestFrame() {
-  frame_capture_requested_ = true;
-}
-
-CanvasDrawListener::CanvasDrawListener(
-    std::unique_ptr<WebCanvasCaptureHandler> handler)
-    : frame_capture_requested_(true), handler_(std::move(handler)) {}
+CanvasDrawListener::CanvasDrawListener() = default;
 
 }  // namespace blink

third_party/blink/renderer/core/html/canvas/canvas_draw_listener.h

@@ -8,7 +8,6 @@
 #include <memory>
 
 #include "base/memory/weak_ptr.h"
-#include "third_party/blink/public/platform/web_canvas_capture_handler.h"
 #include "third_party/blink/renderer/core/core_export.h"
 #include "third_party/blink/renderer/platform/heap/handle.h"
 #include "third_party/skia/include/core/SkRefCnt.h"
@@ -22,16 +21,14 @@ class WebGraphicsContext3DProviderWrapper;
 class CORE_EXPORT CanvasDrawListener : public GarbageCollectedMixin {
  public:
   virtual ~CanvasDrawListener();
-  virtual void SendNewFrame(sk_sp<SkImage>,
-                            base::WeakPtr<WebGraphicsContext3DProviderWrapper>);
-  bool NeedsNewFrame() const;
-  void RequestFrame();
+  virtual void SendNewFrame(
+      sk_sp<SkImage>,
+      base::WeakPtr<WebGraphicsContext3DProviderWrapper>) = 0;
+  virtual bool NeedsNewFrame() const = 0;
+  virtual void RequestFrame() = 0;
 
  protected:
-  explicit CanvasDrawListener(std::unique_ptr<WebCanvasCaptureHandler>);
-
-  bool frame_capture_requested_;
-  std::unique_ptr<WebCanvasCaptureHandler> handler_;
+  CanvasDrawListener();
 };
 
 }  // namespace blink

third_party/blink/renderer/modules/mediacapturefromelement/auto_canvas_draw_listener.cc

@@ -6,10 +6,28 @@
 
 #include <memory>
 
+#include "third_party/blink/renderer/platform/graphics/web_graphics_context_3d_provider_wrapper.h"
+#include "third_party/skia/include/core/SkImage.h"
+
 namespace blink {
 
 AutoCanvasDrawListener::AutoCanvasDrawListener(
-    std::unique_ptr<WebCanvasCaptureHandler> handler)
-    : CanvasDrawListener(std::move(handler)) {}
+    std::unique_ptr<CanvasCaptureHandler> handler)
+    : handler_(std::move(handler)), frame_capture_requested_(true) {}
+
+void AutoCanvasDrawListener::SendNewFrame(
+    sk_sp<SkImage> image,
+    base::WeakPtr<WebGraphicsContext3DProviderWrapper> context_provider) {
+  handler_->SendNewFrame(
+      image, context_provider ? context_provider->ContextProvider() : nullptr);
+}
+
+bool AutoCanvasDrawListener::NeedsNewFrame() const {
+  return frame_capture_requested_ && handler_->NeedsNewFrame();
+}
+
+void AutoCanvasDrawListener::RequestFrame() {
+  frame_capture_requested_ = true;
+}
 
 }  // namespace blink

third_party/blink/renderer/modules/mediacapturefromelement/auto_canvas_draw_listener.h

@@ -6,22 +6,32 @@
 #define THIRD_PARTY_BLINK_RENDERER_MODULES_MEDIACAPTUREFROMELEMENT_AUTO_CANVAS_DRAW_LISTENER_H_
 
 #include <memory>
-#include "third_party/blink/public/platform/web_canvas_capture_handler.h"
 #include "third_party/blink/renderer/core/html/canvas/canvas_draw_listener.h"
+#include "third_party/blink/renderer/modules/mediacapturefromelement/canvas_capture_handler.h"
 #include "third_party/blink/renderer/platform/heap/handle.h"
 
 namespace blink {
 
-class AutoCanvasDrawListener final
+class AutoCanvasDrawListener
     : public GarbageCollectedFinalized<AutoCanvasDrawListener>,
       public CanvasDrawListener {
   USING_GARBAGE_COLLECTED_MIXIN(AutoCanvasDrawListener);
 
  public:
-  explicit AutoCanvasDrawListener(std::unique_ptr<WebCanvasCaptureHandler>);
+  explicit AutoCanvasDrawListener(std::unique_ptr<CanvasCaptureHandler>);
   ~AutoCanvasDrawListener() override = default;
 
-  void Trace(blink::Visitor* visitor) override {}
+  void SendNewFrame(
+      sk_sp<SkImage>,
+      base::WeakPtr<WebGraphicsContext3DProviderWrapper>) override;
+  bool NeedsNewFrame() const final;
+  void RequestFrame() final;
+
+  void Trace(blink::Visitor*) override {}
+
+ protected:
+  std::unique_ptr<CanvasCaptureHandler> handler_;
+  bool frame_capture_requested_;
 };
 
 }  // namespace blink

third_party/blink/renderer/modules/mediacapturefromelement/canvas_capture_handler.h

@@ -17,7 +17,6 @@
 #include "base/threading/thread_checker.h"
 #include "media/base/video_frame_pool.h"
 #include "media/capture/video_capturer_source.h"
-#include "third_party/blink/public/platform/web_canvas_capture_handler.h"
 #include "third_party/blink/public/platform/web_media_stream_track.h"
 #include "third_party/blink/public/platform/web_size.h"
 #include "third_party/blink/renderer/modules/modules_export.h"
@@ -27,6 +26,8 @@ class SkImage;
 
 namespace blink {
 
+class WebGraphicsContext3DProvider;
+
 // CanvasCaptureHandler acts as the link between Blink side HTMLCanvasElement
 // and Chrome side VideoCapturerSource. It is responsible for handling
 // SkImage instances sent from the Blink side, convert them to
@@ -36,10 +37,9 @@ namespace blink {
 // All methods are called on the same thread as construction and destruction,
 // i.e. the Main Render thread. Note that a CanvasCaptureHandlerDelegate is
 // used to send back frames to |io_task_runner_|, i.e. IO thread.
-class MODULES_EXPORT CanvasCaptureHandler final
-    : public blink::WebCanvasCaptureHandler {
+class MODULES_EXPORT CanvasCaptureHandler {
  public:
-  ~CanvasCaptureHandler() override;
+  ~CanvasCaptureHandler();
 
   // Creates a CanvasCaptureHandler instance and updates UMA histogram.
   static std::unique_ptr<CanvasCaptureHandler> CreateCanvasCaptureHandler(
@@ -48,11 +48,9 @@ class MODULES_EXPORT CanvasCaptureHandler final
       scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
       blink::WebMediaStreamTrack* track);
 
-  // blink::WebCanvasCaptureHandler implementation.
-  void SendNewFrame(
-      sk_sp<SkImage> image,
-      blink::WebGraphicsContext3DProvider* context_provider) override;
-  bool NeedsNewFrame() const override;
+  void SendNewFrame(sk_sp<SkImage> image,
+                    blink::WebGraphicsContext3DProvider* context_provider);
+  bool NeedsNewFrame() const;
 
   // Functions called by media::VideoCapturerSource implementation.
   void StartVideoCapture(

third_party/blink/renderer/modules/mediacapturefromelement/canvas_capture_media_stream_track.cc

@@ -50,7 +50,7 @@ CanvasCaptureMediaStreamTrack::CanvasCaptureMediaStreamTrack(
     MediaStreamComponent* component,
     HTMLCanvasElement* element,
     ExecutionContext* context,
-    std::unique_ptr<WebCanvasCaptureHandler> handler)
+    std::unique_ptr<CanvasCaptureHandler> handler)
     : MediaStreamTrack(context, component), canvas_element_(element) {
   draw_listener_ =
       MakeGarbageCollected<AutoCanvasDrawListener>(std::move(handler));
@@ -61,7 +61,7 @@ CanvasCaptureMediaStreamTrack::CanvasCaptureMediaStreamTrack(
     MediaStreamComponent* component,
     HTMLCanvasElement* element,
     ExecutionContext* context,
-    std::unique_ptr<WebCanvasCaptureHandler> handler,
+    std::unique_ptr<CanvasCaptureHandler> handler,
     double frame_rate)
     : MediaStreamTrack(context, component), canvas_element_(element) {
   if (frame_rate == 0) {

third_party/blink/renderer/modules/mediacapturefromelement/canvas_capture_media_stream_track.h

@@ -14,7 +14,7 @@ namespace blink {
 
 class ExecutionContext;
 class HTMLCanvasElement;
-class WebCanvasCaptureHandler;
+class CanvasCaptureHandler;
 
 class CanvasCaptureMediaStreamTrack final : public MediaStreamTrack {
   DEFINE_WRAPPERTYPEINFO();
@@ -25,11 +25,11 @@ class CanvasCaptureMediaStreamTrack final : public MediaStreamTrack {
   CanvasCaptureMediaStreamTrack(MediaStreamComponent*,
                                 HTMLCanvasElement*,
                                 ExecutionContext*,
-                                std::unique_ptr<WebCanvasCaptureHandler>);
+                                std::unique_ptr<CanvasCaptureHandler>);
   CanvasCaptureMediaStreamTrack(MediaStreamComponent*,
                                 HTMLCanvasElement*,
                                 ExecutionContext*,
-                                std::unique_ptr<WebCanvasCaptureHandler>,
+                                std::unique_ptr<CanvasCaptureHandler>,
                                 double frame_rate);
 
   HTMLCanvasElement* canvas() const;

third_party/blink/renderer/modules/mediacapturefromelement/html_canvas_element_capture.cc

@@ -55,7 +55,7 @@ MediaStream* HTMLCanvasElementCapture::captureStream(
 
   WebMediaStreamTrack track;
   const WebSize size(element.width(), element.height());
-  std::unique_ptr<WebCanvasCaptureHandler> handler;
+  std::unique_ptr<CanvasCaptureHandler> handler;
   if (given_frame_rate) {
     handler = CanvasCaptureHandler::CreateCanvasCaptureHandler(
         size, frame_rate, Platform::Current()->GetIOTaskRunner(), &track);

third_party/blink/renderer/modules/mediacapturefromelement/on_request_canvas_draw_listener.cc

@@ -9,8 +9,8 @@
 namespace blink {
 
 OnRequestCanvasDrawListener::OnRequestCanvasDrawListener(
-    std::unique_ptr<WebCanvasCaptureHandler> handler)
-    : CanvasDrawListener(std::move(handler)) {}
+    std::unique_ptr<CanvasCaptureHandler> handler)
+    : AutoCanvasDrawListener(std::move(handler)) {}
 
 OnRequestCanvasDrawListener::~OnRequestCanvasDrawListener() = default;
 
@@ -18,7 +18,11 @@ void OnRequestCanvasDrawListener::SendNewFrame(
     sk_sp<SkImage> image,
     base::WeakPtr<WebGraphicsContext3DProviderWrapper> context_provider) {
   frame_capture_requested_ = false;
-  CanvasDrawListener::SendNewFrame(image, context_provider);
+  AutoCanvasDrawListener::SendNewFrame(image, context_provider);
+}
+
+void OnRequestCanvasDrawListener::Trace(blink::Visitor* visitor) {
+  AutoCanvasDrawListener::Trace(visitor);
 }
 
 }  // namespace blink

third_party/blink/renderer/modules/mediacapturefromelement/on_request_canvas_draw_listener.h

@@ -7,28 +7,22 @@
 
 #include <memory>
 #include "base/memory/weak_ptr.h"
-#include "third_party/blink/public/platform/web_canvas_capture_handler.h"
-#include "third_party/blink/renderer/core/html/canvas/canvas_draw_listener.h"
+#include "third_party/blink/renderer/modules/mediacapturefromelement/auto_canvas_draw_listener.h"
+#include "third_party/blink/renderer/modules/mediacapturefromelement/canvas_capture_handler.h"
 #include "third_party/blink/renderer/platform/heap/handle.h"
 #include "third_party/skia/include/core/SkRefCnt.h"
 
 namespace blink {
 
-class OnRequestCanvasDrawListener final
-    : public GarbageCollectedFinalized<OnRequestCanvasDrawListener>,
-      public CanvasDrawListener {
-  USING_GARBAGE_COLLECTED_MIXIN(OnRequestCanvasDrawListener);
-
+class OnRequestCanvasDrawListener : public AutoCanvasDrawListener {
  public:
-  explicit OnRequestCanvasDrawListener(
-      std::unique_ptr<WebCanvasCaptureHandler>);
+  explicit OnRequestCanvasDrawListener(std::unique_ptr<CanvasCaptureHandler>);
   ~OnRequestCanvasDrawListener() override;
 
-  void SendNewFrame(
-      sk_sp<SkImage>,
-      base::WeakPtr<WebGraphicsContext3DProviderWrapper>) override;
+  void SendNewFrame(sk_sp<SkImage>,
+                    base::WeakPtr<WebGraphicsContext3DProviderWrapper>) final;
 
-  void Trace(blink::Visitor* visitor) override {}
+  void Trace(blink::Visitor*) override;
 };
 
 }  // namespace blink

third_party/blink/renderer/modules/mediacapturefromelement/timed_canvas_draw_listener.cc

@@ -7,15 +7,16 @@
 #include <memory>
 #include "third_party/blink/public/platform/task_type.h"
 #include "third_party/blink/renderer/core/execution_context/execution_context.h"
+#include "third_party/blink/renderer/modules/mediacapturefromelement/canvas_capture_handler.h"
 #include "third_party/skia/include/core/SkImage.h"
 
 namespace blink {
 
 TimedCanvasDrawListener::TimedCanvasDrawListener(
-    std::unique_ptr<WebCanvasCaptureHandler> handler,
+    std::unique_ptr<CanvasCaptureHandler> handler,
     double frame_rate,
     ExecutionContext* context)
-    : CanvasDrawListener(std::move(handler)),
+    : OnRequestCanvasDrawListener(std::move(handler)),
       frame_interval_(TimeDelta::FromSecondsD(1 / frame_rate)),
       request_frame_timer_(context->GetTaskRunner(TaskType::kInternalMedia),
                            this,
@@ -25,7 +26,7 @@ TimedCanvasDrawListener::~TimedCanvasDrawListener() = default;
 
 // static
 TimedCanvasDrawListener* TimedCanvasDrawListener::Create(
-    std::unique_ptr<WebCanvasCaptureHandler> handler,
+    std::unique_ptr<CanvasCaptureHandler> handler,
     double frame_rate,
     ExecutionContext* context) {
   TimedCanvasDrawListener* listener =
@@ -36,16 +37,13 @@ TimedCanvasDrawListener* TimedCanvasDrawListener::Create(
   return listener;
 }
 
-void TimedCanvasDrawListener::SendNewFrame(
-    sk_sp<SkImage> image,
-    base::WeakPtr<WebGraphicsContext3DProviderWrapper> context_provider) {
-  frame_capture_requested_ = false;
-  CanvasDrawListener::SendNewFrame(image, context_provider);
-}
-
 void TimedCanvasDrawListener::RequestFrameTimerFired(TimerBase*) {
   // TODO(emircan): Measure the jitter and log, see crbug.com/589974.
   frame_capture_requested_ = true;
 }
 
+void TimedCanvasDrawListener::Trace(blink::Visitor* visitor) {
+  OnRequestCanvasDrawListener::Trace(visitor);
+}
+
 }  // namespace blink

third_party/blink/renderer/modules/mediacapturefromelement/timed_canvas_draw_listener.h

@@ -7,36 +7,26 @@
 
 #include <memory>
 #include "base/memory/weak_ptr.h"
-#include "third_party/blink/renderer/core/html/canvas/canvas_draw_listener.h"
+#include "third_party/blink/renderer/modules/mediacapturefromelement/canvas_capture_handler.h"
+#include "third_party/blink/renderer/modules/mediacapturefromelement/on_request_canvas_draw_listener.h"
 #include "third_party/blink/renderer/platform/heap/handle.h"
 #include "third_party/blink/renderer/platform/timer.h"
-
-#include "third_party/blink/public/platform/web_canvas_capture_handler.h"
 #include "third_party/skia/include/core/SkRefCnt.h"
 
 namespace blink {
 class ExecutionContext;
 
-class TimedCanvasDrawListener final
-    : public GarbageCollectedFinalized<TimedCanvasDrawListener>,
-      public CanvasDrawListener {
-  USING_GARBAGE_COLLECTED_MIXIN(TimedCanvasDrawListener);
-
+class TimedCanvasDrawListener final : public OnRequestCanvasDrawListener {
  public:
-  TimedCanvasDrawListener(std::unique_ptr<WebCanvasCaptureHandler>,
+  TimedCanvasDrawListener(std::unique_ptr<CanvasCaptureHandler>,
                           double frame_rate,
                           ExecutionContext*);
   ~TimedCanvasDrawListener() override;
 
-  static TimedCanvasDrawListener* Create(
-      std::unique_ptr<WebCanvasCaptureHandler>,
-      double frame_rate,
-      ExecutionContext*);
-  void SendNewFrame(
-      sk_sp<SkImage>,
-      base::WeakPtr<WebGraphicsContext3DProviderWrapper>) override;
-
-  void Trace(blink::Visitor* visitor) override {}
+  static TimedCanvasDrawListener* Create(std::unique_ptr<CanvasCaptureHandler>,
+                                         double frame_rate,
+                                         ExecutionContext*);
+  void Trace(blink::Visitor*) override;
 
  private:
   // Implementation of TimerFiredFunction.

third_party/blink/renderer/platform/BUILD.gn

@@ -521,7 +521,6 @@ jumbo_component("platform") {
     "exported/web_blob_info.cc",
     "exported/web_cache.cc",
     "exported/web_canonical_cookie.cc",
-    "exported/web_canvas_capture_handler.cc",
     "exported/web_coalesced_input_event.cc",
     "exported/web_content_decryption_module.cc",
     "exported/web_content_decryption_module_access.cc",

third_party/blink/renderer/platform/exported/web_canvas_capture_handler.cc

-// Copyright 2015 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 "third_party/blink/public/platform/web_canvas_capture_handler.h"
-
-// This file just includes WebCanvasCaptureHandler.h, to make sure
-// MSVC compiler does not fail linking with LNK2019 due to unresolved
-// constructor/destructor and should be in Source/platform/exported.