Refactor ImageBuffer to make OffscreenCanvas match HTMLCanvasElement

third_party/WebKit/Source/core/html/HTMLCanvasElement.cpp

 /*
  * Copyright (C) 2004, 2006, 2007 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alp Toker <alp@atoker.com>
  * Copyright (C) 2010 Torch Mobile (Beijing) Co. Ltd. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
@@ skipping 277 matching lines @@
     DidDraw();
   }
 
   SetNeedsCompositingUpdate();
 
   return context_.Get();
 }
 
 bool HTMLCanvasElement::ShouldBeDirectComposited() const {
   return (context_ && context_->IsComposited()) ||
-         (HasImageBuffer() && Buffer()->IsExpensiveToPaint()) ||
+         (GetImageBuffer() && GetImageBuffer()->IsExpensiveToPaint()) ||
          (!!surface_layer_bridge_);
 }
 
 bool HTMLCanvasElement::IsPaintable() const {
   return (context_ && context_->IsPaintable()) ||
          ImageBuffer::CanCreateImageBuffer(Size());
 }
 
 bool HTMLCanvasElement::IsAccelerated() const {
   return context_ && context_->IsAccelerated();
 }
 
 void HTMLCanvasElement::DidDraw(const FloatRect& rect) {
   if (rect.IsEmpty())
     return;
   image_buffer_is_clear_ = false;
   ClearCopiedImage();
   if (GetLayoutObject())
     GetLayoutObject()->SetMayNeedPaintInvalidation();
   if (Is2d() && context_->ShouldAntialias() && GetPage() &&
       GetPage()->DeviceScaleFactorDeprecated() > 1.0f) {
     FloatRect inflated_rect = rect;
     inflated_rect.Inflate(1);
     dirty_rect_.Unite(inflated_rect);
   } else {
     dirty_rect_.Unite(rect);
   }
-  if (Is2d() && HasImageBuffer())
-    Buffer()->DidDraw(rect);
+  if (Is2d() && GetImageBuffer())
+    GetImageBuffer()->DidDraw(rect);
 }
 
 void HTMLCanvasElement::DidDraw() {
   DidDraw(FloatRect(0, 0, Size().Width(), Size().Height()));
 }
 
 void HTMLCanvasElement::FinalizeFrame() {
-  if (HasImageBuffer())
+  if (GetImageBuffer())
     image_buffer_->FinalizeFrame();
 
   // If the canvas is visible, notifying listeners is taken
   // care of in the in doDeferredPaintInvalidation, which allows
   // the frame to be grabbed prior to compositing, which is
   // critically important because compositing may clear the canvas's
   // image. (e.g. WebGL context with preserveDrawingBuffer=false).
   // If the canvas is not visible, doDeferredPaintInvalidation
   // will not get called, so we need to take care of business here.
   if (!did_notify_listeners_for_current_frame_)
@@ skipping 34 matching lines @@
         mapped_dirty_rect.Move(-lb->ContentBoxOffset());
       }
       invalidation_rect = mapped_dirty_rect;
     } else {
       invalidation_rect = dirty_rect_;
     }
 
     if (dirty_rect_.IsEmpty())
       return;
 
-    if (HasImageBuffer()) {
+    if (GetImageBuffer()) {
       image_buffer_->DoPaintInvalidation(invalidation_rect);
     }
   }
 
   if (context_->GetContextType() ==
           CanvasRenderingContext::kContextImageBitmap &&
       context_->PlatformLayer()) {
     context_->PlatformLayer()->Invalidate();
   }
 
@@ skipping 24 matching lines @@
     // FIXME: is this invalidation using the correct compositing state?
     DisableCompositingQueryAsserts disabler;
     ro->InvalidatePaintRectangle(mapped_dirty_rect);
   }
   dirty_rect_ = FloatRect();
 
   num_frames_since_last_rendering_mode_switch_++;
   if (RuntimeEnabledFeatures::
           enableCanvas2dDynamicRenderingModeSwitchingEnabled() &&
       !RuntimeEnabledFeatures::canvas2dFixedRenderingModeEnabled()) {
-    if (Is2d() && HasImageBuffer() && Buffer()->IsAccelerated() &&
+    if (Is2d() && GetImageBuffer() && GetImageBuffer()->IsAccelerated() &&
         num_frames_since_last_rendering_mode_switch_ >=
             ExpensiveCanvasHeuristicParameters::kMinFramesBeforeSwitch &&
         !pending_rendering_mode_switch_) {
       if (!context_->IsAccelerationOptimalForCanvasContent()) {
         // The switch must be done asynchronously in order to avoid switching
         // during the paint invalidation step.
         Platform::Current()->CurrentThread()->GetWebTaskRunner()->PostTask(
             BLINK_FROM_HERE,
             WTF::Bind(
                 [](WeakPtr<ImageBuffer> buffer) {
                   if (buffer) {
                     buffer->DisableAcceleration();
                   }
                 },
                 image_buffer_->weak_ptr_factory_.CreateWeakPtr()));
         num_frames_since_last_rendering_mode_switch_ = 0;
         pending_rendering_mode_switch_ = true;
       }
     }
   }
 
-  if (pending_rendering_mode_switch_ && Buffer() &&
-      !Buffer()->IsAccelerated()) {
+  if (pending_rendering_mode_switch_ && GetOrCreateImageBuffer() &&
+      !GetOrCreateImageBuffer()->IsAccelerated()) {
     pending_rendering_mode_switch_ = false;
   }
 
   DCHECK(dirty_rect_.IsEmpty());
 }
 
 void HTMLCanvasElement::Reset() {
   if (ignore_reset_)
     return;
 
   dirty_rect_ = FloatRect();
 
   bool ok;
-  bool had_image_buffer = HasImageBuffer();
+  bool had_image_buffer = GetImageBuffer();
 
   int w = getAttribute(widthAttr).ToInt(&ok);
   if (!ok || w < 0)
     w = kDefaultWidth;
 
   int h = getAttribute(heightAttr).ToInt(&ok);
   if (!ok || h < 0)
     h = kDefaultHeight;
 
   if (Is2d())
     context_->Reset();
 
   IntSize old_size = Size();
   IntSize new_size(w, h);
 
   // If the size of an existing buffer matches, we can just clear it instead of
   // reallocating.  This optimization is only done for 2D canvases for now.
   if (had_image_buffer && old_size == new_size && Is2d() &&
-      !Buffer()->IsRecording()) {
+      !GetOrCreateImageBuffer()->IsRecording()) {
     if (!image_buffer_is_clear_) {
       image_buffer_is_clear_ = true;
       context_->clearRect(0, 0, width(), height());
     }
     return;
   }
 
   SetSurfaceSize(new_size);
 
   if (Is3d() && old_size != Size())
@@ skipping 63 matching lines @@
     return;
 
   const ComputedStyle* style = EnsureComputedStyle();
   SkFilterQuality filter_quality =
       (style && style->ImageRendering() == kImageRenderingPixelated)
           ? kNone_SkFilterQuality
           : kLow_SkFilterQuality;
 
   if (Is3d()) {
     context_->SetFilterQuality(filter_quality);
-  } else if (HasImageBuffer()) {
+  } else if (GetImageBuffer()) {
     image_buffer_->SetFilterQuality(filter_quality);
   }
 
-  if (HasImageBuffer() && !image_buffer_is_clear_)
+  if (GetImageBuffer() && !image_buffer_is_clear_)
     PaintTiming::From(GetDocument()).MarkFirstContentfulPaint();
 
   if (!PaintsIntoCanvasBuffer() && !GetDocument().Printing())
     return;
 
   if (PlaceholderFrame()) {
     DCHECK(GetDocument().Printing());
     context.DrawImage(PlaceholderFrame().Get(), PixelSnappedIntRect(r));
     return;
   }
 
   // TODO(junov): Paint is currently only implemented by ImageBitmap contexts.
   // We could improve the abstraction by making all context types paint
   // themselves (implement paint()).
   if (context_->Paint(context, PixelSnappedIntRect(r)))
     return;
 
   context_->PaintRenderingResultsToCanvas(kFrontBuffer);
-  if (HasImageBuffer()) {
+  if (GetImageBuffer()) {
     if (!context.ContextDisabled()) {
       SkBlendMode composite_operator =
           !context_ || context_->CreationAttributes().alpha()
               ? SkBlendMode::kSrcOver
               : SkBlendMode::kSrc;
-      Buffer()->Draw(context, PixelSnappedIntRect(r), 0, composite_operator);
+      GetImageBuffer()->Draw(context, PixelSnappedIntRect(r), 0,
+                             composite_operator);
     }
   } else {
     // When alpha is false, we should draw to opaque black.
     if (!context_->CreationAttributes().alpha())
       context.FillRect(FloatRect(r), Color(0, 0, 0));
   }
 
   if (Is3d() && PaintsIntoCanvasBuffer())
     context_->MarkLayerComposited();
 }
 
 bool HTMLCanvasElement::Is3d() const {
   return context_ && context_->Is3d();
 }
 
 bool HTMLCanvasElement::Is2d() const {
   return context_ && context_->Is2d();
 }
 
 bool HTMLCanvasElement::IsAnimated2d() const {
-  return Is2d() && HasImageBuffer() && image_buffer_->WasDrawnToAfterSnapshot();
+  return Is2d() && GetImageBuffer() &&
+         GetImageBuffer()->WasDrawnToAfterSnapshot();
 }
 
 void HTMLCanvasElement::SetSurfaceSize(const IntSize& size) {
   size_ = size;
   did_fail_to_create_image_buffer_ = false;
   DiscardImageBuffer();
   ClearCopiedImage();
   if (Is2d() && context_->isContextLost()) {
     context_->DidSetSurfaceSize();
   }
 }
 
 const AtomicString HTMLCanvasElement::ImageSourceURL() const {
   return AtomicString(
       ToDataURLInternal(ImageEncoderUtils::kDefaultMimeType, 0, kFrontBuffer));
 }
 
-void HTMLCanvasElement::PrepareSurfaceForPaintingIfNeeded() const {
+void HTMLCanvasElement::PrepareSurfaceForPaintingIfNeeded() {
   DCHECK(Is2d());  // This function is called by the 2d context
-  if (Buffer())
+  if (GetOrCreateImageBuffer())
     image_buffer_->PrepareSurfaceForPaintingIfNeeded();
 }
 
 ImageData* HTMLCanvasElement::ToImageData(SourceDrawingBuffer source_buffer,
                                           SnapshotReason reason) const {
   ImageData* image_data;
   if (Is3d()) {
     // Get non-premultiplied data because of inaccurate premultiplied alpha
     // conversion of buffer()->toDataURL().
     image_data = context_->PaintRenderingResultsToImageData(source_buffer);
     if (image_data)
       return image_data;
 
     context_->PaintRenderingResultsToCanvas(source_buffer);
     image_data = ImageData::Create(size_);
-    if (image_data && HasImageBuffer()) {
+    if (image_data && GetImageBuffer()) {
       sk_sp<SkImage> snapshot =
-          Buffer()->NewSkImageSnapshot(kPreferNoAcceleration, reason);
+          GetImageBuffer()->NewSkImageSnapshot(kPreferNoAcceleration, reason);
       if (snapshot) {
         SkImageInfo image_info = SkImageInfo::Make(
             width(), height(), kRGBA_8888_SkColorType, kUnpremul_SkAlphaType);
         snapshot->readPixels(image_info, image_data->data()->Data(),
                              image_info.minRowBytes(), 0, 0);
       }
     }
     return image_data;
   }
 
   image_data = ImageData::Create(size_);
 
   if ((!context_ || !image_data) && !PlaceholderFrame())
     return image_data;
 
   DCHECK(Is2d() || PlaceholderFrame());
   sk_sp<SkImage> snapshot;
-  if (HasImageBuffer()) {
-    snapshot = Buffer()->NewSkImageSnapshot(kPreferNoAcceleration, reason);
+  if (GetImageBuffer()) {
+    snapshot =
+        GetImageBuffer()->NewSkImageSnapshot(kPreferNoAcceleration, reason);
   } else if (PlaceholderFrame()) {
     DCHECK(PlaceholderFrame()->OriginClean());
     snapshot = PlaceholderFrame()->ImageForCurrentFrame();
   }
 
   if (snapshot) {
     SkImageInfo image_info = SkImageInfo::Make(
         width(), height(), kRGBA_8888_SkColorType, kUnpremul_SkAlphaType);
     snapshot->readPixels(image_info, image_data->data()->Data(),
                          image_info.minRowBytes(), 0, 0);
@@ skipping 394 matching lines @@
       checked_externally_allocated_memory.ValueOrDefault(
           std::numeric_limits<intptr_t>::max());
 
   // Subtracting two intptr_t that are known to be positive will never
   // underflow.
   v8::Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(
       externally_allocated_memory - externally_allocated_memory_);
   externally_allocated_memory_ = externally_allocated_memory;
 }
 
-PaintCanvas* HTMLCanvasElement::DrawingCanvas() const {
-  return Buffer() ? image_buffer_->Canvas() : nullptr;
+PaintCanvas* HTMLCanvasElement::DrawingCanvas() {
+  return GetOrCreateImageBuffer() ? GetImageBuffer()->Canvas() : nullptr;
 }
 
-void HTMLCanvasElement::DisableDeferral(DisableDeferralReason reason) const {
-  if (Buffer())
+void HTMLCanvasElement::DisableDeferral(DisableDeferralReason reason) {
+  if (GetOrCreateImageBuffer())
     image_buffer_->DisableDeferral(reason);
 }
 
 PaintCanvas* HTMLCanvasElement::ExistingDrawingCanvas() const {
-  if (!HasImageBuffer())
+  if (!GetImageBuffer())
     return nullptr;
 
   return image_buffer_->Canvas();
 }
 
-ImageBuffer* HTMLCanvasElement::Buffer() const {
+ImageBuffer* HTMLCanvasElement::GetOrCreateImageBuffer() {
   DCHECK(context_);
   DCHECK(context_->GetContextType() !=
          CanvasRenderingContext::kContextImageBitmap);
-  if (!HasImageBuffer() && !did_fail_to_create_image_buffer_)
-    const_cast<HTMLCanvasElement*>(this)->CreateImageBuffer();
+  if (!image_buffer_ && !did_fail_to_create_image_buffer_)
+    CreateImageBuffer();
   return image_buffer_.get();
 }
 
 void HTMLCanvasElement::CreateImageBufferUsingSurfaceForTesting(
     std::unique_ptr<ImageBufferSurface> surface) {
   DiscardImageBuffer();
   SetIntegralAttribute(widthAttr, surface->size().Width());
   SetIntegralAttribute(heightAttr, surface->size().Height());
   CreateImageBufferInternal(std::move(surface));
 }
 
 void HTMLCanvasElement::EnsureUnacceleratedImageBuffer() {
   DCHECK(context_);
-  if ((HasImageBuffer() && !image_buffer_->IsAccelerated()) ||
+  if ((GetImageBuffer() && !GetImageBuffer()->IsAccelerated()) ||
       did_fail_to_create_image_buffer_)
     return;
   DiscardImageBuffer();
   OpacityMode opacity_mode =
       context_->CreationAttributes().alpha() ? kNonOpaque : kOpaque;
   image_buffer_ = ImageBuffer::Create(Size(), opacity_mode);
   did_fail_to_create_image_buffer_ = !image_buffer_;
 }
 
 PassRefPtr<Image> HTMLCanvasElement::CopiedImage(
     SourceDrawingBuffer source_buffer,
     AccelerationHint hint,
-    SnapshotReason snapshot_reason) const {
+    SnapshotReason snapshot_reason) {
   if (!IsPaintable())
     return nullptr;
   if (!context_)
     return CreateTransparentImage(Size());
 
   if (context_->GetContextType() ==
       CanvasRenderingContext::kContextImageBitmap) {
     RefPtr<Image> image = context_->GetImage(hint, snapshot_reason);
+    // TODO(fserb): return image?
     if (image)
       return context_->GetImage(hint, snapshot_reason);
     // Special case: transferFromImageBitmap is not yet called.
     sk_sp<SkSurface> surface =
         SkSurface::MakeRasterN32Premul(width(), height());
     return StaticBitmapImage::Create(surface->makeImageSnapshot());
   }
 
   bool need_to_update = !copied_image_;
   // The concept of SourceDrawingBuffer is valid on only WebGL.
   if (context_->Is3d())
     need_to_update |= context_->PaintRenderingResultsToCanvas(source_buffer);
-  if (need_to_update && Buffer()) {
-    copied_image_ = Buffer()->NewImageSnapshot(hint, snapshot_reason);
+  if (need_to_update && GetOrCreateImageBuffer()) {
+    copied_image_ = GetImageBuffer()->NewImageSnapshot(hint, snapshot_reason);
     UpdateExternallyAllocatedMemory();
   }
   return copied_image_;
 }
 
 void HTMLCanvasElement::DiscardImageBuffer() {
   image_buffer_.reset();
   dirty_rect_ = FloatRect();
   UpdateExternallyAllocatedMemory();
 }
 
 void HTMLCanvasElement::ClearCopiedImage() {
   if (copied_image_) {
     copied_image_.Clear();
     UpdateExternallyAllocatedMemory();
   }
 }
 
 AffineTransform HTMLCanvasElement::BaseTransform() const {
-  DCHECK(HasImageBuffer() && !did_fail_to_create_image_buffer_);
+  DCHECK(GetImageBuffer() && !did_fail_to_create_image_buffer_);
   return image_buffer_->BaseTransform();
 }
 
 void HTMLCanvasElement::PageVisibilityChanged() {
   if (!context_)
     return;
 
   bool hidden = !GetPage()->IsPageVisible();
   context_->SetIsHidden(hidden);
   if (hidden) {
@@ skipping 17 matching lines @@
 
 void HTMLCanvasElement::DidMoveToNewDocument(Document& old_document) {
   ContextLifecycleObserver::SetContext(&GetDocument());
   PageVisibilityObserver::SetContext(GetDocument().GetPage());
   HTMLElement::DidMoveToNewDocument(old_document);
 }
 
 void HTMLCanvasElement::WillDrawImageTo2DContext(CanvasImageSource* source) {
   if (ExpensiveCanvasHeuristicParameters::kEnableAccelerationToAvoidReadbacks &&
       SharedGpuContext::AllowSoftwareToAcceleratedCanvasUpgrade() &&
-      source->IsAccelerated() && !Buffer()->IsAccelerated() &&
+      source->IsAccelerated() && !GetOrCreateImageBuffer()->IsAccelerated() &&
       ShouldAccelerate(kIgnoreResourceLimitCriteria)) {
     OpacityMode opacity_mode =
         context_->CreationAttributes().alpha() ? kNonOpaque : kOpaque;
     int msaa_sample_count = 0;
     std::unique_ptr<ImageBufferSurface> surface =
         CreateAcceleratedImageBufferSurface(opacity_mode, &msaa_sample_count);
     if (surface) {
-      Buffer()->SetSurface(std::move(surface));
+      GetOrCreateImageBuffer()->SetSurface(std::move(surface));
       SetNeedsCompositingUpdate();
     }
   }
 }
 
 PassRefPtr<Image> HTMLCanvasElement::GetSourceImageForCanvas(
     SourceImageStatus* status,
     AccelerationHint hint,
     SnapshotReason reason,
-    const FloatSize&) const {
+    const FloatSize&) {
   if (!width() || !height()) {
     *status = kZeroSizeCanvasSourceImageStatus;
     return nullptr;
   }
 
   if (!IsPaintable()) {
     *status = kInvalidSourceImageStatus;
     return nullptr;
   }
 
@@ skipping 15 matching lines @@
   }
 
   sk_sp<SkImage> sk_image;
   // TODO(ccameron): Canvas should produce sRGB images.
   // https://crbug.com/672299
   if (Is3d()) {
     // Because WebGL sources always require making a copy of the back buffer, we
     // use paintRenderingResultsToCanvas instead of getImage in order to keep a
     // cached copy of the backing in the canvas's ImageBuffer.
     RenderingContext()->PaintRenderingResultsToCanvas(kBackBuffer);
-    if (HasImageBuffer()) {
-      sk_image = Buffer()->NewSkImageSnapshot(hint, reason);
+    if (GetImageBuffer()) {
+      sk_image = GetImageBuffer()->NewSkImageSnapshot(hint, reason);
     } else {
       sk_image = CreateTransparentSkImage(Size());
     }
   } else {
     if (ExpensiveCanvasHeuristicParameters::
             kDisableAccelerationToAvoidReadbacks &&
         !RuntimeEnabledFeatures::canvas2dFixedRenderingModeEnabled() &&
-        hint == kPreferNoAcceleration && HasImageBuffer() &&
-        Buffer()->IsAccelerated()) {
-      Buffer()->DisableAcceleration();
+        hint == kPreferNoAcceleration && GetImageBuffer() &&
+        GetImageBuffer()->IsAccelerated()) {
+      GetImageBuffer()->DisableAcceleration();
     }
     RefPtr<Image> image = RenderingContext()->GetImage(hint, reason);
     if (image) {
       sk_image = image->ImageForCurrentFrame();
     } else {
       sk_image = CreateTransparentSkImage(Size());
     }
   }
 
   if (sk_image) {
@@ skipping 158 matching lines @@
     // Creates a placeholder layer first before Surface is created.
     surface_layer_bridge_->CreateSolidColorLayer();
   }
 }
 
 void HTMLCanvasElement::OnWebLayerReplaced() {
   SetNeedsCompositingUpdate();
 }
 
 }  // namespace blink