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

third_party/WebKit/Source/platform/TimerTest.cpp

 // Copyright 2015 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/Timer.h"
 
-#include "platform/testing/TestingPlatformSupport.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebScheduler.h"
 #include "public/platform/WebThread.h"
 #include "public/platform/WebViewScheduler.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include <queue>
 
 using testing::ElementsAre;
 
@@ skipping 211 matching lines @@
 
     virtual void exitRunLoop()
     {
         ASSERT_NOT_REACHED();
     }
 
 private:
     OwnPtr<MockWebScheduler> m_webScheduler;
 };
 
-class TimerTestPlatform : public TestingPlatformSupport {
+class TimerTestPlatform : public Platform {
 public:
     TimerTestPlatform()
         : m_webThread(adoptPtr(new FakeWebThread())) { }
     ~TimerTestPlatform() override { }
 
     WebThread* currentThread() override
     {
         return m_webThread.get();
     }
 
+    void cryptographicallyRandomValues(unsigned char*, size_t) override
+    {
+        ASSERT_NOT_REACHED();
+    }
+
+    const unsigned char* getTraceCategoryEnabledFlag(const char* categoryName) override
+    {
+        static const unsigned char enabled[] = {0};
+        return enabled;
+    }
+
     void runUntilIdle()
     {
         mockScheduler()->runUntilIdle();
     }
 
     void runPendingTasks()
     {
         mockScheduler()->runPendingTasks();
     }
 
@@ skipping 18 matching lines @@
         return static_cast<MockWebScheduler*>(m_webThread->scheduler());
     }
 
     OwnPtr<FakeWebThread> m_webThread;
 };
 
 class TimerTest : public testing::Test {
 public:
     void SetUp() override
     {
+        m_platform = adoptPtr(new TimerTestPlatform());
+        m_oldPlatform = Platform::current();
+        Platform::initialize(m_platform.get());
         WTF::setMonotonicallyIncreasingTimeFunction(currentTime);
 
         m_runTimes.clear();
         gCurrentTimeSecs = 10.0;
         m_startTime = gCurrentTimeSecs;
     }
 
+    void TearDown() override
+    {
+        Platform::initialize(m_oldPlatform);
+    }
+
     void countingTask(Timer<TimerTest>*)
     {
         m_runTimes.append(monotonicallyIncreasingTime());
     }
 
     void recordNextFireTimeTask(Timer<TimerTest>* timer)
     {
         m_nextFireTimes.append(monotonicallyIncreasingTime() + timer->nextFireInterval());
     }
 
     void advanceTimeBy(double timeSecs)
     {
         gCurrentTimeSecs += timeSecs;
     }
 
     void runUntilIdle()
     {
-        m_platform.runUntilIdle();
+        m_platform->runUntilIdle();
     }
 
     void runPendingTasks()
     {
-        m_platform.runPendingTasks();
+        m_platform->runPendingTasks();
     }
 
     void runUntilIdleOrDeadlinePassed(double deadline)
     {
-        m_platform.runUntilIdleOrDeadlinePassed(deadline);
+        m_platform->runUntilIdleOrDeadlinePassed(deadline);
     }
 
     bool hasOneTimerTask() const
     {
-        return m_platform.hasOneTimerTask();
+        return m_platform->hasOneTimerTask();
     }
 
     double nextTimerTaskDelaySecs() const
     {
-        return m_platform.nextTimerTaskDelaySecs();
+        return m_platform->nextTimerTaskDelaySecs();
     }
 
 protected:
     double m_startTime;
     WTF::Vector<double> m_runTimes;
     WTF::Vector<double> m_nextFireTimes;
 
 private:
-    TimerTestPlatform m_platform;
+    OwnPtr<TimerTestPlatform> m_platform;
+    Platform* m_oldPlatform;
 };
 
 TEST_F(TimerTest, StartOneShot_Zero)
 {
     Timer<TimerTest> timer(this, &TimerTest::countingTask);
     timer.startOneShot(0, BLINK_FROM_HERE);
 
     ASSERT(hasOneTimerTask());
     EXPECT_FLOAT_EQ(0.0, nextTimerTaskDelaySecs());
 
@@ skipping 456 matching lines @@
         m_startTime + 6.0,
         m_startTime + 8.0,
         m_startTime + 10.0,
         m_startTime + 14.0,
         m_startTime + 18.0,
         m_startTime + 28.0));
 }
 
 } // namespace
 } // namespace blink