Replacing the OVERRIDE with override in third_party/WebKit/Source/platform

Source/platform/scheduler/SchedulerTest.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/scheduler/Scheduler.h"
 
 #include "platform/TestingPlatformSupport.h"
 #include "platform/TraceLocation.h"
 #include "public/platform/Platform.h"
@@ skipping 16 matching lines @@
     }
 
     using Scheduler::Normal;
     using Scheduler::CompositorPriority;
     using Scheduler::enterSchedulerPolicy;
 };
 
 class TestMainThread : public blink::WebThread {
 public:
     // blink::WebThread implementation.
-    virtual void postTask(Task* task) OVERRIDE
+    virtual void postTask(Task* task) override
     {
         m_pendingTasks.append(adoptPtr(task));
     }
 
-    virtual void postDelayedTask(Task* task, long long delayMs) OVERRIDE
+    virtual void postDelayedTask(Task* task, long long delayMs) override
     {
         ASSERT_NOT_REACHED();
     }
 
-    virtual bool isCurrentThread() const OVERRIDE
+    virtual bool isCurrentThread() const override
     {
         return true;
     }
 
-    virtual blink::PlatformThreadId threadId() const OVERRIDE
+    virtual blink::PlatformThreadId threadId() const override
     {
         ASSERT_NOT_REACHED();
         return 0;
     }
 
-    virtual void enterRunLoop() OVERRIDE
+    virtual void enterRunLoop() override
     {
         ASSERT_NOT_REACHED();
     }
 
-    virtual void exitRunLoop() OVERRIDE
+    virtual void exitRunLoop() override
     {
         ASSERT_NOT_REACHED();
     }
 
     void runPendingTasks()
     {
         while (!m_pendingTasks.isEmpty())
             m_pendingTasks.takeFirst()->run();
     }
 
@@ skipping 11 matching lines @@
     SchedulerTestingPlatformSupport()
         : TestingPlatformSupport(TestingPlatformSupport::Config())
         , m_sharedTimerFunction(nullptr)
         , m_sharedTimerRunning(false)
         , m_sharedTimerFireInterval(0)
         , m_monotonicallyIncreasingTime(0)
     {
     }
 
     // blink::Platform implementation.
-    virtual blink::WebThread* currentThread() OVERRIDE
+    virtual blink::WebThread* currentThread() override
     {
         return &m_mainThread;
     }
 
-    virtual void setSharedTimerFiredFunction(SharedTimerFunction timerFunction) OVERRIDE
+    virtual void setSharedTimerFiredFunction(SharedTimerFunction timerFunction) override
     {
         m_sharedTimerFunction = timerFunction;
     }
 
-    virtual double monotonicallyIncreasingTime() OVERRIDE
+    virtual double monotonicallyIncreasingTime() override
     {
         return m_monotonicallyIncreasingTime;
     }
 
     virtual void setSharedTimerFireInterval(double)
     {
         m_sharedTimerFireInterval = 0;
         m_sharedTimerRunning = true;
     }
 
@@ skipping 48 matching lines @@
     {
         SchedulerForTest::initializeOnMainThread();
         m_scheduler = static_cast<SchedulerForTest*>(Scheduler::shared());
     }
 
     ~SchedulerTest()
     {
         Scheduler::shutdown();
     }
 
-    virtual void SetUp() OVERRIDE
+    virtual void SetUp() override
     {
         m_scheduler->enterSchedulerPolicy(SchedulerForTest::Normal);
     }
 
-    virtual void TearDown() OVERRIDE
+    virtual void TearDown() override
     {
         // If the Scheduler hasn't been shut down then explicitly flush the tasks.
         if (Scheduler::shared())
             runPendingTasks();
     }
 
     void runPendingTasks()
     {
         m_platformSupport.runPendingTasks();
     }
@@ skipping 340 matching lines @@
     m_platformSupport.setMonotonicTimeForTest(1000.5);
     runPendingTasks();
 
     ASSERT_FALSE(m_scheduler->shouldYieldForHighPriorityWork());
     m_scheduler->postCompositorTask(FROM_HERE, WTF::bind(&dummyTask));
 
     EXPECT_FALSE(m_scheduler->shouldYieldForHighPriorityWork());
 }
 
 } // namespace