Update functions names in OffscreenCanvasPlaceHolder

In OffscreenCanvasPlaceHolder, placeholder used to refer
to both Canvas and OffscreenCanvas. This updates all function names
to avoid ambiguity.

Change-Id: Ia272c3b9e6f978c8c4f638cc7a8b1606d4a2b29e
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1776405Reviewed-by: Fernando Serboncini <fserb@chromium.org>
Commit-Queue: Yi Xu <yiyix@chromium.org>
Cr-Commit-Position: refs/heads/master@{#691877}

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

@@ -129,12 +129,12 @@ HTMLCanvasElement::~HTMLCanvasElement() {
 }
 
 void HTMLCanvasElement::Dispose() {
-  if (PlaceholderFrame()) {
-    ReleasePlaceholderFrame();
+  if (OffscreenCanvasFrame()) {
+    ReleaseOffscreenCanvasFrame();
   }
   // It's possible that the placeholder frame has been disposed but its ID still
   // exists. Make sure that it gets unregistered here
-  UnregisterPlaceholder();
+  UnregisterPlaceholderCanvas();
 
   // We need to drop frame dispatcher, to prevent mojo calls from completing.
   frame_dispatcher_ = nullptr;
@@ -191,7 +191,7 @@ Node::InsertionNotificationRequest HTMLCanvasElement::InsertedInto(
 
 void HTMLCanvasElement::setHeight(unsigned value,
                                   ExceptionState& exception_state) {
-  if (IsPlaceholderRegistered()) {
+  if (IsOffscreenCanvasRegistered()) {
     exception_state.ThrowDOMException(
         DOMExceptionCode::kInvalidStateError,
         "Cannot resize canvas after call to transferControlToOffscreen().");
@@ -202,7 +202,7 @@ void HTMLCanvasElement::setHeight(unsigned value,
 
 void HTMLCanvasElement::setWidth(unsigned value,
                                  ExceptionState& exception_state) {
-  if (IsPlaceholderRegistered()) {
+  if (IsOffscreenCanvasRegistered()) {
     exception_state.ThrowDOMException(
         DOMExceptionCode::kInvalidStateError,
         "Cannot resize canvas after call to transferControlToOffscreen().");
@@ -598,7 +598,7 @@ void HTMLCanvasElement::Reset() {
 }
 
 bool HTMLCanvasElement::PaintsIntoCanvasBuffer() const {
-  if (PlaceholderFrame())
+  if (OffscreenCanvasFrame())
     return false;
   DCHECK(context_);
   if (!context_->IsComposited())
@@ -695,7 +695,7 @@ void HTMLCanvasElement::Paint(GraphicsContext& context,
 
   // FIXME: crbug.com/438240; there is a bug with the new CSS blending and
   // compositing feature.
-  if (!context_ && !PlaceholderFrame())
+  if (!context_ && !OffscreenCanvasFrame())
     return;
 
   if (Is3d())
@@ -713,10 +713,10 @@ void HTMLCanvasElement::Paint(GraphicsContext& context,
       return;
   }
 
-  if (PlaceholderFrame()) {
+  if (OffscreenCanvasFrame()) {
     DCHECK(GetDocument().Printing());
     scoped_refptr<StaticBitmapImage> image_for_printing =
-        PlaceholderFrame()->Bitmap()->MakeUnaccelerated();
+        OffscreenCanvasFrame()->Bitmap()->MakeUnaccelerated();
     context.DrawImage(image_for_printing.get(), Image::kSyncDecode,
                       FloatRect(PixelSnappedIntRect(r)));
     return;
@@ -812,9 +812,9 @@ scoped_refptr<StaticBitmapImage> HTMLCanvasElement::Snapshot(
     return nullptr;
 
   scoped_refptr<StaticBitmapImage> image_bitmap = nullptr;
-  if (PlaceholderFrame()) {  // Offscreen Canvas
-    DCHECK(PlaceholderFrame()->OriginClean());
-    image_bitmap = PlaceholderFrame()->Bitmap();
+  if (OffscreenCanvasFrame()) {  // Offscreen Canvas
+    DCHECK(OffscreenCanvasFrame()->OriginClean());
+    image_bitmap = OffscreenCanvasFrame()->Bitmap();
   } else if (Is3d()) {  // WebGL or WebGL2 canvas
     if (context_->CreationAttributes().premultiplied_alpha) {
       context_->PaintRenderingResultsToCanvas(source_buffer);
@@ -985,8 +985,8 @@ bool HTMLCanvasElement::OriginClean() const {
       GetDocument().GetSettings()->GetDisableReadingFromCanvas()) {
     return false;
   }
-  if (PlaceholderFrame())
-    return PlaceholderFrame()->OriginClean();
+  if (OffscreenCanvasFrame())
+    return OffscreenCanvasFrame()->OriginClean();
   return origin_clean_;
 }
 
@@ -1193,9 +1193,9 @@ scoped_refptr<Image> HTMLCanvasElement::GetSourceImageForCanvas(
     return nullptr;
   }
 
-  if (PlaceholderFrame()) {
+  if (OffscreenCanvasFrame()) {
     *status = kNormalSourceImageStatus;
-    return PlaceholderFrame()->Bitmap();
+    return OffscreenCanvasFrame()->Bitmap();
   }
 
   if (!context_) {
@@ -1249,8 +1249,8 @@ FloatSize HTMLCanvasElement::ElementSize(const FloatSize&) const {
       return FloatSize(image->width(), image->height());
     return FloatSize(0, 0);
   }
-  if (PlaceholderFrame())
-    return FloatSize(PlaceholderFrame()->Size());
+  if (OffscreenCanvasFrame())
+    return FloatSize(OffscreenCanvasFrame()->Size());
   return FloatSize(width(), height());
 }
 
@@ -1269,15 +1269,15 @@ ScriptPromise HTMLCanvasElement::CreateImageBitmap(
       script_state, ImageBitmap::Create(this, crop_rect, options));
 }
 
-void HTMLCanvasElement::SetPlaceholderFrame(
+void HTMLCanvasElement::SetOffscreenCanvasFrame(
     scoped_refptr<CanvasResource> image,
     base::WeakPtr<CanvasResourceDispatcher> dispatcher,
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     unsigned resource_id) {
-  OffscreenCanvasPlaceholder::SetPlaceholderFrame(
+  OffscreenCanvasPlaceholder::SetOffscreenCanvasFrame(
       std::move(image), std::move(dispatcher), std::move(task_runner),
       resource_id);
-  SetSize(PlaceholderFrame()->Size());
+  SetSize(OffscreenCanvasFrame()->Size());
   NotifyListenersCanvasChanged();
 }
 

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

@@ -236,10 +236,10 @@ class CORE_EXPORT HTMLCanvasElement final
                                   const ImageBitmapOptions*) override;
 
   // OffscreenCanvasPlaceholder implementation.
-  void SetPlaceholderFrame(scoped_refptr<CanvasResource>,
-                           base::WeakPtr<CanvasResourceDispatcher>,
-                           scoped_refptr<base::SingleThreadTaskRunner>,
-                           unsigned resource_id) override;
+  void SetOffscreenCanvasFrame(scoped_refptr<CanvasResource>,
+                               base::WeakPtr<CanvasResourceDispatcher>,
+                               scoped_refptr<base::SingleThreadTaskRunner>,
+                               unsigned resource_id) override;
   void Trace(Visitor*) override;
 
   void SetResourceProviderForTesting(std::unique_ptr<CanvasResourceProvider>,

third_party/blink/renderer/modules/canvas/htmlcanvas/html_canvas_element_module.cc

@@ -69,7 +69,7 @@ OffscreenCanvas* HTMLCanvasElementModule::TransferControlToOffscreenInternal(
 
   DOMNodeId canvas_id = DOMNodeIds::IdForNode(&canvas);
   offscreen_canvas->SetPlaceholderCanvasId(canvas_id);
-  canvas.RegisterPlaceholder(static_cast<int>(canvas_id));
+  canvas.RegisterPlaceholderCanvas(static_cast<int>(canvas_id));
 
   SurfaceLayerBridge* bridge = canvas.SurfaceLayerBridge();
   if (bridge) {

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

@@ -91,9 +91,10 @@ void UpdatePlaceholderImage(
     viz::ResourceId resource_id) {
   DCHECK(IsMainThread());
   OffscreenCanvasPlaceholder* placeholder_canvas =
-      OffscreenCanvasPlaceholder::GetPlaceholderById(placeholder_canvas_id);
+      OffscreenCanvasPlaceholder::GetPlaceholderCanvasById(
+          placeholder_canvas_id);
   if (placeholder_canvas) {
-    placeholder_canvas->SetPlaceholderFrame(
+    placeholder_canvas->SetOffscreenCanvasFrame(
         std::move(canvas_resource), std::move(dispatcher),
         std::move(task_runner), resource_id);
   }

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

@@ -45,40 +45,17 @@ void SetSuspendAnimation(
 namespace blink {
 
 OffscreenCanvasPlaceholder::~OffscreenCanvasPlaceholder() {
-  UnregisterPlaceholder();
+  UnregisterPlaceholderCanvas();
 }
 
-OffscreenCanvasPlaceholder* OffscreenCanvasPlaceholder::GetPlaceholderById(
-    unsigned placeholder_id) {
-  PlaceholderIdMap::iterator it = placeholderRegistry().find(placeholder_id);
-  if (it == placeholderRegistry().end())
-    return nullptr;
-  return it->value;
-}
-
-void OffscreenCanvasPlaceholder::RegisterPlaceholder(unsigned placeholder_id) {
-  DCHECK(!placeholderRegistry().Contains(placeholder_id));
-  DCHECK(!IsPlaceholderRegistered());
-  placeholderRegistry().insert(placeholder_id, this);
-  placeholder_id_ = placeholder_id;
-}
-
-void OffscreenCanvasPlaceholder::UnregisterPlaceholder() {
-  if (!IsPlaceholderRegistered())
-    return;
-  DCHECK(placeholderRegistry().find(placeholder_id_)->value == this);
-  placeholderRegistry().erase(placeholder_id_);
-  placeholder_id_ = kNoPlaceholderId;
-}
-
-void OffscreenCanvasPlaceholder::SetPlaceholderFrame(
+void OffscreenCanvasPlaceholder::SetOffscreenCanvasFrame(
     scoped_refptr<CanvasResource> new_frame,
     base::WeakPtr<CanvasResourceDispatcher> dispatcher,
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     viz::ResourceId resource_id) {
-  DCHECK(IsPlaceholderRegistered());
+  DCHECK(IsOffscreenCanvasRegistered());
   DCHECK(new_frame);
-  ReleasePlaceholderFrame();
+  ReleaseOffscreenCanvasFrame();
   placeholder_frame_ = std::move(new_frame);
   frame_dispatcher_ = std::move(dispatcher);
   frame_dispatcher_task_runner_ = std::move(task_runner);
@@ -95,8 +72,8 @@ void OffscreenCanvasPlaceholder::SetPlaceholderFrame(
   }
 }
 
-void OffscreenCanvasPlaceholder::ReleasePlaceholderFrame() {
-  DCHECK(IsPlaceholderRegistered());
+void OffscreenCanvasPlaceholder::ReleaseOffscreenCanvasFrame() {
+  DCHECK(IsOffscreenCanvasRegistered());
   if (placeholder_frame_) {
     DCHECK(frame_dispatcher_task_runner_);
     placeholder_frame_->Transfer();
@@ -144,6 +121,30 @@ void OffscreenCanvasPlaceholder::SetSuspendOffscreenCanvasAnimation(
   }
 }
 
+OffscreenCanvasPlaceholder*
+OffscreenCanvasPlaceholder::GetPlaceholderCanvasById(unsigned placeholder_id) {
+  PlaceholderIdMap::iterator it = placeholderRegistry().find(placeholder_id);
+  if (it == placeholderRegistry().end())
+    return nullptr;
+  return it->value;
+}
+
+void OffscreenCanvasPlaceholder::RegisterPlaceholderCanvas(
+    unsigned placeholder_id) {
+  DCHECK(!placeholderRegistry().Contains(placeholder_id));
+  DCHECK(!IsOffscreenCanvasRegistered());
+  placeholderRegistry().insert(placeholder_id, this);
+  placeholder_id_ = placeholder_id;
+}
+
+void OffscreenCanvasPlaceholder::UnregisterPlaceholderCanvas() {
+  if (!IsOffscreenCanvasRegistered())
+    return;
+  DCHECK(placeholderRegistry().find(placeholder_id_)->value == this);
+  placeholderRegistry().erase(placeholder_id_);
+  placeholder_id_ = kNoPlaceholderId;
+}
+
 bool OffscreenCanvasPlaceholder::PostSetSuspendAnimationToOffscreenCanvasThread(
     bool suspend) {
   if (!frame_dispatcher_task_runner_)

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

@@ -24,30 +24,32 @@ class PLATFORM_EXPORT OffscreenCanvasPlaceholder {
  public:
   ~OffscreenCanvasPlaceholder();
 
-  virtual void SetPlaceholderFrame(scoped_refptr<CanvasResource>,
-                                   base::WeakPtr<CanvasResourceDispatcher>,
-                                   scoped_refptr<base::SingleThreadTaskRunner>,
-                                   viz::ResourceId resource_id);
-  void ReleasePlaceholderFrame();
+  virtual void SetOffscreenCanvasFrame(
+      scoped_refptr<CanvasResource>,
+      base::WeakPtr<CanvasResourceDispatcher>,
+      scoped_refptr<base::SingleThreadTaskRunner>,
+      viz::ResourceId resource_id);
+  void ReleaseOffscreenCanvasFrame();
 
   void SetSuspendOffscreenCanvasAnimation(bool);
 
-  static OffscreenCanvasPlaceholder* GetPlaceholderById(
+  static OffscreenCanvasPlaceholder* GetPlaceholderCanvasById(
       unsigned placeholder_id);
 
-  void RegisterPlaceholder(unsigned placeholder_id);
-  void UnregisterPlaceholder();
-  const scoped_refptr<CanvasResource>& PlaceholderFrame() const {
+  void RegisterPlaceholderCanvas(unsigned placeholder_id);
+  void UnregisterPlaceholderCanvas();
+  const scoped_refptr<CanvasResource>& OffscreenCanvasFrame() const {
     return placeholder_frame_;
   }
 
-  bool IsPlaceholderRegistered() const {
+  bool IsOffscreenCanvasRegistered() const {
     return placeholder_id_ != kNoPlaceholderId;
   }
 
  private:
   bool PostSetSuspendAnimationToOffscreenCanvasThread(bool suspend);
 
+  // Information about the Offscreen Canvas:
   scoped_refptr<CanvasResource> placeholder_frame_;
   base::WeakPtr<CanvasResourceDispatcher> frame_dispatcher_;
   scoped_refptr<base::SingleThreadTaskRunner> frame_dispatcher_task_runner_;