Optimize posting of WTF::Closure and improve scheduler test mocks

third_party/WebKit/Source/platform/graphics/RecordingImageBufferSurfaceTest.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 "platform/graphics/RecordingImageBufferSurface.h"
 
 #include "platform/graphics/GraphicsContext.h"
 #include "platform/graphics/ImageBuffer.h"
 #include "platform/graphics/ImageBufferClient.h"
 #include "platform/graphics/UnacceleratedImageBufferSurface.h"
@@ skipping 213 matching lines @@
         EXPECT_EQ(expectedSurfaceCreationCount, m_surfaceFactory->createSurfaceCount());
     }
 
 private:
     MockSurfaceFactory* m_surfaceFactory;
     RecordingImageBufferSurface* m_testSurface;
     std::unique_ptr<FakeImageBufferClient> m_fakeImageBufferClient;
     std::unique_ptr<ImageBuffer> m_imageBuffer;
 };
 
-namespace {
-
-// The following test helper class installs a mock platform that provides a mock WebThread
-// for the current thread. The Mock thread is capable of queuing a single non-delayed task
-// and registering a single task observer. The run loop exits immediately after running
-// the single task.
-
-class CurrentThreadPlatformMock : public TestingPlatformSupport {
-public:
-    CurrentThreadPlatformMock() { }
-    WebThread* currentThread() override { return &m_currentThread; }
-
-    void enterRunLoop() { m_currentThread.enterRunLoop(); }
-private:
-    class MockWebTaskRunner : public WebTaskRunner {
-    public:
-        MockWebTaskRunner() : m_task(0) { }
-        ~MockWebTaskRunner() override { }
-
-        void postTask(const WebTraceLocation&, Task* task) override
-        {
-            EXPECT_EQ((Task*)0, m_task);
-            m_task = task;
-        }
-
-        void postDelayedTask(const WebTraceLocation&, Task*, double delayMs) override { NOTREACHED(); };
-
-        bool runsTasksOnCurrentThread() override
-        {
-            NOTREACHED();
-            return true;
-        }
-
-        std::unique_ptr<WebTaskRunner> clone() override
-        {
-            NOTREACHED();
-            return nullptr;
-        }
-
-        double virtualTimeSeconds() const override
-        {
-            NOTREACHED();
-            return 0.0;
-        }
-
-        double monotonicallyIncreasingVirtualTimeSeconds() const override
-        {
-            NOTREACHED();
-            return 0.0;
-        }
-
-        base::SingleThreadTaskRunner* taskRunner() override
-        {
-            NOTREACHED();
-            return nullptr;
-        }
-
-        Task* m_task;
-    };
-
-    class CurrentThreadMock : public WebThread {
-    public:
-        CurrentThreadMock() : m_taskObserver(0) { }
-
-        ~CurrentThreadMock() override
-        {
-            EXPECT_EQ((WebTaskRunner::Task*)0, m_taskRunner.m_task);
-        }
-
-        WebTaskRunner* getWebTaskRunner() override
-        {
-            return &m_taskRunner;
-        }
-
-        bool isCurrentThread() const override { return true; }
-
-        PlatformThreadId threadId() const override
-        {
-            NOTREACHED();
-            return 0;
-        }
-
-        void addTaskObserver(TaskObserver* taskObserver) override
-        {
-            EXPECT_EQ(nullptr, m_taskObserver);
-            m_taskObserver = taskObserver;
-        }
-
-        void removeTaskObserver(TaskObserver* taskObserver) override
-        {
-            EXPECT_EQ(m_taskObserver, taskObserver);
-            m_taskObserver = 0;
-        }
-
-        WebScheduler* scheduler() const override
-        {
-            NOTREACHED();
-            return nullptr;
-        }
-
-        void enterRunLoop()
-        {
-            if (m_taskObserver)
-                m_taskObserver->willProcessTask();
-            if (m_taskRunner.m_task) {
-                m_taskRunner.m_task->run();
-                delete m_taskRunner.m_task;
-                m_taskRunner.m_task = 0;
-            }
-            if (m_taskObserver)
-                m_taskObserver->didProcessTask();
-        }
-
-    private:
-        MockWebTaskRunner m_taskRunner;
-        TaskObserver* m_taskObserver;
-    };
-
-    CurrentThreadMock m_currentThread;
-};
-
-} // anonymous namespace
-
 #define CALL_TEST_TASK_WRAPPER(TEST_METHOD)                                                               \
     {                                                                                                     \
-        CurrentThreadPlatformMock ctpm;                                                                   \
+        TestingPlatformSupportWithMockScheduler testingPlatform;                                                                   \
         Platform::current()->currentThread()->getWebTaskRunner()->postTask(BLINK_FROM_HERE, WTF::bind(&RecordingImageBufferSurfaceTest::TEST_METHOD, WTF::unretained(this))); \
-        ctpm.enterRunLoop();                                      \
+        testingPlatform.runUntilIdle();                                      \
     }
 
 TEST_F(RecordingImageBufferSurfaceTest, testEmptyPicture)
 {
     testEmptyPicture();
 }
 
 TEST_F(RecordingImageBufferSurfaceTest, testNoFallbackWithClear)
 {
     testNoFallbackWithClear();
@@ skipping 25 matching lines @@
     expectDisplayListEnabled(true);
 }
 
 TEST_F(RecordingImageBufferSurfaceTest, testClearRect)
 {
     CALL_TEST_TASK_WRAPPER(testClearRect);
     expectDisplayListEnabled(true);
 }
 
 } // namespace blink