Standardize usage of virtual/override/final in chrome/

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 255 matching lines @@
       }
       case kElementNotExistsQueryOnce: {
         if (only_one_)
           result_.reset(base::Value::CreateNullValue());
         else
           result_.reset(new base::ListValue());
         break;
       }
     }
   }
-  virtual ~FindElementWebView() {}
+  ~FindElementWebView() override {}
 
   void Verify(const std::string& expected_frame,
               const base::ListValue* expected_args,
               const base::Value* actrual_result) {
     EXPECT_EQ(expected_frame, frame_);
     std::string function;
     if (only_one_)
       function = webdriver::atoms::asString(webdriver::atoms::FIND_ELEMENT);
     else
       function = webdriver::atoms::asString(webdriver::atoms::FIND_ELEMENTS);
     EXPECT_EQ(function, function_);
     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 {
+  Status CallFunction(const std::string& frame,
+                      const std::string& function,
+                      const base::ListValue& args,
+                      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 185 matching lines @@
   ASSERT_EQ(kNoSuchElement,
             ExecuteFindElement(1, &session, &web_view, params, &result).code());
 }
 
 namespace {
 
 class ErrorCallFunctionWebView : public StubWebView {
  public:
   explicit ErrorCallFunctionWebView(StatusCode code)
       : StubWebView("1"), code_(code) {}
-  virtual ~ErrorCallFunctionWebView() {}
+  ~ErrorCallFunctionWebView() override {}
 
   // Overridden from WebView:
-  virtual Status CallFunction(const std::string& frame,
-                              const std::string& function,
-                              const base::ListValue& args,
-                              scoped_ptr<base::Value>* result) override {
+  Status CallFunction(const std::string& frame,
+                      const std::string& function,
+                      const base::ListValue& args,
+                      scoped_ptr<base::Value>* result) override {
     return Status(code_);
   }
 
  private:
   StatusCode code_;
 };
 
 }  // namespace
 
 TEST(CommandsTest, ErrorFindElement) {
@@ skipping 25 matching lines @@
       kStaleElementReference,
       ExecuteFindChildElements(
           1, &session, &web_view, element_id, params, &result).code());
 }
 
 namespace {
 
 class MockCommandListener : public CommandListener {
  public:
   MockCommandListener() : called_(false) {}
-  virtual ~MockCommandListener() {}
+  ~MockCommandListener() override {}
 
-  virtual Status BeforeCommand(const std::string& command_name) override {
+  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 84 matching lines @@
   run_loop_testlistener.Run();
 
   listener->VerifyCalled();
 }
 
 namespace {
 
 class FailingCommandListener : public CommandListener {
  public:
   FailingCommandListener() {}
-  virtual ~FailingCommandListener() {}
+  ~FailingCommandListener() override {}
 
-  virtual Status BeforeCommand(const std::string& command_name) override {
+  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));
 }