Refactor ImageBuffer to make OffscreenCanvas match HTMLCanvasElement

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

 // 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.
 
 #ifndef OffscreenCanvas_h
 #define OffscreenCanvas_h
 
 #include <memory>
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/ScriptWrappable.h"
 #include "core/events/EventTarget.h"
 #include "core/html/HTMLCanvasElement.h"
 #include "core/html/canvas/CanvasImageSource.h"
 #include "core/html/canvas/CanvasRenderingContextHost.h"
+#include "core/imagebitmap/ImageBitmapSource.h"
 #include "core/offscreencanvas/ImageEncodeOptions.h"
 #include "platform/geometry/IntSize.h"
 #include "platform/graphics/OffscreenCanvasFrameDispatcher.h"
 #include "platform/heap/Handle.h"
 
 namespace blink {
 
 class CanvasContextCreationAttributes;
 class ImageBitmap;
 class
@@ skipping 50 matching lines @@
   static void RegisterRenderingContextFactory(
       std::unique_ptr<CanvasRenderingContextFactory>);
 
   bool OriginClean() const;
   void SetOriginTainted() { origin_clean_ = false; }
   // TODO(crbug.com/630356): apply the flag to WebGL context as well
   void SetDisableReadingFromCanvasTrue() {
     disable_reading_from_canvas_ = true;
   }
 
+  void DiscardImageBuffer() override;
+  ImageBuffer* GetImageBuffer() const { return image_buffer_.get(); }
+  ImageBuffer* GetOrCreateImageBuffer() override;
+
   void SetFrameSinkId(uint32_t client_id, uint32_t sink_id) {
     client_id_ = client_id;
     sink_id_ = sink_id;
   }
   uint32_t ClientId() const { return client_id_; }
   uint32_t SinkId() const { return sink_id_; }
 
   void SetExecutionContext(ExecutionContext* context) {
     execution_context_ = context;
   }
@@ skipping 30 matching lines @@
   ScriptPromise CreateImageBitmap(ScriptState*,
                                   EventTarget&,
                                   Optional<IntRect>,
                                   const ImageBitmapOptions&,
                                   ExceptionState&) final;
 
   // CanvasImageSource implementation
   PassRefPtr<Image> GetSourceImageForCanvas(SourceImageStatus*,
                                             AccelerationHint,
                                             SnapshotReason,
-                                            const FloatSize&) const final;
+                                            const FloatSize&) final;
   bool WouldTaintOrigin(SecurityOrigin*) const final { return !origin_clean_; }
   FloatSize ElementSize(const FloatSize& default_object_size) const final {
     return FloatSize(width(), height());
   }
   bool IsOpaque() const final;
   bool IsAccelerated() const final;
   int SourceWidth() final { return width(); }
   int SourceHeight() final { return height(); }
 
   DispatchEventResult HostDispatchEvent(Event* event) {
@@ skipping 27 matching lines @@
   bool disable_reading_from_canvas_ = false;
 
   bool IsPaintable() const;
 
   std::unique_ptr<OffscreenCanvasFrameDispatcher> frame_dispatcher_;
 
   Member<ScriptPromiseResolver> commit_promise_resolver_;
   RefPtr<StaticBitmapImage> current_frame_;
   bool current_frame_is_web_gl_software_rendering_ = false;
 
+  std::unique_ptr<ImageBuffer> image_buffer_;
+  bool needs_matrix_clip_restore_ = false;
+
   // cc::FrameSinkId is broken into two integer components as this can be used
   // in transfer of OffscreenCanvas across threads
   // If this object is not created via
   // HTMLCanvasElement.transferControlToOffscreen(),
   // then the following members would remain as initialized zero values.
   uint32_t client_id_ = 0;
   uint32_t sink_id_ = 0;
 };
 
 }  // namespace blink
 
 #endif  // OffscreenCanvas_h