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()) ||
+         (HasImageBuffer() && 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);
+    GetImageBuffer()->DidDraw(rect);
 }
 
 void HTMLCanvasElement::DidDraw() {
   DidDraw(FloatRect(0, 0, Size().Width(), Size().Height()));
 }
 
 void HTMLCanvasElement::FinalizeFrame() {
   if (HasImageBuffer())
     image_buffer_->FinalizeFrame();
 
@@ skipping 87 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() && HasImageBuffer() && 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_ && GetImageBuffer() &&
+      !GetImageBuffer()->IsAccelerated()) {
     pending_rendering_mode_switch_ = false;
   }
 
   DCHECK(dirty_rect_.IsEmpty());
 }
 
 void HTMLCanvasElement::Reset() {
   if (ignore_reset_)
     return;
 
@@ skipping 12 matching lines @@
 
   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()) {
+      !GetImageBuffer()->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 92 matching lines @@
   if (context_->Paint(context, PixelSnappedIntRect(r)))
     return;
 
   context_->PaintRenderingResultsToCanvas(kFrontBuffer);
   if (HasImageBuffer()) {
     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();
 }
@@ skipping 20 matching lines @@
   }
 }
 
 const AtomicString HTMLCanvasElement::ImageSourceURL() const {
   return AtomicString(
       ToDataURLInternal(ImageEncoderUtils::kDefaultMimeType, 0, kFrontBuffer));
 }
 
 void HTMLCanvasElement::PrepareSurfaceForPaintingIfNeeded() const {
   DCHECK(Is2d());  // This function is called by the 2d context
-  if (Buffer())
+  if (GetImageBuffer())
     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()) {
       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);
+    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 395 matching lines @@
           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;
+  return GetImageBuffer() ? image_buffer_->Canvas() : nullptr;
 }
 
 void HTMLCanvasElement::DisableDeferral(DisableDeferralReason reason) const {
-  if (Buffer())
+  if (GetImageBuffer())
     image_buffer_->DisableDeferral(reason);
 }
 
 PaintCanvas* HTMLCanvasElement::ExistingDrawingCanvas() const {
   if (!HasImageBuffer())
     return nullptr;
 
   return image_buffer_->Canvas();
 }
 
-ImageBuffer* HTMLCanvasElement::Buffer() const {
+ImageBuffer* HTMLCanvasElement::GetImageBuffer() const {

[Justin Novosad, 2017/05/01 15:18:57]

Nit (existed before this CL): This function does not deserve "const" IMHO,
especially once its semantics are clarified by renaming it "GetOrCreate". I also
think "const" is overused by the methods that call this function.  const_casts
like the one below are hypocritical and should be avoided with only a few rare
exceptions (e.g. caches, stats needed for validations or consistency checks).

[fserb, 2017/05/02 18:49:30]

done

   DCHECK(context_);
   DCHECK(context_->GetContextType() !=
          CanvasRenderingContext::kContextImageBitmap);
   if (!HasImageBuffer() && !did_fail_to_create_image_buffer_)
     const_cast<HTMLCanvasElement*>(this)->CreateImageBuffer();
   return image_buffer_.get();
 }
 
 void HTMLCanvasElement::CreateImageBufferUsingSurfaceForTesting(
     std::unique_ptr<ImageBufferSurface> surface) {
@@ skipping 32 matching lines @@
     // 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 && GetImageBuffer()) {
+    copied_image_ = GetImageBuffer()->NewImageSnapshot(hint, snapshot_reason);
     UpdateExternallyAllocatedMemory();
   }
   return copied_image_;
 }
 
 void HTMLCanvasElement::DiscardImageBuffer() {
   image_buffer_.reset();
   dirty_rect_ = FloatRect();
   UpdateExternallyAllocatedMemory();
 }
@@ skipping 37 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() && !GetImageBuffer()->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));
+      GetImageBuffer()->SetSurface(std::move(surface));
       SetNeedsCompositingUpdate();
     }
   }
 }
 
 PassRefPtr<Image> HTMLCanvasElement::GetSourceImageForCanvas(
     SourceImageStatus* status,
     AccelerationHint hint,
     SnapshotReason reason,
     const FloatSize&) const {
@@ skipping 26 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);
+      sk_image = GetImageBuffer()->NewSkImageSnapshot(hint, reason);
     } else {
       sk_image = CreateTransparentSkImage(Size());
     }
   } else {
     if (ExpensiveCanvasHeuristicParameters::
             kDisableAccelerationToAvoidReadbacks &&
         !RuntimeEnabledFeatures::canvas2dFixedRenderingModeEnabled() &&
         hint == kPreferNoAcceleration && HasImageBuffer() &&
-        Buffer()->IsAccelerated()) {
-      Buffer()->DisableAcceleration();
+        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