Add OffscreenCanvas to ImageBitmapSource union typedef

third_party/WebKit/Source/core/frame/ImageBitmap.cpp

 // Copyright 2013 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/frame/ImageBitmap.h"
 
 #include "core/html/HTMLCanvasElement.h"
 #include "core/html/HTMLVideoElement.h"
 #include "core/html/ImageData.h"
+#include "core/offscreencanvas/OffscreenCanvas.h"
 #include "platform/graphics/skia/SkiaUtils.h"
 #include "platform/image-decoders/ImageDecoder.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkSurface.h"
 #include "wtf/CheckedNumeric.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/RefPtr.h"
 #include <memory>
 
 namespace blink {
@@ skipping 482 matching lines @@
     m_image = StaticBitmapImage::create(premulSkImageToUnPremul(
         m_image->imageForCurrentFrame(ColorBehavior::transformToGlobalTarget())
             .get()));
   }
   if (!m_image)
     return;
   m_image->setOriginClean(canvas->originClean());
   m_image->setPremultiplied(parsedOptions.premultiplyAlpha);
 }
 
+ImageBitmap::ImageBitmap(OffscreenCanvas* offscreenCanvas,
+                         Optional<IntRect> cropRect,
+                         const ImageBitmapOptions& options) {
+  SourceImageStatus status;
+  RefPtr<Image> input = offscreenCanvas->getSourceImageForCanvas(
+      &status, PreferNoAcceleration, CreateImageBitmapSnapshotReason,
+      FloatSize(offscreenCanvas->size()));
+  if (status != NormalSourceImageStatus)
+    return;
+  ParsedOptions parsedOptions =
+      parseOptions(options, cropRect, IntSize(input->width(), input->height()));
+  if (dstBufferSizeHasOverflow(parsedOptions))
+    return;
+
+  bool isPremultiplyAlphaReverted = false;
+  if (!parsedOptions.premultiplyAlpha) {
+    parsedOptions.premultiplyAlpha = true;
+    isPremultiplyAlphaReverted = true;
+  }
+  m_image = cropImage(input.get(), parsedOptions, PremultiplyAlpha,
+                      ColorBehavior::transformToGlobalTarget());
+  if (!m_image)
+    return;
+  if (isPremultiplyAlphaReverted) {
+    parsedOptions.premultiplyAlpha = false;
+    m_image = StaticBitmapImage::create(
+        premulSkImageToUnPremul(m_image->imageForCurrentFrame().get()));
+  }
+  if (!m_image)
+    return;
+  m_image->setOriginClean(offscreenCanvas->originClean());
+  m_image->setPremultiplied(parsedOptions.premultiplyAlpha);
+}
+
 ImageBitmap::ImageBitmap(const void* pixelData,
                          uint32_t width,
                          uint32_t height,
                          bool isImageBitmapPremultiplied,
                          bool isImageBitmapOriginClean) {
   SkImageInfo info = SkImageInfo::MakeN32(
       width, height,
       isImageBitmapPremultiplied ? kPremul_SkAlphaType : kUnpremul_SkAlphaType);
   SkPixmap pixmap(info, pixelData, info.bytesPerPixel() * width);
   m_image = StaticBitmapImage::create(SkImage::MakeRasterCopy(pixmap));
@@ skipping 238 matching lines @@
                                  const ImageBitmapOptions& options) {
   return new ImageBitmap(video, cropRect, document, options);
 }
 
 ImageBitmap* ImageBitmap::create(HTMLCanvasElement* canvas,
                                  Optional<IntRect> cropRect,
                                  const ImageBitmapOptions& options) {
   return new ImageBitmap(canvas, cropRect, options);
 }
 
+ImageBitmap* ImageBitmap::create(OffscreenCanvas* offscreenCanvas,
+                                 Optional<IntRect> cropRect,
+                                 const ImageBitmapOptions& options) {
+  return new ImageBitmap(offscreenCanvas, cropRect, options);
+}
+
 ImageBitmap* ImageBitmap::create(ImageData* data,
                                  Optional<IntRect> cropRect,
                                  const ImageBitmapOptions& options) {
   return new ImageBitmap(data, cropRect, options);
 }
 
 ImageBitmap* ImageBitmap::create(ImageBitmap* bitmap,
                                  Optional<IntRect> cropRect,
                                  const ImageBitmapOptions& options) {
   return new ImageBitmap(bitmap, cropRect, options);
@@ skipping 99 matching lines @@
 void ImageBitmap::adjustDrawRects(FloatRect* srcRect,
                                   FloatRect* dstRect) const {}
 
 FloatSize ImageBitmap::elementSize(const FloatSize&) const {
   return FloatSize(width(), height());
 }
 
 DEFINE_TRACE(ImageBitmap) {}
 
 }  // namespace blink