Standardize usage of virtual/override/final in sync/

sync/tools/sync_listen_notifications.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 <cstddef>
 #include <cstdio>
 #include <string>
 
 #include "base/at_exit.h"
 #include "base/command_line.h"
@@ skipping 34 matching lines @@
 const char kEmailSwitch[] = "email";
 const char kTokenSwitch[] = "token";
 const char kHostPortSwitch[] = "host-port";
 const char kTrySslTcpFirstSwitch[] = "try-ssltcp-first";
 const char kAllowInsecureConnectionSwitch[] = "allow-insecure-connection";
 
 // Class to print received notifications events.
 class NotificationPrinter : public InvalidationHandler {
  public:
   NotificationPrinter() {}
-  virtual ~NotificationPrinter() {}
+  ~NotificationPrinter() override {}
 
-  virtual void OnInvalidatorStateChange(InvalidatorState state) override {
+  void OnInvalidatorStateChange(InvalidatorState state) override {
     LOG(INFO) << "Invalidator state changed to "
               << InvalidatorStateToString(state);
   }
 
-  virtual void OnIncomingInvalidation(
+  void OnIncomingInvalidation(
       const ObjectIdInvalidationMap& invalidation_map) override {
     ObjectIdSet ids = invalidation_map.GetObjectIds();
     for (ObjectIdSet::const_iterator it = ids.begin(); it != ids.end(); ++it) {
       LOG(INFO) << "Remote invalidation: "
                 << invalidation_map.ToString();
     }
   }
 
-  virtual std::string GetOwnerName() const override {
-    return "NotificationPrinter";
-  }
+  std::string GetOwnerName() const override { return "NotificationPrinter"; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(NotificationPrinter);
 };
 
 // Needed to use a real host resolver.
 class MyTestURLRequestContext : public net::TestURLRequestContext {
  public:
   MyTestURLRequestContext() : TestURLRequestContext(true) {
     context_storage_.set_host_resolver(
         net::HostResolver::CreateDefaultResolver(NULL));
     context_storage_.set_transport_security_state(
         new net::TransportSecurityState());
     Init();
   }
 
-  virtual ~MyTestURLRequestContext() {}
+  ~MyTestURLRequestContext() override {}
 };
 
 class MyTestURLRequestContextGetter : public net::TestURLRequestContextGetter {
  public:
   explicit MyTestURLRequestContextGetter(
       const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner)
       : TestURLRequestContextGetter(io_task_runner) {}
 
-  virtual net::TestURLRequestContext* GetURLRequestContext() override {
+  net::TestURLRequestContext* GetURLRequestContext() override {
     // Construct |context_| lazily so it gets constructed on the right
     // thread (the IO thread).
     if (!context_)
       context_.reset(new MyTestURLRequestContext());
     return context_.get();
   }
 
  private:
-  virtual ~MyTestURLRequestContextGetter() {}
+  ~MyTestURLRequestContextGetter() override {}
 
   scoped_ptr<MyTestURLRequestContext> context_;
 };
 
 notifier::NotifierOptions ParseNotifierOptions(
     const CommandLine& command_line,
     const scoped_refptr<net::URLRequestContextGetter>&
         request_context_getter) {
   notifier::NotifierOptions notifier_options;
   notifier_options.request_context_getter = request_context_getter;
@@ skipping 93 matching lines @@
   io_thread.Stop();
   return 0;
 }
 
 }  // namespace
 }  // namespace syncer
 
 int main(int argc, char* argv[]) {
   return syncer::SyncListenNotificationsMain(argc, argv);
 }