Make blink::TimerBase own the WebTaskRunner for timer task

third_party/WebKit/Source/core/layout/ImageQualityControllerTest.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 "core/layout/ImageQualityController.h"
 
 #include "core/layout/LayoutImage.h"
 #include "core/layout/LayoutTestHelper.h"
 #include "platform/graphics/GraphicsContext.h"
 #include "platform/graphics/paint/PaintController.h"
@@ skipping 98 matching lines @@
 
     RefPtr<TestImageLowQuality> testImage = adoptRef(new TestImageLowQuality);
     EXPECT_EQ(InterpolationMedium, controller()->chooseInterpolationQuality(*img, testImage.get(), testImage.get(), LayoutSize(1, 1)));
 }
 
 // TODO(alexclarke): Remove this when possible.
 class MockTimer : public TaskRunnerTimer<ImageQualityController> {
 public:
     using TimerFiredFunction = typename TaskRunnerTimer<ImageQualityController>::TimerFiredFunction;
 
-    MockTimer(ImageQualityController* o, TimerFiredFunction f)
-        : TaskRunnerTimer(&m_taskRunner, o, f)
+    static std::unique_ptr<MockTimer> create(ImageQualityController* o, TimerFiredFunction f)
     {
+        auto taskRunner = WTF::wrapUnique(new scheduler::FakeWebTaskRunner);
+        return WTF::wrapUnique(new MockTimer(std::move(taskRunner), o, f));
     }
 
     void fire()
     {
         fired();
         stop();
     }
 
     void setTime(double newTime)
     {
-        m_taskRunner.setTime(newTime);
+        m_taskRunner->setTime(newTime);
     }
 
 private:
-    scheduler::FakeWebTaskRunner m_taskRunner;
+    MockTimer(std::unique_ptr<scheduler::FakeWebTaskRunner> taskRunner, ImageQualityController* o, TimerFiredFunction f)
+        : TaskRunnerTimer(taskRunner.get(), o, f)
+        , m_taskRunner(std::move(taskRunner))
+    {
+    }
+
+    std::unique_ptr<scheduler::FakeWebTaskRunner> m_taskRunner;
+
+    DISALLOW_COPY_AND_ASSIGN(MockTimer);
 };
 
 TEST_F(ImageQualityControllerTest, LowQualityFilterForResizingImage)
 {
-    MockTimer* mockTimer = new MockTimer(controller(), &ImageQualityController::highQualityRepaintTimerFired);
+    MockTimer* mockTimer = MockTimer::create(controller(), &ImageQualityController::highQualityRepaintTimerFired).release();
     controller()->setTimer(wrapUnique(mockTimer));
     setBodyInnerHTML("<img src='myimage'></img>");
     LayoutImage* img = toLayoutImage(document().body()->firstChild()->layoutObject());
 
     RefPtr<TestImageLowQuality> testImage = adoptRef(new TestImageLowQuality);
     std::unique_ptr<PaintController> paintController = PaintController::create();
     GraphicsContext context(*paintController);
 
     // Paint once. This will kick off a timer to see if we resize it during that timer's execution.
     EXPECT_EQ(InterpolationMedium, controller()->chooseInterpolationQuality(*img, testImage.get(), testImage.get(), LayoutSize(2, 2)));
 
     // Go into low-quality mode now that the size changed.
     EXPECT_EQ(InterpolationLow, controller()->chooseInterpolationQuality(*img, testImage.get(), testImage.get(), LayoutSize(3, 3)));
 
     // Stay in low-quality mode since the size changed again.
     EXPECT_EQ(InterpolationLow, controller()->chooseInterpolationQuality(*img, testImage.get(), testImage.get(), LayoutSize(4, 4)));
 
     mockTimer->fire();
     // The timer fired before painting at another size, so this doesn't count as animation. Therefore not painting at low quality.
     EXPECT_EQ(InterpolationMedium, controller()->chooseInterpolationQuality(*img, testImage.get(), testImage.get(), LayoutSize(4, 4)));
 }
 
 TEST_F(ImageQualityControllerTest, MediumQualityFilterForNotAnimatedWhileAnotherAnimates)
 {
-    MockTimer* mockTimer = new MockTimer(controller(), &ImageQualityController::highQualityRepaintTimerFired);
+    MockTimer* mockTimer = MockTimer::create(controller(), &ImageQualityController::highQualityRepaintTimerFired).release();
     controller()->setTimer(wrapUnique(mockTimer));
     setBodyInnerHTML("<img id='myAnimatingImage' src='myimage'></img> <img id='myNonAnimatingImage' src='myimage2'></img>");
     LayoutImage* animatingImage = toLayoutImage(document().getElementById("myAnimatingImage")->layoutObject());
     LayoutImage* nonAnimatingImage = toLayoutImage(document().getElementById("myNonAnimatingImage")->layoutObject());
 
     RefPtr<TestImageLowQuality> testImage = adoptRef(new TestImageLowQuality);
     std::unique_ptr<PaintController> paintController = PaintController::create();
     GraphicsContext context(*paintController);
 
     // Paint once. This will kick off a timer to see if we resize it during that timer's execution.
     EXPECT_EQ(InterpolationMedium, controller()->chooseInterpolationQuality(*animatingImage, testImage.get(), testImage.get(), LayoutSize(2, 2)));
 
     // Go into low-quality mode now that the size changed.
     EXPECT_EQ(InterpolationLow, controller()->chooseInterpolationQuality(*animatingImage, testImage.get(), testImage.get(), LayoutSize(3, 3)));
 
     // The non-animating image receives a medium-quality filter, even though the other one is animating.
     EXPECT_EQ(InterpolationMedium, controller()->chooseInterpolationQuality(*nonAnimatingImage, testImage.get(), testImage.get(), LayoutSize(4, 4)));
 
     // Now the second image has animated, so it also gets painted with a low-quality filter.
     EXPECT_EQ(InterpolationLow, controller()->chooseInterpolationQuality(*nonAnimatingImage, testImage.get(), testImage.get(), LayoutSize(3, 3)));
 
     mockTimer->fire();
     // The timer fired before painting at another size, so this doesn't count as animation. Therefore not painting at low quality for any image.
     EXPECT_EQ(InterpolationMedium, controller()->chooseInterpolationQuality(*animatingImage, testImage.get(), testImage.get(), LayoutSize(4, 4)));
     EXPECT_EQ(InterpolationMedium, controller()->chooseInterpolationQuality(*nonAnimatingImage, testImage.get(), testImage.get(), LayoutSize(4, 4)));
 }
 
 TEST_F(ImageQualityControllerTest, DontKickTheAnimationTimerWhenPaintingAtTheSameSize)
 {
-    MockTimer* mockTimer = new MockTimer(controller(), &ImageQualityController::highQualityRepaintTimerFired);
+    MockTimer* mockTimer = MockTimer::create(controller(), &ImageQualityController::highQualityRepaintTimerFired).release();
     controller()->setTimer(wrapUnique(mockTimer));
     setBodyInnerHTML("<img src='myimage'></img>");
     LayoutImage* img = toLayoutImage(document().body()->firstChild()->layoutObject());
 
     RefPtr<TestImageLowQuality> testImage = adoptRef(new TestImageLowQuality);
 
     // Paint once. This will kick off a timer to see if we resize it during that timer's execution.
     EXPECT_EQ(InterpolationMedium, controller()->chooseInterpolationQuality(*img, testImage.get(), testImage.get(), LayoutSize(2, 2)));
 
     // Go into low-quality mode now that the size changed.
     EXPECT_EQ(InterpolationLow, controller()->chooseInterpolationQuality(*img, testImage.get(), testImage.get(), LayoutSize(3, 3)));
 
     // Stay in low-quality mode since the size changed again.
     EXPECT_EQ(InterpolationLow, controller()->chooseInterpolationQuality(*img, testImage.get(), testImage.get(), LayoutSize(4, 4)));
 
     mockTimer->stop();
     EXPECT_FALSE(mockTimer->isActive());
     // Painted at the same size, so even though timer is still executing, don't go to low quality.
     EXPECT_EQ(InterpolationLow, controller()->chooseInterpolationQuality(*img, testImage.get(), testImage.get(), LayoutSize(4, 4)));
     // Check that the timer was not kicked. It should not have been, since the image was painted at the same size as last time.
     EXPECT_FALSE(mockTimer->isActive());
 }
 
 TEST_F(ImageQualityControllerTest, DontRestartTimerUnlessAdvanced)
 {
-    MockTimer* mockTimer = new MockTimer(controller(), &ImageQualityController::highQualityRepaintTimerFired);
+    MockTimer* mockTimer = MockTimer::create(controller(), &ImageQualityController::highQualityRepaintTimerFired).release();
     controller()->setTimer(wrapUnique(mockTimer));
     setBodyInnerHTML("<img src='myimage'></img>");
     LayoutImage* img = toLayoutImage(document().body()->firstChild()->layoutObject());
 
     RefPtr<TestImageLowQuality> testImage = adoptRef(new TestImageLowQuality);
 
     // Paint once. This will kick off a timer to see if we resize it during that timer's execution.
     mockTimer->setTime(0.1);
     EXPECT_FALSE(controller()->shouldPaintAtLowQuality(*img, testImage.get(), testImage.get(), LayoutSize(2, 2), 0.1));
     EXPECT_EQ(ImageQualityController::cLowQualityTimeThreshold, mockTimer->nextFireInterval());
 
     // Go into low-quality mode now that the size changed.
     double nextTime = 0.1 + ImageQualityController::cTimerRestartThreshold / 2.0;
     mockTimer->setTime(nextTime);
     EXPECT_EQ(true, controller()->shouldPaintAtLowQuality(*img, testImage.get(), testImage.get(), LayoutSize(3, 3), nextTime));
     // The fire interval has decreased, because we have not restarted the timer.
     EXPECT_EQ(ImageQualityController::cLowQualityTimeThreshold - ImageQualityController::cTimerRestartThreshold / 2.0, mockTimer->nextFireInterval());
 
     // This animation is far enough in the future to make the timer restart, since it is half over.
     nextTime = 0.1 + ImageQualityController::cTimerRestartThreshold + 0.01;
     EXPECT_EQ(true, controller()->shouldPaintAtLowQuality(*img, testImage.get(), testImage.get(), LayoutSize(4, 4), nextTime));
     // Now the timer has restarted, leading to a larger fire interval.
     EXPECT_EQ(ImageQualityController::cLowQualityTimeThreshold, mockTimer->nextFireInterval());
 }
 
 #endif
 
 } // namespace blink