Revert of More regular Platform implementations in unit tests (reland.)

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 "config.h"
 #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"
-#include "platform/testing/TestingPlatformSupport.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebTaskRunner.h"
 #include "public/platform/WebThread.h"
 #include "public/platform/WebTraceLocation.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkPictureRecorder.h"
 #include "wtf/OwnPtr.h"
 #include "wtf/PassOwnPtr.h"
@@ skipping 207 matching lines @@
     OwnPtr<FakeImageBufferClient> m_fakeImageBufferClient;
     OwnPtr<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 AutoInstallCurrentThreadPlatformMock {
+public:
+    AutoInstallCurrentThreadPlatformMock()
+    {
+        m_oldPlatform = Platform::current();
+        Platform::initialize(&m_mockPlatform);
+    }
 
-class CurrentThreadPlatformMock : public TestingPlatformSupport {
-public:
-    CurrentThreadPlatformMock() { }
-    WebThread* currentThread() override { return &m_currentThread; }
+    ~AutoInstallCurrentThreadPlatformMock()
+    {
+        Platform::initialize(m_oldPlatform);
+    }
 
-    void enterRunLoop() { m_currentThread.enterRunLoop(); }
+    void enterRunLoop()
+    {
+        m_mockPlatform.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;
@@ skipping 61 matching lines @@
             }
             if (m_taskObserver)
                 m_taskObserver->didProcessTask();
         }
 
     private:
         MockWebTaskRunner m_taskRunner;
         TaskObserver* m_taskObserver;
     };
 
-    CurrentThreadMock m_currentThread;
+    class CurrentThreadPlatformMock : public Platform {
+    public:
+        CurrentThreadPlatformMock() { }
+        virtual void cryptographicallyRandomValues(unsigned char* buffer, size_t length)
+        {
+            RELEASE_ASSERT_NOT_REACHED();
+        }
+        WebThread* currentThread() override { return &m_currentThread; }
+
+        void enterRunLoop() { m_currentThread.enterRunLoop(); }
+    private:
+        CurrentThreadMock m_currentThread;
+    };
+
+    CurrentThreadPlatformMock m_mockPlatform;
+    Platform* m_oldPlatform;
 };
 
 } // anonymous namespace
 
 #define DEFINE_TEST_TASK_WRAPPER_CLASS(TEST_METHOD)                                               \
 class TestWrapperTask_ ## TEST_METHOD : public WebTaskRunner::Task {                           \
     public:                                                                                       \
         TestWrapperTask_ ## TEST_METHOD(RecordingImageBufferSurfaceTest* test) : m_test(test) { } \
         void run() override { m_test->TEST_METHOD(); }                                    \
     private:                                                                                      \
         RecordingImageBufferSurfaceTest* m_test;                                                  \
 };
 
 #define CALL_TEST_TASK_WRAPPER(TEST_METHOD)                                                               \
     {                                                                                                     \
-        CurrentThreadPlatformMock ctpm;                                                                   \
+        AutoInstallCurrentThreadPlatformMock ctpm;                                                        \
         Platform::current()->currentThread()->taskRunner()->postTask(BLINK_FROM_HERE, new TestWrapperTask_ ## TEST_METHOD(this)); \
         ctpm.enterRunLoop();                                      \
     }
 
 TEST_F(RecordingImageBufferSurfaceTest, testEmptyPicture)
 {
     testEmptyPicture();
 }
 
 TEST_F(RecordingImageBufferSurfaceTest, testNoFallbackWithClear)
@@ skipping 33 matching lines @@
 }
 
 DEFINE_TEST_TASK_WRAPPER_CLASS(testClearRect)
 TEST_F(RecordingImageBufferSurfaceTest, testClearRect)
 {
     CALL_TEST_TASK_WRAPPER(testClearRect);
     expectDisplayListEnabled(true);
 }
 
 } // namespace blink