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

gin/interceptor_unittest.cc

 // 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 "base/logging.h"
 #include "gin/arguments.h"
 #include "gin/handle.h"
 #include "gin/interceptor.h"
 #include "gin/object_template_builder.h"
 #include "gin/per_isolate_data.h"
@@ skipping 15 matching lines @@
   static gin::Handle<MyInterceptor> Create(v8::Isolate* isolate) {
     return CreateHandle(isolate, new MyInterceptor(isolate));
   }
 
   int value() const { return value_; }
   void set_value(int value) { value_ = value; }
 
   // gin::NamedPropertyInterceptor
   virtual v8::Local<v8::Value> GetNamedProperty(v8::Isolate* isolate,
                                                 const std::string& property)
-      OVERRIDE {
+      override {
     if (property == "value") {
       return ConvertToV8(isolate, value_);
     } else if (property == "func") {
       return GetFunctionTemplate(isolate, "func")->GetFunction();
     } else {
       return v8::Local<v8::Value>();
     }
   }
   virtual bool SetNamedProperty(v8::Isolate* isolate,
                                 const std::string& property,
-                                v8::Local<v8::Value> value) OVERRIDE {
+                                v8::Local<v8::Value> value) override {
     if (property == "value") {
       ConvertFromV8(isolate, value, &value_);
       return true;
     }
     return false;
   }
   virtual std::vector<std::string> EnumerateNamedProperties(
-      v8::Isolate* isolate) OVERRIDE {
+      v8::Isolate* isolate) override {
     std::vector<std::string> result;
     result.push_back("func");
     result.push_back("value");
     return result;
   }
 
   // gin::IndexedPropertyInterceptor
   virtual v8::Local<v8::Value> GetIndexedProperty(v8::Isolate* isolate,
-                                                  uint32_t index) OVERRIDE {
+                                                  uint32_t index) override {
     if (index == 0)
       return ConvertToV8(isolate, value_);
     return v8::Local<v8::Value>();
   }
   virtual bool SetIndexedProperty(v8::Isolate* isolate,
                                   uint32_t index,
-                                  v8::Local<v8::Value> value) OVERRIDE {
+                                  v8::Local<v8::Value> value) override {
     if (index == 0) {
       ConvertFromV8(isolate, value, &value_);
       return true;
     }
     // Don't allow bypassing the interceptor.
     return true;
   }
   virtual std::vector<uint32_t> EnumerateIndexedProperties(v8::Isolate* isolate)
-      OVERRIDE {
+      override {
     std::vector<uint32_t> result;
     result.push_back(0);
     return result;
   }
 
  private:
   explicit MyInterceptor(v8::Isolate* isolate)
       : NamedPropertyInterceptor(isolate, this),
         IndexedPropertyInterceptor(isolate, this),
         value_(0),
         template_cache_(isolate) {}
   virtual ~MyInterceptor() {}
 
   // gin::Wrappable
   virtual ObjectTemplateBuilder GetObjectTemplateBuilder(v8::Isolate* isolate)
-      OVERRIDE {
+      override {
     return Wrappable<MyInterceptor>::GetObjectTemplateBuilder(isolate)
         .AddNamedPropertyInterceptor()
         .AddIndexedPropertyInterceptor();
   }
 
   int Call(int value) {
     int tmp = value_;
     value_ = value;
     return tmp;
   }
@@ skipping 80 matching lines @@
 
 TEST_F(InterceptorTest, BypassInterceptorForbidden) {
   RunInterceptorTest(
       "(function (obj) {"
       "   obj.value = 191 /* make test happy */;"
       "   obj[1] = 23;"
       "   if (obj[1] === 23) throw 'FAIL'; })");
 }
 
 }  // namespace gin