Replace OVERRIDE and FINAL with override and final in content/shell/[a-s]*

content/shell/renderer/test_runner/test_runner.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 "content/shell/renderer/test_runner/test_runner.h"
 
 #include <limits>
 
 #include "base/logging.h"
 #include "content/public/test/layouttest_support.h"
@@ skipping 56 matching lines @@
   v8_str->WriteUtf8(chars.get(), length);
   return WebString::fromUTF8(chars.get());
 }
 
 class HostMethodTask : public WebMethodTask<TestRunner> {
  public:
   typedef void (TestRunner::*CallbackMethodType)();
   HostMethodTask(TestRunner* object, CallbackMethodType callback)
       : WebMethodTask<TestRunner>(object), callback_(callback) {}
 
-  virtual void RunIfValid() OVERRIDE { (object_->*callback_)(); }
+  virtual void RunIfValid() override { (object_->*callback_)(); }
 
  private:
   CallbackMethodType callback_;
 };
 
 }  // namespace
 
 class InvokeCallbackTask : public WebMethodTask<TestRunner> {
  public:
   InvokeCallbackTask(TestRunner* object, v8::Handle<v8::Function> callback)
       : WebMethodTask<TestRunner>(object),
         callback_(blink::mainThreadIsolate(), callback),
         argc_(0) {}
 
-  virtual void RunIfValid() OVERRIDE {
+  virtual void RunIfValid() override {
     v8::Isolate* isolate = blink::mainThreadIsolate();
     v8::HandleScope handle_scope(isolate);
     WebFrame* frame = object_->web_view_->mainFrame();
 
     v8::Handle<v8::Context> context = frame->mainWorldScriptContext();
     if (context.IsEmpty())
       return;
 
     v8::Context::Scope context_scope(context);
 
@@ skipping 32 matching lines @@
   static void Install(base::WeakPtr<TestRunner> controller,
                       WebFrame* frame);
 
  private:
   explicit TestRunnerBindings(
       base::WeakPtr<TestRunner> controller);
   virtual ~TestRunnerBindings();
 
   // gin::Wrappable:
   virtual gin::ObjectTemplateBuilder GetObjectTemplateBuilder(
-      v8::Isolate* isolate) OVERRIDE;
+      v8::Isolate* isolate) override;
 
   void LogToStderr(const std::string& output);
   void NotifyDone();
   void WaitUntilDone();
   void QueueBackNavigation(int how_far_back);
   void QueueForwardNavigation(int how_far_forward);
   void QueueReload();
   void QueueLoadingScript(const std::string& script);
   void QueueNonLoadingScript(const std::string& script);
   void QueueLoad(gin::Arguments* args);
@@ skipping 1288 matching lines @@
 void TestRunnerBindings::NotImplemented(const gin::Arguments& args) {
 }
 
 class TestPageOverlay : public WebPageOverlay {
  public:
   explicit TestPageOverlay(WebView* web_view)
       : web_view_(web_view) {
   }
   virtual ~TestPageOverlay() {}
 
-  virtual void paintPageOverlay(WebCanvas* canvas) OVERRIDE  {
+  virtual void paintPageOverlay(WebCanvas* canvas) override  {
     SkRect rect = SkRect::MakeWH(web_view_->size().width,
                                  web_view_->size().height);
     SkPaint paint;
     paint.setColor(SK_ColorCYAN);
     paint.setStyle(SkPaint::kFill_Style);
     canvas->drawRect(rect, paint);
   }
 
  private:
   WebView* web_view_;
@@ skipping 443 matching lines @@
 
 void TestRunner::ShowDevTools(const std::string& settings,
                               const std::string& frontend_url) {
   delegate_->ShowDevTools(settings, frontend_url);
 }
 
 class WorkItemBackForward : public TestRunner::WorkItem {
  public:
   WorkItemBackForward(int distance) : distance_(distance) {}
 
-  virtual bool Run(WebTestDelegate* delegate, WebView*) OVERRIDE {
+  virtual bool Run(WebTestDelegate* delegate, WebView*) override {
     delegate->GoToOffset(distance_);
     return true; // FIXME: Did it really start a navigation?
   }
 
  private:
   int distance_;
 };
 
 void TestRunner::NotifyDone() {
   if (disable_notify_done_)
@@ skipping 12 matching lines @@
 void TestRunner::QueueBackNavigation(int how_far_back) {
   work_queue_.AddWork(new WorkItemBackForward(-how_far_back));
 }
 
 void TestRunner::QueueForwardNavigation(int how_far_forward) {
   work_queue_.AddWork(new WorkItemBackForward(how_far_forward));
 }
 
 class WorkItemReload : public TestRunner::WorkItem {
  public:
-  virtual bool Run(WebTestDelegate* delegate, WebView*) OVERRIDE {
+  virtual bool Run(WebTestDelegate* delegate, WebView*) override {
     delegate->Reload();
     return true;
   }
 };
 
 void TestRunner::QueueReload() {
   work_queue_.AddWork(new WorkItemReload());
 }
 
 class WorkItemLoadingScript : public TestRunner::WorkItem {
  public:
   WorkItemLoadingScript(const std::string& script)
       : script_(script) {}
 
-  virtual bool Run(WebTestDelegate*, WebView* web_view) OVERRIDE {
+  virtual bool Run(WebTestDelegate*, WebView* web_view) override {
     web_view->mainFrame()->executeScript(
         WebScriptSource(WebString::fromUTF8(script_)));
     return true; // FIXME: Did it really start a navigation?
   }
 
  private:
   std::string script_;
 };
 
 void TestRunner::QueueLoadingScript(const std::string& script) {
   work_queue_.AddWork(new WorkItemLoadingScript(script));
 }
 
 class WorkItemNonLoadingScript : public TestRunner::WorkItem {
  public:
   WorkItemNonLoadingScript(const std::string& script)
       : script_(script) {}
 
-  virtual bool Run(WebTestDelegate*, WebView* web_view) OVERRIDE {
+  virtual bool Run(WebTestDelegate*, WebView* web_view) override {
     web_view->mainFrame()->executeScript(
         WebScriptSource(WebString::fromUTF8(script_)));
     return false;
   }
 
  private:
   std::string script_;
 };
 
 void TestRunner::QueueNonLoadingScript(const std::string& script) {
   work_queue_.AddWork(new WorkItemNonLoadingScript(script));
 }
 
 class WorkItemLoad : public TestRunner::WorkItem {
  public:
   WorkItemLoad(const WebURL& url, const std::string& target)
       : url_(url), target_(target) {}
 
-  virtual bool Run(WebTestDelegate* delegate, WebView*) OVERRIDE {
+  virtual bool Run(WebTestDelegate* delegate, WebView*) override {
     delegate->LoadURLForFrame(url_, target_);
     return true; // FIXME: Did it really start a navigation?
   }
 
  private:
   WebURL url_;
   std::string target_;
 };
 
 void TestRunner::QueueLoad(const std::string& url, const std::string& target) {
   // FIXME: Implement WebURL::resolve() and avoid GURL.
   GURL current_url = web_view_->mainFrame()->document().url();
   GURL full_url = current_url.Resolve(url);
   work_queue_.AddWork(new WorkItemLoad(full_url, target));
 }
 
 class WorkItemLoadHTMLString : public TestRunner::WorkItem  {
  public:
   WorkItemLoadHTMLString(const std::string& html, const WebURL& base_url)
       : html_(html), base_url_(base_url) {}
 
   WorkItemLoadHTMLString(const std::string& html, const WebURL& base_url,
                          const WebURL& unreachable_url)
       : html_(html), base_url_(base_url), unreachable_url_(unreachable_url) {}
 
-  virtual bool Run(WebTestDelegate*, WebView* web_view) OVERRIDE {
+  virtual bool Run(WebTestDelegate*, WebView* web_view) override {
     web_view->mainFrame()->loadHTMLString(
         WebData(html_.data(), html_.length()),
         base_url_, unreachable_url_);
     return true;
   }
 
  private:
   std::string html_;
   WebURL base_url_;
   WebURL unreachable_url_;
@@ skipping 907 matching lines @@
 }
 
 void TestRunner::DidLosePointerLockInternal() {
   bool was_locked = pointer_locked_;
   pointer_locked_ = false;
   if (was_locked)
     web_view_->didLosePointerLock();
 }
 
 }  // namespace content