Standardize usage of virtual/override/final in chrome/

chrome/test/chromedriver/performance_logger_unittest.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 "chrome/test/chromedriver/performance_logger.h"
 
 #include "base/compiler_specific.h"
 #include "base/format_macros.h"
 #include "base/json/json_reader.h"
 #include "base/memory/scoped_vector.h"
@@ skipping 17 matching lines @@
   ~DevToolsCommand() {}
 
   std::string method;
   scoped_ptr<base::DictionaryValue> params;
 };
 
 class FakeDevToolsClient : public StubDevToolsClient {
  public:
   explicit FakeDevToolsClient(const std::string& id)
       : id_(id), listener_(NULL), command_index_(0) {}
-  virtual ~FakeDevToolsClient() {}
+  ~FakeDevToolsClient() override {}
 
   bool PopSentCommand(DevToolsCommand** out_command) {
     if (sent_commands_.size() > command_index_) {
       *out_command = sent_commands_.get().at(command_index_++);
       return true;
     }
     return false;
   }
 
   Status TriggerEvent(const std::string& method) {
     base::DictionaryValue empty_params;
     return listener_->OnEvent(this, method, empty_params);
   }
 
   Status TriggerEvent(const std::string& method,
                       const base::DictionaryValue& params) {
     return listener_->OnEvent(this, method, params);
   }
 
   // Overridden from DevToolsClient:
-  virtual Status ConnectIfNecessary() override {
-    return listener_->OnConnected(this);
-  }
+  Status ConnectIfNecessary() override { return listener_->OnConnected(this); }
 
-  virtual Status SendCommandAndGetResult(
+  Status SendCommandAndGetResult(
       const std::string& method,
       const base::DictionaryValue& params,
       scoped_ptr<base::DictionaryValue>* result) override {
     sent_commands_.push_back(new DevToolsCommand(method,
                                                  params.DeepCopy()));
     return Status(kOk);
   }
 
-  virtual void AddListener(DevToolsEventListener* listener) override {
+  void AddListener(DevToolsEventListener* listener) override {
     CHECK(!listener_);
     listener_ = listener;
   }
 
-  virtual const std::string& GetId() override {
-    return id_;
-  }
+  const std::string& GetId() override { return id_; }
 
  private:
   const std::string id_;  // WebView id.
   ScopedVector<DevToolsCommand> sent_commands_;  // Commands that were sent.
   DevToolsEventListener* listener_;  // The fake allows only one event listener.
   size_t command_index_;
 };
 
 struct LogEntry {
   const base::Time timestamp;
   const Log::Level level;
   const std::string source;
   const std::string message;
 
   LogEntry(const base::Time& timestamp,
            Log::Level level,
            const std::string& source,
            const std::string& message)
       : timestamp(timestamp), level(level), source(source), message(message) {}
 };
 
 class FakeLog : public Log {
  public:
-  virtual void AddEntryTimestamped(const base::Time& timestamp,
-                        Level level,
-                        const std::string& source,
-                        const std::string& message) override;
+  void AddEntryTimestamped(const base::Time& timestamp,
+                           Level level,
+                           const std::string& source,
+                           const std::string& message) override;
 
   const ScopedVector<LogEntry>& GetEntries() {
     return entries_;
   }
 
  private:
   ScopedVector<LogEntry> entries_;
 };
 
 void FakeLog::AddEntryTimestamped(const base::Time& timestamp,
@@ skipping 129 matching lines @@
   ASSERT_FALSE(client.PopSentCommand(&cmd));
 }
 
 namespace {
 
 class FakeBrowserwideClient : public FakeDevToolsClient {
  public:
   FakeBrowserwideClient()
       : FakeDevToolsClient(DevToolsClientImpl::kBrowserwideDevToolsClientId),
         events_handled_(false) {}
-  virtual ~FakeBrowserwideClient() {}
+  ~FakeBrowserwideClient() override {}
 
   bool events_handled() const {
     return events_handled_;
   }
 
   // Overridden from DevToolsClient:
-  virtual Status HandleEventsUntil(
-      const ConditionalFunc& conditional_func,
-      const base::TimeDelta& timeout) override {
+  Status HandleEventsUntil(const ConditionalFunc& conditional_func,
+                           const base::TimeDelta& timeout) override {
     TriggerEvent("Tracing.tracingComplete");
     events_handled_ = true;
     return Status(kOk);
   }
 
  private:
   bool events_handled_;
 };
 
 }  // namespace
@@ skipping 102 matching lines @@
   std::string webview;
   EXPECT_TRUE(message->GetString("webview", &webview));
   EXPECT_EQ(DevToolsClientImpl::kBrowserwideDevToolsClientId, webview);
   std::string method;
   EXPECT_TRUE(message->GetString("message.method", &method));
   EXPECT_EQ("Tracing.bufferUsage", method);
   base::DictionaryValue* actual_params;
   EXPECT_TRUE(message->GetDictionary("message.params", &actual_params));
   EXPECT_TRUE(actual_params->HasKey("error"));
 }