Use union type in ImageBitmapFactories.idl

third_party/WebKit/Source/modules/canvas2d/CanvasRenderingContext2DTest.cpp

 // Copyright 2014 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 "config.h"
 #include "modules/canvas2d/CanvasRenderingContext2D.h"
 
+#include "core/fetch/MemoryCache.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/ImageBitmap.h"
 #include "core/html/HTMLCanvasElement.h"
 #include "core/html/HTMLDocument.h"
 #include "core/html/ImageData.h"
 #include "core/loader/EmptyClients.h"
 #include "core/testing/DummyPageHolder.h"
 #include "modules/canvas2d/CanvasGradient.h"
 #include "modules/canvas2d/CanvasPattern.h"
 #include "modules/webgl/WebGLRenderingContext.h"
@@ skipping 55 matching lines @@
 protected:
     CanvasRenderingContext2DTest();
     void SetUp() override;
 
     DummyPageHolder& page() const { return *m_dummyPageHolder; }
     HTMLDocument& document() const { return *m_document; }
     HTMLCanvasElement& canvasElement() const { return *m_canvasElement; }
     CanvasRenderingContext2D* context2d() const { return static_cast<CanvasRenderingContext2D*>(canvasElement().renderingContext()); }
 
     void createContext(OpacityMode);
+    void TearDown();
 
 private:
     OwnPtr<DummyPageHolder> m_dummyPageHolder;
     RefPtrWillBePersistent<HTMLDocument> m_document;
     RefPtrWillBePersistent<HTMLCanvasElement> m_canvasElement;
+    Persistent<MemoryCache> m_globalMemoryCache;
 
     class WrapGradients final : public NoBaseWillBeGarbageCollectedFinalized<WrapGradients> {
     public:
         static PassOwnPtrWillBeRawPtr<WrapGradients> create()
         {
             return adoptPtrWillBeNoop(new WrapGradients);
         }
 
         DEFINE_INLINE_TRACE()
         {
@@ skipping 54 matching lines @@
     EXPECT_FALSE(exceptionState.hadException());
     this->opaqueGradient().setCanvasGradient(opaqueGradient);
 
     CanvasGradient* alphaGradient = CanvasGradient::create(FloatPoint(0, 0), FloatPoint(10, 0));
     alphaGradient->addColorStop(0, String("green"), exceptionState);
     EXPECT_FALSE(exceptionState.hadException());
     alphaGradient->addColorStop(1, String("rgba(0, 0, 255, 0.5)"), exceptionState);
     EXPECT_FALSE(exceptionState.hadException());
     StringOrCanvasGradientOrCanvasPattern wrappedAlphaGradient;
     this->alphaGradient().setCanvasGradient(alphaGradient);
+
+    m_globalMemoryCache = replaceMemoryCacheForTesting(MemoryCache::create());
+}
+
+void CanvasRenderingContext2DTest::TearDown()
+{
+    Heap::collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithSweep, BlinkGC::ForcedGC);
+    replaceMemoryCacheForTesting(m_globalMemoryCache.release());
 }
 
 //============================================================================
 
 class MockImageBufferSurfaceForOverwriteTesting : public UnacceleratedImageBufferSurface {
 public:
     MockImageBufferSurfaceForOverwriteTesting(const IntSize& size, OpacityMode mode) : UnacceleratedImageBufferSurface(size, mode) { }
     ~MockImageBufferSurfaceForOverwriteTesting() override { }
     bool isRecording() const override { return true; } // otherwise overwrites are not tracked
 
@@ skipping 421 matching lines @@
     canvasElement().createImageBufferUsingSurfaceForTesting(surface.release());
 
     context2d()->fillRect(0, 0, 1, 1); // To have a non-empty dirty rect
     for (int i = 0; i < ExpensiveCanvasHeuristicParameters::ExpensiveRecordingStackDepth; ++i) {
         context2d()->save();
         context2d()->translate(1.0f, 0.0f);
     }
     canvasElement().doDeferredPaintInvalidation(); // To close the current frame
 }
 
+TEST_F(CanvasRenderingContext2DTest, ImageResourceLifetime)
+{
+    RefPtrWillBeRawPtr<HTMLCanvasElement> canvasElement = HTMLCanvasElement::create(*Document::create().get());
+    canvasElement->setHeight(40);
+    canvasElement->setWidth(40);
+    RefPtrWillBeRawPtr<ImageBitmap> imageBitmapDerived = nullptr;
+    {
+        RefPtrWillBeRawPtr<ImageBitmap> imageBitmapFromCanvas = ImageBitmap::create(canvasElement.get(), IntRect(0, 0, canvasElement->width(), canvasElement->height()));
+        imageBitmapDerived = ImageBitmap::create(imageBitmapFromCanvas.get(), IntRect(0, 0, 20, 20));
+    }
+    CanvasContextCreationAttributes attributes;
+    CanvasRenderingContext2D* context = static_cast<CanvasRenderingContext2D*>(canvasElement->getCanvasRenderingContext("2d", attributes));
+    TrackExceptionState exceptionState;
+    CanvasImageSourceUnion imageSource;
+    imageSource.setImageBitmap(imageBitmapDerived);
+    context->drawImage(imageSource, 0, 0, exceptionState);
+}
+
 } // namespace blink