Standardize usage of virtual/override/final in mojo/

mojo/common/handle_watcher.cc

 // Copyright 2013 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 "mojo/common/handle_watcher.h"
 
 #include <map>
 
 #include "base/atomic_sequence_num.h"
 #include "base/bind.h"
@@ skipping 43 matching lines @@
 };
 
 // WatcherBackend --------------------------------------------------------------
 
 // WatcherBackend is responsible for managing the requests and interacting with
 // MessagePumpMojo. All access (outside of creation/destruction) is done on the
 // thread WatcherThreadManager creates.
 class WatcherBackend : public MessagePumpMojoHandler {
  public:
   WatcherBackend();
-  virtual ~WatcherBackend();
+  ~WatcherBackend() override;
 
   void StartWatching(const WatchData& data);
 
   // Cancels a previously scheduled request to start a watch.
   void StopWatching(WatcherID watcher_id);
 
  private:
   typedef std::map<Handle, WatchData> HandleToWatchDataMap;
 
   // Invoked when a handle needs to be removed and notified.
   void RemoveAndNotify(const Handle& handle, MojoResult result);
 
   // Searches through |handle_to_data_| for |watcher_id|. Returns true if found
   // and sets |handle| to the Handle. Returns false if not a known id.
   bool GetMojoHandleByWatcherID(WatcherID watcher_id, Handle* handle) const;
 
   // MessagePumpMojoHandler overrides:
-  virtual void OnHandleReady(const Handle& handle) override;
-  virtual void OnHandleError(const Handle& handle, MojoResult result) override;
+  void OnHandleReady(const Handle& handle) override;
+  void OnHandleError(const Handle& handle, MojoResult result) override;
 
   // Maps from assigned id to WatchData.
   HandleToWatchDataMap handle_to_data_;
 
   DISALLOW_COPY_AND_ASSIGN(WatcherBackend);
 };
 
 WatcherBackend::WatcherBackend() {
 }
 
@@ skipping 224 matching lines @@
 class HandleWatcher::StateBase : public base::MessageLoop::DestructionObserver {
  public:
   StateBase(HandleWatcher* watcher,
             const base::Callback<void(MojoResult)>& callback)
       : watcher_(watcher),
         callback_(callback),
         got_ready_(false) {
     base::MessageLoop::current()->AddDestructionObserver(this);
   }
 
-  virtual ~StateBase() {
+  ~StateBase() override {
     base::MessageLoop::current()->RemoveDestructionObserver(this);
   }
 
  protected:
   void NotifyHandleReady(MojoResult result) {
     got_ready_ = true;
     NotifyAndDestroy(result);
   }
 
   bool got_ready() const { return got_ready_; }
 
  private:
-  virtual void WillDestroyCurrentMessageLoop() override {
+  void WillDestroyCurrentMessageLoop() override {
     // The current thread is exiting. Simulate a watch error.
     NotifyAndDestroy(MOJO_RESULT_ABORTED);
   }
 
   void NotifyAndDestroy(MojoResult result) {
     base::Callback<void(MojoResult)> callback = callback_;
     watcher_->Stop();  // Destroys |this|.
 
     callback.Run(result);
   }
@@ skipping 19 matching lines @@
                           MojoDeadline deadline,
                           const base::Callback<void(MojoResult)>& callback)
       : StateBase(watcher, callback),
         handle_(handle) {
     DCHECK(MessagePumpMojo::IsCurrent());
 
     MessagePumpMojo::current()->AddHandler(
         this, handle, handle_signals, MojoDeadlineToTimeTicks(deadline));
   }
 
-  virtual ~SameThreadWatchingState() {
+  ~SameThreadWatchingState() override {
     if (!got_ready())
       MessagePumpMojo::current()->RemoveHandler(handle_);
   }
 
  private:
   // MessagePumpMojoHandler overrides:
-  virtual void OnHandleReady(const Handle& handle) override {
+  void OnHandleReady(const Handle& handle) override {
     StopWatchingAndNotifyReady(handle, MOJO_RESULT_OK);
   }
 
-  virtual void OnHandleError(const Handle& handle, MojoResult result) override {
+  void OnHandleError(const Handle& handle, MojoResult result) override {
     StopWatchingAndNotifyReady(handle, result);
   }
 
   void StopWatchingAndNotifyReady(const Handle& handle, MojoResult result) {
     DCHECK_EQ(handle.value(), handle_.value());
     MessagePumpMojo::current()->RemoveHandler(handle_);
     NotifyHandleReady(result);
   }
 
   Handle handle_;
@@ skipping 14 matching lines @@
       : StateBase(watcher, callback),
         weak_factory_(this) {
     watcher_id_ = WatcherThreadManager::GetInstance()->StartWatching(
         handle,
         handle_signals,
         MojoDeadlineToTimeTicks(deadline),
         base::Bind(&SecondaryThreadWatchingState::NotifyHandleReady,
                    weak_factory_.GetWeakPtr()));
   }
 
-  virtual ~SecondaryThreadWatchingState() {
+  ~SecondaryThreadWatchingState() override {
     // If we've been notified the handle is ready (|got_ready()| is true) then
     // the watch has been implicitly removed by
     // WatcherThreadManager/MessagePumpMojo and we don't have to call
     // StopWatching(). To do so would needlessly entail posting a task and
     // blocking until the background thread services it.
     if (!got_ready())
       WatcherThreadManager::GetInstance()->StopWatching(watcher_id_);
   }
 
  private:
@@ skipping 28 matching lines @@
         this, handle, handle_signals, deadline, callback));
   }
 }
 
 void HandleWatcher::Stop() {
   state_.reset();
 }
 
 }  // namespace common
 }  // namespace mojo