Replace FINAL and OVERRIDE with their C++11 counterparts in Source/bindings

Source/bindings/core/v8/ScriptPromisePropertyTest.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 "bindings/core/v8/ScriptPromiseProperty.h"
 
 #include "bindings/core/v8/DOMWrapperWorld.h"
 #include "bindings/core/v8/ScriptFunction.h"
 #include "bindings/core/v8/ScriptPromise.h"
@@ skipping 25 matching lines @@
         NotReached* self = new NotReached(scriptState);
         return self->bindToV8Function();
     }
 
 private:
     explicit NotReached(ScriptState* scriptState)
         : ScriptFunction(scriptState)
     {
     }
 
-    virtual ScriptValue call(ScriptValue) OVERRIDE;
+    virtual ScriptValue call(ScriptValue) override;
 };
 
 ScriptValue NotReached::call(ScriptValue)
 {
     EXPECT_TRUE(false) << "'Unreachable' code was reached";
     return ScriptValue();
 }
 
 class StubFunction : public ScriptFunction {
 public:
     static v8::Handle<v8::Function> createFunction(ScriptState* scriptState, ScriptValue& value, size_t& callCount)
     {
         StubFunction* self = new StubFunction(scriptState, value, callCount);
         return self->bindToV8Function();
     }
 
 private:
     StubFunction(ScriptState* scriptState, ScriptValue& value, size_t& callCount)
         : ScriptFunction(scriptState)
         , m_value(value)
         , m_callCount(callCount)
     {
     }
 
-    virtual ScriptValue call(ScriptValue arg) OVERRIDE
+    virtual ScriptValue call(ScriptValue arg) override
     {
         m_value = arg;
         m_callCount++;
         return ScriptValue();
     }
 
     ScriptValue& m_value;
     size_t& m_callCount;
 };
 
 class GarbageCollectedHolder : public GarbageCollectedScriptWrappable {
 public:
     typedef ScriptPromiseProperty<Member<GarbageCollectedScriptWrappable>, Member<GarbageCollectedScriptWrappable>, Member<GarbageCollectedScriptWrappable> > Property;
     GarbageCollectedHolder(ExecutionContext* executionContext)
         : GarbageCollectedScriptWrappable("holder")
         , m_property(new Property(executionContext, toGarbageCollectedScriptWrappable(), Property::Ready)) { }
 
     Property* property() { return m_property; }
     GarbageCollectedScriptWrappable* toGarbageCollectedScriptWrappable() { return this; }
 
-    virtual void trace(Visitor *visitor) OVERRIDE
+    virtual void trace(Visitor *visitor) override
     {
         GarbageCollectedScriptWrappable::trace(visitor);
         visitor->trace(m_property);
     }
 
 private:
     Member<Property> m_property;
 };
 
 class RefCountedHolder : public RefCountedScriptWrappable {
@@ skipping 76 matching lines @@
 
     ScriptPromisePropertyGarbageCollectedTest()
         : m_holder(new GarbageCollectedHolder(&document()))
     {
     }
 
     GarbageCollectedHolder* holder() { return m_holder; }
     Property* property() { return m_holder->property(); }
     ScriptPromise promise(DOMWrapperWorld& world) { return property()->promise(world); }
 
-    virtual void destroyContext() OVERRIDE
+    virtual void destroyContext() override
     {
         m_holder = nullptr;
         ScriptPromisePropertyTestBase::destroyContext();
     }
 
 private:
     Persistent<GarbageCollectedHolder> m_holder;
 };
 
 TEST_F(ScriptPromisePropertyGarbageCollectedTest, Promise_IsStableObjectInMainWorld)
@@ skipping 345 matching lines @@
 {
     test(String("hello"), "hello", __FILE__, __LINE__);
 }
 
 TEST_F(ScriptPromisePropertyNonScriptWrappableResolutionTargetTest, ResolveWithInteger)
 {
     test<int>(-1, "-1", __FILE__, __LINE__);
 }
 
 } // namespace