Standardize usage of virtual/override/final in components/

components/domain_reliability/service.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/domain_reliability/service.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 17 matching lines @@
 }
 
 }  // namespace
 
 class DomainReliabilityServiceImpl : public DomainReliabilityService {
  public:
   explicit DomainReliabilityServiceImpl(
       const std::string& upload_reporter_string)
       : upload_reporter_string_(upload_reporter_string) {}
 
-  virtual ~DomainReliabilityServiceImpl() {}
+  ~DomainReliabilityServiceImpl() override {}
 
   // DomainReliabilityService implementation:
 
-  virtual scoped_ptr<DomainReliabilityMonitor> CreateMonitor(
+  scoped_ptr<DomainReliabilityMonitor> CreateMonitor(
       scoped_refptr<base::SingleThreadTaskRunner> network_task_runner)
       override {
     DCHECK(!network_task_runner_.get());
 
     scoped_ptr<DomainReliabilityMonitor> monitor(
         new DomainReliabilityMonitor(upload_reporter_string_,
                                      base::MessageLoopProxy::current(),
                                      network_task_runner));
 
     monitor_ = monitor->MakeWeakPtr();
     network_task_runner_ = network_task_runner;
 
     return monitor.Pass();
   }
 
-  virtual void ClearBrowsingData(DomainReliabilityClearMode clear_mode,
-                                 const base::Closure& callback) override {
+  void ClearBrowsingData(DomainReliabilityClearMode clear_mode,
+                         const base::Closure& callback) override {
     DCHECK(network_task_runner_.get());
 
     network_task_runner_->PostTaskAndReply(
         FROM_HERE,
         base::Bind(&DomainReliabilityMonitor::ClearBrowsingData,
                    monitor_,
                    clear_mode),
         callback);
   }
 
-  virtual void GetWebUIData(
-      const base::Callback<void(scoped_ptr<base::Value>)>& callback)
-      const override {
+  void GetWebUIData(const base::Callback<void(scoped_ptr<base::Value>)>&
+                        callback) const override {
     DCHECK(network_task_runner_.get());
 
     PostTaskAndReplyWithResult(
         network_task_runner_.get(),
         FROM_HERE,
         base::Bind(&GetWebUIDataOnNetworkTaskRunner, monitor_),
         callback);
   }
 
  private:
   std::string upload_reporter_string_;
   base::WeakPtr<DomainReliabilityMonitor> monitor_;
   scoped_refptr<base::SingleThreadTaskRunner> network_task_runner_;
 };
 
 // static
 DomainReliabilityService* DomainReliabilityService::Create(
     const std::string& upload_reporter_string) {
   return new DomainReliabilityServiceImpl(upload_reporter_string);
 }
 
 DomainReliabilityService::~DomainReliabilityService() {}
 
 DomainReliabilityService::DomainReliabilityService() {}
 
 }  // namespace domain_reliability