Oilpan: fix unit tests bugs unmasked by r196836.

Source/core/html/canvas/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 "core/html/canvas/CanvasRenderingContext2D.h"
 
 #include "core/frame/FrameView.h"
 #include "core/frame/ImageBitmap.h"
 #include "core/html/HTMLDocument.h"
@@ skipping 67 matching lines @@
     HTMLCanvasElement& canvasElement() const { return *m_canvasElement; }
     CanvasRenderingContext2D* context2d() const { return static_cast<CanvasRenderingContext2D*>(canvasElement().renderingContext()); }
 
     void createContext(OpacityMode);
 
 private:
     OwnPtr<DummyPageHolder> m_dummyPageHolder;
     RefPtrWillBePersistent<HTMLDocument> m_document;
     RefPtrWillBePersistent<HTMLCanvasElement> m_canvasElement;
 
+    class WrapGradients final : public NoBaseWillBeGarbageCollectedFinalized<WrapGradients> {
+    public:
+        static PassOwnPtrWillBeRawPtr<WrapGradients> create()
+        {
+            return adoptPtrWillBeNoop(new WrapGradients);
+        }
+
+        DEFINE_INLINE_TRACE()
+        {
+            visitor->trace(m_opaqueGradient);
+            visitor->trace(m_alphaGradient);
+        }
+
+        StringOrCanvasGradientOrCanvasPattern m_opaqueGradient;
+        StringOrCanvasGradientOrCanvasPattern m_alphaGradient;
+    };
+
+    // TODO(Oilpan): avoid tedious part-object wrapper by supporting on-heap ::testing::Tests.
+    OwnPtrWillBePersistent<WrapGradients> m_wrapGradients;
+
 protected:
     // Pre-canned objects for testing
     Persistent<ImageData> m_fullImageData;
     Persistent<ImageData> m_partialImageData;
     FakeImageSource m_opaqueBitmap;
     FakeImageSource m_alphaBitmap;
-    StringOrCanvasGradientOrCanvasPattern m_opaqueGradient;
-    StringOrCanvasGradientOrCanvasPattern m_alphaGradient;
+
+    StringOrCanvasGradientOrCanvasPattern& opaqueGradient() { return m_wrapGradients->m_opaqueGradient; }
+    StringOrCanvasGradientOrCanvasPattern& alphaGradient() { return m_wrapGradients->m_alphaGradient; }
 };
 
 CanvasRenderingContext2DTest::CanvasRenderingContext2DTest()
-    : m_opaqueBitmap(IntSize(10, 10), OpaqueBitmap)
+    : m_wrapGradients(WrapGradients::create())
+    , m_opaqueBitmap(IntSize(10, 10), OpaqueBitmap)
     , m_alphaBitmap(IntSize(10, 10), TransparentBitmap)
 { }
 
 void CanvasRenderingContext2DTest::createContext(OpacityMode opacityMode)
 {
     String canvasType("2d");
     CanvasContextCreationAttributes attributes;
     attributes.setAlpha(opacityMode == NonOpaque);
     CanvasRenderingContext2DOrWebGLRenderingContext result;
     m_canvasElement->getContext(canvasType, attributes, result);
@@ skipping 11 matching lines @@
 
     m_fullImageData = ImageData::create(IntSize(10, 10));
     m_partialImageData = ImageData::create(IntSize(2, 2));
 
     NonThrowableExceptionState exceptionState;
     RefPtrWillBeRawPtr<CanvasGradient> opaqueGradient = CanvasGradient::create(FloatPoint(0, 0), FloatPoint(10, 0));
     opaqueGradient->addColorStop(0, String("green"), exceptionState);
     EXPECT_FALSE(exceptionState.hadException());
     opaqueGradient->addColorStop(1, String("blue"), exceptionState);
     EXPECT_FALSE(exceptionState.hadException());
-    m_opaqueGradient.setCanvasGradient(opaqueGradient);
+    this->opaqueGradient().setCanvasGradient(opaqueGradient);
 
     RefPtrWillBeRawPtr<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;
-    m_alphaGradient.setCanvasGradient(alphaGradient);
+    this->alphaGradient().setCanvasGradient(alphaGradient);
 }
 
 //============================================================================
 
 class MockImageBufferSurfaceForOverwriteTesting : public UnacceleratedImageBufferSurface {
 public:
     MockImageBufferSurfaceForOverwriteTesting(const IntSize& size, OpacityMode mode) : UnacceleratedImageBufferSurface(size, mode) { }
     virtual ~MockImageBufferSurfaceForOverwriteTesting() { }
     bool isRecording() const override { return true; } // otherwise overwrites are not tracked
 
     MOCK_METHOD0(willOverwriteCanvas, void());
 };
 
 //============================================================================
 
