Replacing the OVERRIDE with override and FINAL with final in /src/gin

gin/wrappable_unittest.cc

 // Copyright 2013 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 "base/logging.h"
 #include "gin/arguments.h"
 #include "gin/handle.h"
 #include "gin/object_template_builder.h"
 #include "gin/per_isolate_data.h"
 #include "gin/public/isolate_holder.h"
@@ skipping 23 matching lines @@
   static gin::Handle<MyObject> Create(v8::Isolate* isolate) {
     return CreateHandle(isolate, new MyObject());
   }
 
   int value() const { return value_; }
   void set_value(int value) { value_ = value; }
 
  protected:
   MyObject() : value_(0) {}
   virtual ObjectTemplateBuilder GetObjectTemplateBuilder(
-      v8::Isolate* isolate) OVERRIDE;
+      v8::Isolate* isolate) override;
   virtual ~MyObject() {}
 
  private:
   int value_;
 };
 
 class MyObjectSubclass : public MyObject {
  public:
   static gin::Handle<MyObjectSubclass> Create(v8::Isolate* isolate) {
     return CreateHandle(isolate, new MyObjectSubclass());
   }
 
   void SayHello(const std::string& name) {
     result = std::string("Hello, ") + name;
   }
 
   std::string result;
 
  private:
   virtual ObjectTemplateBuilder GetObjectTemplateBuilder(
-      v8::Isolate* isolate) OVERRIDE {
+      v8::Isolate* isolate) override {
     return MyObject::GetObjectTemplateBuilder(isolate)
         .SetMethod("sayHello", &MyObjectSubclass::SayHello);
   }
 
   MyObjectSubclass() {
   }
 
   virtual ~MyObjectSubclass() {
   }
 };
 
 class MyCallableObject : public Wrappable<MyCallableObject> {
  public:
   static WrapperInfo kWrapperInfo;
 
   static gin::Handle<MyCallableObject> Create(v8::Isolate* isolate) {
     return CreateHandle(isolate, new MyCallableObject());
   }
 
   int result() { return result_; }
 
  private:
   virtual ObjectTemplateBuilder GetObjectTemplateBuilder(
-      v8::Isolate* isolate) OVERRIDE {
+      v8::Isolate* isolate) override {
     return Wrappable<MyCallableObject>::GetObjectTemplateBuilder(isolate)
         .SetCallAsFunctionHandler(&MyCallableObject::Call);
   }
 
   MyCallableObject() : result_(0) {
   }
 
   virtual ~MyCallableObject() {
   }
 
@@ skipping 164 matching lines @@
   v8::Handle<v8::Function> func;
   EXPECT_TRUE(ConvertFromV8(isolate, val, &func));
   v8::Handle<v8::Value> argv[] = {
     ConvertToV8(isolate, object.get())
   };
   func->Call(v8::Undefined(isolate), 1, argv);
   EXPECT_TRUE(try_catch.HasCaught());
 }
 
 }  // namespace gin