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

content/shell/renderer/test_runner/mock_web_speech_recognizer.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/mock_web_speech_recognizer.h"
 
 #include "base/logging.h"
 #include "content/shell/renderer/test_runner/web_test_delegate.h"
 #include "third_party/WebKit/public/web/WebSpeechRecognitionResult.h"
 #include "third_party/WebKit/public/web/WebSpeechRecognizerClient.h"
 
 namespace content {
 
 namespace {
 
 // Task class for calling a client function that does not take any parameters.
 typedef void (blink::WebSpeechRecognizerClient::*ClientFunctionPointer)(
     const blink::WebSpeechRecognitionHandle&);
 class ClientCallTask : public MockWebSpeechRecognizer::Task {
  public:
   ClientCallTask(MockWebSpeechRecognizer* mock, ClientFunctionPointer function)
       : MockWebSpeechRecognizer::Task(mock), function_(function) {}
 
   virtual ~ClientCallTask() {}
 
-  virtual void run() OVERRIDE {
+  virtual void run() override {
     (recognizer_->Client()->*function_)(recognizer_->Handle());
   }
 
  private:
   ClientFunctionPointer function_;
 
   DISALLOW_COPY_AND_ASSIGN(ClientCallTask);
 };
 
 // Task for delivering a result event.
 class ResultTask : public MockWebSpeechRecognizer::Task {
  public:
   ResultTask(MockWebSpeechRecognizer* mock,
              const blink::WebString transcript,
              float confidence)
       : MockWebSpeechRecognizer::Task(mock),
         transcript_(transcript),
         confidence_(confidence) {}
 
   virtual ~ResultTask() {}
 
-  virtual void run() OVERRIDE {
+  virtual void run() override {
     blink::WebVector<blink::WebString> transcripts(static_cast<size_t>(1));
     blink::WebVector<float> confidences(static_cast<size_t>(1));
     transcripts[0] = transcript_;
     confidences[0] = confidence_;
     blink::WebVector<blink::WebSpeechRecognitionResult> final_results(
         static_cast<size_t>(1));
     blink::WebVector<blink::WebSpeechRecognitionResult> interim_results;
     final_results[0].assign(transcripts, confidences, true);
 
     recognizer_->Client()->didReceiveResults(
         recognizer_->Handle(), final_results, interim_results);
   }
 
  private:
   blink::WebString transcript_;
   float confidence_;
 
   DISALLOW_COPY_AND_ASSIGN(ResultTask);
 };
 
 // Task for delivering a nomatch event.
 class NoMatchTask : public MockWebSpeechRecognizer::Task {
  public:
   NoMatchTask(MockWebSpeechRecognizer* mock)
       : MockWebSpeechRecognizer::Task(mock) {}
 
   virtual ~NoMatchTask() {}
 
-  virtual void run() OVERRIDE {
+  virtual void run() override {
     recognizer_->Client()->didReceiveNoMatch(
         recognizer_->Handle(), blink::WebSpeechRecognitionResult());
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(NoMatchTask);
 };
 
 // Task for delivering an error event.
 class ErrorTask : public MockWebSpeechRecognizer::Task {
  public:
   ErrorTask(MockWebSpeechRecognizer* mock,
             blink::WebSpeechRecognizerClient::ErrorCode code,
             const blink::WebString& message)
       : MockWebSpeechRecognizer::Task(mock), code_(code), message_(message) {}
 
   virtual ~ErrorTask() {}
 
-  virtual void run() OVERRIDE {
+  virtual void run() override {
     recognizer_->Client()->didReceiveError(
         recognizer_->Handle(), message_, code_);
   }
 
  private:
   blink::WebSpeechRecognizerClient::ErrorCode code_;
   blink::WebString message_;
 
   DISALLOW_COPY_AND_ASSIGN(ErrorTask);
 };
@@ skipping 137 matching lines @@
 
   if (object_->task_queue_.empty()) {
     object_->task_queue_running_ = false;
     return;
   }
 
   object_->delegate_->PostTask(new StepTask(object_));
 }
 
 }  // namespace content