Add a origin clean flag in ImageBitmap class

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 "third_party/skia/include/core/SkSurface.h"
@@ skipping 27 matching lines @@
     SkScalar dstLeft = std::min(0, -cropRect.x());
     SkScalar dstTop = std::min(0, -cropRect.y());
     if (cropRect.x() < 0)
         dstLeft = -cropRect.x();
     if (cropRect.y() < 0)
         dstTop = -cropRect.y();
     surface->getCanvas()->drawImage(image->imageForCurrentFrame().get(), dstLeft, dstTop);
     return StaticBitmapImage::create(adoptRef(surface->newImageSnapshot()));
 }
 
-ImageBitmap::ImageBitmap(HTMLImageElement* image, const IntRect& cropRect)
+ImageBitmap::ImageBitmap(HTMLImageElement* image, const IntRect& cropRect, Document* document)
 {
+    m_isOriginClean = !image->wouldTaintOrigin(document->securityOrigin());
     m_image = cropImage(image->cachedImage()->image(), cropRect);
 }
 
-ImageBitmap::ImageBitmap(HTMLVideoElement* video, const IntRect& cropRect)
+ImageBitmap::ImageBitmap(HTMLVideoElement* video, const IntRect& cropRect, Document* document)
 {
     IntSize playerSize;
     if (video->webMediaPlayer())
         playerSize = video->webMediaPlayer()->naturalSize();
 
     IntRect videoRect = IntRect(IntPoint(), playerSize);
     IntRect srcRect = intersection(cropRect, videoRect);
     OwnPtr<ImageBuffer> buffer = ImageBuffer::create(cropRect.size(), NonOpaque, DoNotInitializeImagePixels);
     if (!buffer)
         return;
 
     IntPoint dstPoint = IntPoint(std::max(0, -cropRect.x()), std::max(0, -cropRect.y()));
     video->paintCurrentFrame(buffer->canvas(), IntRect(dstPoint, srcRect.size()), nullptr);
+    m_isOriginClean = !video->wouldTaintOrigin(document->securityOrigin());
     m_image = StaticBitmapImage::create(buffer->newSkImageSnapshot(PreferNoAcceleration));
 }
 
 ImageBitmap::ImageBitmap(HTMLCanvasElement* canvas, const IntRect& cropRect)
 {
     ASSERT(canvas->isPaintable());
+    m_isOriginClean = canvas->originClean();
     m_image = cropImage(canvas->copiedImage(BackBuffer, PreferAcceleration).get(), cropRect);
 }
 
 ImageBitmap::ImageBitmap(ImageData* data, const IntRect& cropRect)
 {
     IntRect srcRect = intersection(cropRect, IntRect(IntPoint(), data->size()));
 
     OwnPtr<ImageBuffer> buffer = ImageBuffer::create(cropRect.size(), NonOpaque, DoNotInitializeImagePixels);
     if (!buffer)
         return;
 
     if (srcRect.isEmpty()) {
         m_image = StaticBitmapImage::create(buffer->newSkImageSnapshot(PreferNoAcceleration));
         return;
     }
 
     IntPoint dstPoint = IntPoint(std::min(0, -cropRect.x()), std::min(0, -cropRect.y()));
     if (cropRect.x() < 0)
         dstPoint.setX(-cropRect.x());
     if (cropRect.y() < 0)
         dstPoint.setY(-cropRect.y());
     buffer->putByteArray(Unmultiplied, data->data()->data(), data->size(), srcRect, dstPoint);
     m_image = StaticBitmapImage::create(buffer->newSkImageSnapshot(PreferNoAcceleration));
 }
 
 ImageBitmap::ImageBitmap(ImageBitmap* bitmap, const IntRect& cropRect)
 {
+    m_isOriginClean = bitmap->originClean();
     m_image = cropImage(bitmap->bitmapImage(), cropRect);
 }
 
 ImageBitmap::ImageBitmap(Image* image, const IntRect& cropRect)
 {
+    m_isOriginClean = !image->currentFrameHasSingleSecurityOrigin();
     m_image = cropImage(image, cropRect);
 }
 
 ImageBitmap::ImageBitmap(PassRefPtr<StaticBitmapImage> image)
 {
+    m_isOriginClean = !image->currentFrameHasSingleSecurityOrigin();

[xidachen, 2016/01/05 20:04:36]

Is this what we want? For StaticBitmapImage&Image, the
currentFrameHasSingleSecurityOrigin() is set to be always false. This will set
the origin clean flag of this ImageBitmap to be always clean.

     m_image = image;
 }
 
 PassRefPtr<StaticBitmapImage> ImageBitmap::transfer()
 {
     ASSERT(!isNeutered());
     m_isNeutered = true;
     return m_image.release();
 }
 
 ImageBitmap::~ImageBitmap()
 {
 }
 
-PassRefPtrWillBeRawPtr<ImageBitmap> ImageBitmap::create(HTMLImageElement* image, const IntRect& cropRect)
+PassRefPtrWillBeRawPtr<ImageBitmap> ImageBitmap::create(HTMLImageElement* image, const IntRect& cropRect, Document* document)
 {
     IntRect normalizedCropRect = normalizeRect(cropRect);
-    return adoptRefWillBeNoop(new ImageBitmap(image, normalizedCropRect));
+    return adoptRefWillBeNoop(new ImageBitmap(image, normalizedCropRect, document));
 }
 
-PassRefPtrWillBeRawPtr<ImageBitmap> ImageBitmap::create(HTMLVideoElement* video, const IntRect& cropRect)
+PassRefPtrWillBeRawPtr<ImageBitmap> ImageBitmap::create(HTMLVideoElement* video, const IntRect& cropRect, Document* document)
 {
     IntRect normalizedCropRect = normalizeRect(cropRect);
-    return adoptRefWillBeNoop(new ImageBitmap(video, normalizedCropRect));
+    return adoptRefWillBeNoop(new ImageBitmap(video, normalizedCropRect, document));
 }
 
 PassRefPtrWillBeRawPtr<ImageBitmap> ImageBitmap::create(HTMLCanvasElement* canvas, const IntRect& cropRect)
 {
     IntRect normalizedCropRect = normalizeRect(cropRect);
     return adoptRefWillBeNoop(new ImageBitmap(canvas, normalizedCropRect));
 }
 
 PassRefPtrWillBeRawPtr<ImageBitmap> ImageBitmap::create(ImageData* data, const IntRect& cropRect)
 {
@@ skipping 69 matching lines @@
 {
     return FloatSize(width(), height());
 }
 
 DEFINE_TRACE(ImageBitmap)
 {
     ImageLoaderClient::trace(visitor);
 }
 
 } // namespace blink