Replace FINAL and OVERRIDE with their C++11 counterparts in chrome/test

chrome/test/chromedriver/commands_unittest.cc

 // Copyright (c) 2012 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 <string>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_path.h"
@@ skipping 277 matching lines @@
     ASSERT_TRUE(args_.get());
     EXPECT_TRUE(expected_args->Equals(args_.get()));
     ASSERT_TRUE(actrual_result);
     EXPECT_TRUE(result_->Equals(actrual_result));
   }
 
   // Overridden from WebView:
   virtual Status CallFunction(const std::string& frame,
                               const std::string& function,
                               const base::ListValue& args,
-                              scoped_ptr<base::Value>* result) OVERRIDE {
+                              scoped_ptr<base::Value>* result) override {
     ++current_count_;
     if (scenario_ == kElementExistsTimeout ||
         (scenario_ == kElementExistsQueryTwice && current_count_ == 1)) {
         // Always return empty result when testing timeout.
         if (only_one_)
           result->reset(base::Value::CreateNullValue());
         else
           result->reset(new base::ListValue());
     } else {
       switch (scenario_) {
@@ skipping 191 matching lines @@
 class ErrorCallFunctionWebView : public StubWebView {
  public:
   explicit ErrorCallFunctionWebView(StatusCode code)
       : StubWebView("1"), code_(code) {}
   virtual ~ErrorCallFunctionWebView() {}
 
   // Overridden from WebView:
   virtual Status CallFunction(const std::string& frame,
                               const std::string& function,
                               const base::ListValue& args,
-                              scoped_ptr<base::Value>* result) OVERRIDE {
+                              scoped_ptr<base::Value>* result) override {
     return Status(code_);
   }
 
  private:
   StatusCode code_;
 };
 
 }  // namespace
 
 TEST(CommandsTest, ErrorFindElement) {
@@ skipping 27 matching lines @@
           1, &session, &web_view, element_id, params, &result).code());
 }
 
 namespace {
 
 class MockCommandListener : public CommandListener {
  public:
   MockCommandListener() : called_(false) {}
   virtual ~MockCommandListener() {}
 
-  virtual Status BeforeCommand(const std::string& command_name) OVERRIDE {
+  virtual Status BeforeCommand(const std::string& command_name) override {
     called_ = true;
     EXPECT_STREQ("cmd", command_name.c_str());
     return Status(kOk);
   }
 
   void VerifyCalled() {
     EXPECT_TRUE(called_);
   }
 
   void VerifyNotCalled() {
@@ skipping 86 matching lines @@
   listener->VerifyCalled();
 }
 
 namespace {
 
 class FailingCommandListener : public CommandListener {
  public:
   FailingCommandListener() {}
   virtual ~FailingCommandListener() {}
 
-  virtual Status BeforeCommand(const std::string& command_name) OVERRIDE {
+  virtual Status BeforeCommand(const std::string& command_name) override {
     return Status(kUnknownError);
   }
 };
 
 void AddListenerToSessionIfSessionExists(CommandListener* listener) {
   Session* session = GetThreadLocalSession();
   if (session) {
     session->command_listeners.push_back(listener);
   }
 }
@@ skipping 45 matching lines @@
       false,
       params,
       id,
       base::Bind(&OnFailBecauseErrorNotifyingListeners, &run_loop));
   run_loop.Run();
 
   thread->message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&VerifySessionWasDeleted));
 }