Standardize usage of virtual/override/final in 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 22 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;
-  virtual ~MyObject() {}
+  ObjectTemplateBuilder GetObjectTemplateBuilder(v8::Isolate* isolate) override;
+  ~MyObject() override {}
 
  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(
+  ObjectTemplateBuilder GetObjectTemplateBuilder(
       v8::Isolate* isolate) override {
     return MyObject::GetObjectTemplateBuilder(isolate)
         .SetMethod("sayHello", &MyObjectSubclass::SayHello);
   }
 
   MyObjectSubclass() {
   }
 
-  virtual ~MyObjectSubclass() {
-  }
+  ~MyObjectSubclass() override {}
 };
 
 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(
+  ObjectTemplateBuilder GetObjectTemplateBuilder(
       v8::Isolate* isolate) override {
     return Wrappable<MyCallableObject>::GetObjectTemplateBuilder(isolate)
         .SetCallAsFunctionHandler(&MyCallableObject::Call);
   }
 
   MyCallableObject() : result_(0) {
   }
 
-  virtual ~MyCallableObject() {
-  }
+  ~MyCallableObject() override {}
 
   void Call(int val, const gin::Arguments& arguments) {
     if (arguments.IsConstructCall())
       arguments.ThrowTypeError("Cannot be called as constructor.");
     else
       result_ = val;
   }
 
   int result_;
 };
@@ skipping 155 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