Refactor ImageBuffer to make OffscreenCanvas match HTMLCanvasElement

third_party/WebKit/Source/core/offscreencanvas/OffscreenCanvas.cpp

 // 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 "core/offscreencanvas/OffscreenCanvas.h"
 
 #include <memory>
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/ExecutionContext.h"
 #include "core/fileapi/Blob.h"
 #include "core/frame/ImageBitmap.h"
 #include "core/html/ImageData.h"
 #include "core/html/canvas/CanvasAsyncBlobCreator.h"
 #include "core/html/canvas/CanvasContextCreationAttributes.h"
 #include "core/html/canvas/CanvasRenderingContext.h"
 #include "core/html/canvas/CanvasRenderingContextFactory.h"
 #include "platform/graphics/Image.h"
 #include "platform/graphics/ImageBuffer.h"
 #include "platform/graphics/OffscreenCanvasFrameDispatcherImpl.h"
 #include "platform/graphics/StaticBitmapImage.h"
+#include "platform/graphics/UnacceleratedImageBufferSurface.h"
+#include "platform/graphics/gpu/AcceleratedImageBufferSurface.h"
 #include "platform/image-encoders/ImageEncoderUtils.h"
 #include "platform/instrumentation/tracing/TraceEvent.h"
 #include "platform/wtf/MathExtras.h"
 #include "public/platform/Platform.h"
 #include "third_party/skia/include/core/SkSurface.h"
 
 namespace blink {
 
 OffscreenCanvas::OffscreenCanvas(const IntSize& size) : size_(size) {}
 
@@ skipping 71 matching lines @@
     // Undocumented exception (not in spec)
     exception_state.ThrowDOMException(kV8Error, "Out of memory");
   }
   return image;
 }
 
 PassRefPtr<Image> OffscreenCanvas::GetSourceImageForCanvas(
     SourceImageStatus* status,
     AccelerationHint hint,
     SnapshotReason reason,
-    const FloatSize& size) const {
+    const FloatSize& size) {
   if (!context_) {
     *status = kInvalidSourceImageStatus;
     sk_sp<SkSurface> surface =
         SkSurface::MakeRasterN32Premul(size_.Width(), size_.Height());
     return surface ? StaticBitmapImage::Create(surface->makeImageSnapshot())
                    : nullptr;
   }
   if (!size.Width() || !size.Height()) {
     *status = kZeroSizeCanvasSourceImageStatus;
     return nullptr;
@@ skipping 107 matching lines @@
     // The frame dispatcher connects the current thread of OffscreenCanvas
     // (either main or worker) to the browser process and remains unchanged
     // throughout the lifetime of this OffscreenCanvas.
     frame_dispatcher_ = WTF::WrapUnique(new OffscreenCanvasFrameDispatcherImpl(
         this, client_id_, sink_id_, placeholder_canvas_id_, size_.Width(),
         size_.Height()));
   }
   return frame_dispatcher_.get();
 }
 
+void OffscreenCanvas::DiscardImageBuffer() {
+  image_buffer_.reset();
+  needs_matrix_clip_restore_ = true;
+}
+
+ImageBuffer* OffscreenCanvas::GetOrCreateImageBuffer() {
+  if (!image_buffer_) {
+    IntSize surface_size(width(), height());
+    OpacityMode opacity_mode =
+        context_->CreationAttributes().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));
+    }
+
+    image_buffer_ = ImageBuffer::Create(std::move(surface));
+
+    if (needs_matrix_clip_restore_) {
+      needs_matrix_clip_restore_ = false;
+      context_->RestoreCanvasMatrixClipStack(image_buffer_->Canvas());
+    }
+  }
+
+  return image_buffer_.get();
+}
+
 ScriptPromise OffscreenCanvas::Commit(RefPtr<StaticBitmapImage> image,
                                       bool is_web_gl_software_rendering,
                                       ScriptState* script_state,
                                       ExceptionState& exception_state) {
   TRACE_EVENT0("blink", "OffscreenCanvas::Commit");
 
   if (!HasPlaceholderCanvas()) {
     exception_state.ThrowDOMException(
         kInvalidStateError,
         "Commit() was called on a context whose "
@@ skipping 118 matching lines @@
 }
 
 DEFINE_TRACE(OffscreenCanvas) {
   visitor->Trace(context_);
   visitor->Trace(execution_context_);
   visitor->Trace(commit_promise_resolver_);
   EventTargetWithInlineData::Trace(visitor);
 }
 
 }  // namespace blink