Refactor ImageBuffer to make OffscreenCanvas match HTMLCanvasElement

third_party/WebKit/Source/modules/offscreencanvas2d/OffscreenCanvasRenderingContext2D.cpp

 // Copyright 2016 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 "modules/offscreencanvas2d/OffscreenCanvasRenderingContext2D.h"
 
 #include "bindings/modules/v8/OffscreenCanvasRenderingContext2DOrWebGLRenderingContextOrWebGL2RenderingContext.h"
 #include "core/dom/ExecutionContext.h"
 #include "core/frame/ImageBitmap.h"
 #include "core/frame/Settings.h"
 #include "core/workers/WorkerGlobalScope.h"
 #include "core/workers/WorkerSettings.h"
 #include "platform/graphics/ImageBuffer.h"
 #include "platform/graphics/StaticBitmapImage.h"
-#include "platform/graphics/UnacceleratedImageBufferSurface.h"
-#include "platform/graphics/gpu/AcceleratedImageBufferSurface.h"
 #include "platform/graphics/paint/PaintCanvas.h"
 #include "platform/wtf/Assertions.h"
 #include "platform/wtf/CurrentTime.h"
 
 namespace blink {
 
 OffscreenCanvasRenderingContext2D::~OffscreenCanvasRenderingContext2D() {}
 
 OffscreenCanvasRenderingContext2D::OffscreenCanvasRenderingContext2D(
     ScriptState* script_state,
@@ skipping 56 matching lines @@
 
 int OffscreenCanvasRenderingContext2D::Width() const {
   return host()->Size().Width();
 }
 
 int OffscreenCanvasRenderingContext2D::Height() const {
   return host()->Size().Height();
 }
 
 bool OffscreenCanvasRenderingContext2D::HasImageBuffer() const {
-  return !!image_buffer_;
+  return host()->GetImageBuffer();
 }
 
 void OffscreenCanvasRenderingContext2D::Reset() {
-  image_buffer_ = nullptr;
+  host()->DiscardImageBuffer();
   BaseRenderingContext2D::Reset();
 }
 
 ColorBehavior OffscreenCanvasRenderingContext2D::DrawImageColorBehavior()
     const {
   return CanvasRenderingContext::ColorBehaviorForMediaDrawnToCanvas();
 }
 
 ImageBuffer* OffscreenCanvasRenderingContext2D::GetImageBuffer() const {
-  if (!image_buffer_) {
-    IntSize surface_size(Width(), Height());
-    OpacityMode opacity_mode = HasAlpha() ? kNonOpaque : kOpaque;
-    std::unique_ptr<ImageBufferSurface> surface;
-    if (RuntimeEnabledFeatures::accelerated2dCanvasEnabled()) {
-      surface.reset(
-          new AcceleratedImageBufferSurface(surface_size, opacity_mode));
-    }
-
-    if (!surface || !surface->IsValid()) {
-      surface.reset(new UnacceleratedImageBufferSurface(
-          surface_size, opacity_mode, kInitializeImagePixels));
-    }
-
-    OffscreenCanvasRenderingContext2D* non_const_this =
-        const_cast<OffscreenCanvasRenderingContext2D*>(this);
-    non_const_this->image_buffer_ = ImageBuffer::Create(std::move(surface));
-
-    if (needs_matrix_clip_restore_) {
-      RestoreMatrixClipStack(image_buffer_->Canvas());
-      non_const_this->needs_matrix_clip_restore_ = false;
-    }
-  }
-
-  return image_buffer_.get();
+  return const_cast<CanvasRenderingContextHost*>(host())
+      ->GetOrCreateImageBuffer();
 }
 
 RefPtr<StaticBitmapImage>
 OffscreenCanvasRenderingContext2D::TransferToStaticBitmapImage() {
   if (!GetImageBuffer())
     return nullptr;
-  sk_sp<SkImage> sk_image = image_buffer_->NewSkImageSnapshot(
+  sk_sp<SkImage> sk_image = host()->GetImageBuffer()->NewSkImageSnapshot(
       kPreferAcceleration, kSnapshotReasonTransferToImageBitmap);
   RefPtr<StaticBitmapImage> image =
       StaticBitmapImage::Create(std::move(sk_image));
   image->SetOriginClean(this->OriginClean());
   return image;
 }
 
 ImageBitmap* OffscreenCanvasRenderingContext2D::TransferToImageBitmap(
     ScriptState* script_state) {
   UseCounter::Feature feature =
       UseCounter::kOffscreenCanvasTransferToImageBitmap2D;
   UseCounter::Count(ExecutionContext::From(script_state), feature);
   RefPtr<StaticBitmapImage> image = TransferToStaticBitmapImage();
   if (!image)
     return nullptr;
-  image_buffer_.reset();  // "Transfer" means no retained buffer
-  needs_matrix_clip_restore_ = true;
+  host()->DiscardImageBuffer();  // "Transfer" means no retained buffer
   return ImageBitmap::Create(std::move(image));
 }
 
 PassRefPtr<Image> OffscreenCanvasRenderingContext2D::GetImage(
     AccelerationHint hint,
     SnapshotReason reason) const {
   if (!GetImageBuffer())
     return nullptr;
-  sk_sp<SkImage> sk_image = image_buffer_->NewSkImageSnapshot(hint, reason);
+  sk_sp<SkImage> sk_image =
+      host()->GetImageBuffer()->NewSkImageSnapshot(hint, reason);
   RefPtr<StaticBitmapImage> image =
       StaticBitmapImage::Create(std::move(sk_image));
   return image;
 }
 
 ImageData* OffscreenCanvasRenderingContext2D::ToImageData(
     SnapshotReason reason) {
   if (!GetImageBuffer())
     return nullptr;
-  sk_sp<SkImage> snapshot =
-      image_buffer_->NewSkImageSnapshot(kPreferNoAcceleration, reason);
+  sk_sp<SkImage> snapshot = host()->GetImageBuffer()->NewSkImageSnapshot(
+      kPreferNoAcceleration, reason);
   ImageData* image_data = nullptr;
   if (snapshot) {
     image_data = ImageData::Create(host()->Size());
     SkImageInfo image_info =
         SkImageInfo::Make(this->Width(), this->Height(), kRGBA_8888_SkColorType,
                           kUnpremul_SkAlphaType);
     snapshot->readPixels(image_info, image_data->data()->Data(),
                          image_info.minRowBytes(), 0, 0);
   }
   return image_data;
@@ skipping 11 matching lines @@
 }
 
 PaintCanvas* OffscreenCanvasRenderingContext2D::DrawingCanvas() const {
   ImageBuffer* buffer = GetImageBuffer();
   if (!buffer)
     return nullptr;
   return GetImageBuffer()->Canvas();
 }
 
 PaintCanvas* OffscreenCanvasRenderingContext2D::ExistingDrawingCanvas() const {
-  if (!image_buffer_)
+  if (!host()->GetImageBuffer())
     return nullptr;
-  return image_buffer_->Canvas();
+  return host()->GetImageBuffer()->Canvas();
 }
 
 void OffscreenCanvasRenderingContext2D::DisableDeferral(DisableDeferralReason) {
 }
 
 AffineTransform OffscreenCanvasRenderingContext2D::BaseTransform() const {
-  if (!image_buffer_)
+  if (!host()->GetImageBuffer())
     return AffineTransform();  // identity
-  return image_buffer_->BaseTransform();
+  return host()->GetImageBuffer()->BaseTransform();
 }
 
 void OffscreenCanvasRenderingContext2D::DidDraw(const SkIRect& dirty_rect) {}
 
 bool OffscreenCanvasRenderingContext2D::StateHasFilter() {
   return GetState().HasFilterForOffscreenCanvas(host()->Size());
 }
 
 sk_sp<SkImageFilter> OffscreenCanvasRenderingContext2D::StateGetFilter() {
   return GetState().GetFilterForOffscreenCanvas(host()->Size());
 }
 
 void OffscreenCanvasRenderingContext2D::ValidateStateStack() const {
 #if DCHECK_IS_ON()
   if (PaintCanvas* sk_canvas = ExistingDrawingCanvas()) {
     DCHECK_EQ(static_cast<size_t>(sk_canvas->getSaveCount()),
               state_stack_.size() + 1);
   }
 #endif
 }
 
 bool OffscreenCanvasRenderingContext2D::isContextLost() const {
   return false;
 }
 
 bool OffscreenCanvasRenderingContext2D::IsPaintable() const {
-  return this->GetImageBuffer();
+  return GetImageBuffer();
 }
 
 CanvasColorSpace OffscreenCanvasRenderingContext2D::ColorSpace() const {
   return color_params().color_space();
 }
 
 String OffscreenCanvasRenderingContext2D::ColorSpaceAsString() const {
   return CanvasRenderingContext::ColorSpaceAsString();
 }
 
 CanvasPixelFormat OffscreenCanvasRenderingContext2D::PixelFormat() const {
   return color_params().pixel_format();
 }
 
 bool OffscreenCanvasRenderingContext2D::IsAccelerated() const {
-  return image_buffer_ && image_buffer_->IsAccelerated();
+  return host()->GetImageBuffer() && host()->GetImageBuffer()->IsAccelerated();
 }
 }