Standardize usage of virtual/override/final in components/

components/copresence/rpc/rpc_handler_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 "components/copresence/rpc/rpc_handler.h"
 
 #include <map>
 #include <string>
 #include <vector>
 
@@ skipping 22 matching lines @@
   message_proto->mutable_published_message()->set_payload(message_string);
   for (const std::string& subscription_id : subscription_ids) {
     message_proto->add_subscription_id(subscription_id);
   }
 }
 
 // TODO(ckehoe): Make DirectiveHandler an interface.
 class FakeDirectiveHandler : public DirectiveHandler {
  public:
   FakeDirectiveHandler() {}
-  virtual ~FakeDirectiveHandler() {}
+  ~FakeDirectiveHandler() override {}
 
   const std::vector<Directive>& added_directives() const {
     return added_directives_;
   }
 
-  virtual void Initialize(
+  void Initialize(
       const AudioRecorder::DecodeSamplesCallback& decode_cb,
       const AudioDirectiveHandler::EncodeTokenCallback& encode_cb) override {}
 
-  virtual void AddDirective(const Directive& directive) override {
+  void AddDirective(const Directive& directive) override {
     added_directives_.push_back(directive);
   }
 
-  virtual void RemoveDirectives(const std::string& op_id) override {
+  void RemoveDirectives(const std::string& op_id) override {
     // TODO(ckehoe): Add a parallel implementation when prod has one.
   }
 
  private:
   std::vector<Directive> added_directives_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeDirectiveHandler);
 };
 
 }  // namespace
@@ skipping 62 matching lines @@
                                    const std::string& response) {
     rpc_handler_.ReportResponseHandler(
         base::Bind(&RpcHandlerTest::CaptureStatus, base::Unretained(this)),
         NULL,
         status_code,
         response);
   }
 
   // CopresenceDelegate implementation
 
-  virtual void HandleMessages(
-      const std::string& app_id,
-      const std::string& subscription_id,
-      const std::vector<Message>& messages) override {
+  void HandleMessages(const std::string& app_id,
+                      const std::string& subscription_id,
+                      const std::vector<Message>& messages) override {
     // app_id is unused for now, pending a server fix.
     messages_by_subscription_[subscription_id] = messages;
   }
 
-  virtual net::URLRequestContextGetter* GetRequestContext() const override {
+  net::URLRequestContextGetter* GetRequestContext() const override {
     return NULL;
   }
 
-  virtual const std::string GetPlatformVersionString() const override {
+  const std::string GetPlatformVersionString() const override {
     return kChromeVersion;
   }
 
-  virtual const std::string GetAPIKey() const override {
-    return api_key_;
-  }
+  const std::string GetAPIKey() const override { return api_key_; }
 
-  virtual WhispernetClient* GetWhispernetClient() override {
-    return NULL;
-  }
+  WhispernetClient* GetWhispernetClient() override { return NULL; }
 
  protected:
   // For rpc_handler_.invalid_audio_token_cache_
   base::MessageLoop message_loop_;
 
   RpcHandler rpc_handler_;
   CopresenceStatus status_;
   std::string api_key_;
 
   std::string rpc_name_;
@@ skipping 100 matching lines @@
             messages_by_subscription_["Subscription 2"][1].payload());
 
   ASSERT_EQ(2U, directive_handler->added_directives().size());
   EXPECT_EQ("Subscription 1",
             directive_handler->added_directives()[0].subscription_id());
   EXPECT_EQ("Subscription 2",
             directive_handler->added_directives()[1].subscription_id());
 }
 
 }  // namespace copresence