-class MockCanvasObserver : public NoBaseWillBeGarbageCollectedFinalized<MockCanvasObserver>, public CanvasObserver {
+class MockCanvasObserver final : public NoBaseWillBeGarbageCollectedFinalized<MockCanvasObserver>, public CanvasObserver {
     WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(MockCanvasObserver);
 public:
     static PassOwnPtrWillBeRawPtr<MockCanvasObserver> create()
     {
         return adoptPtrWillBeNoop(new MockCanvasObserver);
     }
 
+    DEFINE_INLINE_VIRTUAL_TRACE()
+    {
+        CanvasObserver::trace(visitor);
+    }
+
+
     virtual ~MockCanvasObserver() { }
     MOCK_METHOD2(canvasChanged, void(HTMLCanvasElement*, const FloatRect&));
     MOCK_METHOD1(canvasResized, void(HTMLCanvasElement*));
 #if !ENABLE(OILPAN)
     void canvasDestroyed(HTMLCanvasElement*) override { };
 #endif
 };
 
 //============================================================================
 
@@ skipping 81 matching lines @@
 {
     createContext(NonOpaque);
 
     TEST_OVERDRAW_1(1, fillRect(-1, -1, 12, 12));
     TEST_OVERDRAW_1(1, fillRect(0, 0, 10, 10));
     TEST_OVERDRAW_1(0, strokeRect(0, 0, 10, 10)); // stroking instead of filling does not overwrite
     TEST_OVERDRAW_2(0, setGlobalAlpha(0.5f), fillRect(0, 0, 10, 10));
     TEST_OVERDRAW_1(0, fillRect(0, 0, 9, 9));
     TEST_OVERDRAW_2(0, translate(1, 1), fillRect(0, 0, 10, 10));
     TEST_OVERDRAW_2(1, translate(1, 1), fillRect(-1, -1, 10, 10));
-    TEST_OVERDRAW_2(1, setFillStyle(m_opaqueGradient), fillRect(0, 0, 10, 10));
-    TEST_OVERDRAW_2(0, setFillStyle(m_alphaGradient), fillRect(0, 0, 10, 10));
-    TEST_OVERDRAW_3(0, setGlobalAlpha(0.5), setFillStyle(m_opaqueGradient), fillRect(0, 0, 10, 10));
+    TEST_OVERDRAW_2(1, setFillStyle(opaqueGradient()), fillRect(0, 0, 10, 10));
+    TEST_OVERDRAW_2(0, setFillStyle(alphaGradient()), fillRect(0, 0, 10, 10));
+    TEST_OVERDRAW_3(0, setGlobalAlpha(0.5), setFillStyle(opaqueGradient()), fillRect(0, 0, 10, 10));
     TEST_OVERDRAW_3(1, setGlobalAlpha(0.5f), setGlobalCompositeOperation(String("copy")), fillRect(0, 0, 10, 10));
     TEST_OVERDRAW_2(1, setGlobalCompositeOperation(String("copy")), fillRect(0, 0, 9, 9));
     TEST_OVERDRAW_3(0, rect(0, 0, 5, 5), clip(), fillRect(0, 0, 10, 10));
     TEST_OVERDRAW_4(0, rect(0, 0, 5, 5), clip(), setGlobalCompositeOperation(String("copy")), fillRect(0, 0, 10, 10));
 }
 
 TEST_F(CanvasRenderingContext2DTest, detectOverdrawWithClearRect)
 {
     createContext(NonOpaque);
 
     TEST_OVERDRAW_1(1, clearRect(0, 0, 10, 10));
     TEST_OVERDRAW_1(0, clearRect(0, 0, 9, 9));
     TEST_OVERDRAW_2(1, setGlobalAlpha(0.5f), clearRect(0, 0, 10, 10));
-    TEST_OVERDRAW_2(1, setFillStyle(m_alphaGradient), clearRect(0, 0, 10, 10));
+    TEST_OVERDRAW_2(1, setFillStyle(alphaGradient()), clearRect(0, 0, 10, 10));
     TEST_OVERDRAW_2(0, translate(1, 1), clearRect(0, 0, 10, 10));
     TEST_OVERDRAW_2(1, translate(1, 1), clearRect(-1, -1, 10, 10));
     TEST_OVERDRAW_2(1, setGlobalCompositeOperation(String("destination-in")), clearRect(0, 0, 10, 10)); // composite op ignored
     TEST_OVERDRAW_3(0, rect(0, 0, 5, 5), clip(), clearRect(0, 0, 10, 10));
 }
 
 TEST_F(CanvasRenderingContext2DTest, detectOverdrawWithDrawImage)
 {
     createContext(NonOpaque);
     NonThrowableExceptionState exceptionState;
@@ skipping 11 matching lines @@
     TEST_OVERDRAW_1(0, drawImage(&m_opaqueBitmap, 0, 0, 10, 10, 1, 0, 10, 10, exceptionState));
     EXPECT_FALSE(exceptionState.hadException());
     TEST_OVERDRAW_1(0, drawImage(&m_opaqueBitmap, 0, 0, 10, 10, 0, 0, 9, 9, exceptionState));
     EXPECT_FALSE(exceptionState.hadException());
     TEST_OVERDRAW_1(1, drawImage(&m_opaqueBitmap, 0, 0, 10, 10, 0, 0, 11, 11, exceptionState));
     EXPECT_FALSE(exceptionState.hadException());
     TEST_OVERDRAW_2(1, translate(-1, 0), drawImage(&m_opaqueBitmap, 0, 0, 10, 10, 1, 0, 10, 10, exceptionState));
     EXPECT_FALSE(exceptionState.hadException());
     TEST_OVERDRAW_2(0, translate(-1, 0), drawImage(&m_opaqueBitmap, 0, 0, 10, 10, 0, 0, 10, 10, exceptionState));
     EXPECT_FALSE(exceptionState.hadException());
-    TEST_OVERDRAW_2(0, setFillStyle(m_opaqueGradient), drawImage(&m_alphaBitmap, 0, 0, 10, 10, 0, 0, 10, 10, exceptionState)); // fillStyle ignored by drawImage
+    TEST_OVERDRAW_2(0, setFillStyle(opaqueGradient()), drawImage(&m_alphaBitmap, 0, 0, 10, 10, 0, 0, 10, 10, exceptionState)); // fillStyle ignored by drawImage
     EXPECT_FALSE(exceptionState.hadException());
-    TEST_OVERDRAW_2(1, setFillStyle(m_alphaGradient), drawImage(&m_opaqueBitmap, 0, 0, 10, 10, 0, 0, 10, 10, exceptionState)); // fillStyle ignored by drawImage
+    TEST_OVERDRAW_2(1, setFillStyle(alphaGradient()), drawImage(&m_opaqueBitmap, 0, 0, 10, 10, 0, 0, 10, 10, exceptionState)); // fillStyle ignored by drawImage
     EXPECT_FALSE(exceptionState.hadException());
     TEST_OVERDRAW_2(1, setGlobalCompositeOperation(String("copy")), drawImage(&m_opaqueBitmap, 0, 0, 10, 10, 1, 0, 10, 10, exceptionState));
     EXPECT_FALSE(exceptionState.hadException());
     TEST_OVERDRAW_3(0, rect(0, 0, 5, 5), clip(), drawImage(&m_opaqueBitmap, 0, 0, 10, 10, 0, 0, 10, 10, exceptionState));
     EXPECT_FALSE(exceptionState.hadException());
 }
 
 TEST_F(CanvasRenderingContext2DTest, detectOverdrawWithPutImageData)
 {
     createContext(NonOpaque);
@@ skipping 271 matching lines @@
     // The canvasChanged notification must be immediate, and not deferred until paint time
     // because offscreen canvases, which are not painted, also need to emit notifications.
     EXPECT_CALL(*observer, canvasChanged(&canvasElement(), FloatRect(0, 0, 1, 1))).Times(1);
     context2d()->fillRect(0, 0, 1, 1);
     Mock::VerifyAndClearExpectations(observer.get());
 
     canvasElement().removeObserver(observer.get());
 }
 
 } // namespace blink