Standardize usage of virtual/override/final specifiers in dbus/.

dbus/bus.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 "dbus/bus.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
@@ skipping 29 matching lines @@
 
 // The class is used for watching the file descriptor used for D-Bus
 // communication.
 class Watch : public base::MessagePumpLibevent::Watcher {
  public:
   explicit Watch(DBusWatch* watch)
       : raw_watch_(watch) {
     dbus_watch_set_data(raw_watch_, this, NULL);
   }
 
-  virtual ~Watch() {
-    dbus_watch_set_data(raw_watch_, NULL, NULL);
-  }
+  ~Watch() override { dbus_watch_set_data(raw_watch_, NULL, NULL); }
 
   // Returns true if the underlying file descriptor is ready to be watched.
   bool IsReadyToBeWatched() {
     return dbus_watch_get_enabled(raw_watch_);
   }
 
   // Starts watching the underlying file descriptor.
   void StartWatching() {
     const int file_descriptor = dbus_watch_get_unix_fd(raw_watch_);
     const int flags = dbus_watch_get_flags(raw_watch_);
@@ skipping 14 matching lines @@
     CHECK(success) << "Unable to allocate memory";
   }
 
   // Stops watching the underlying file descriptor.
   void StopWatching() {
     file_descriptor_watcher_.StopWatchingFileDescriptor();
   }
 
  private:
   // Implement MessagePumpLibevent::Watcher.
-  virtual void OnFileCanReadWithoutBlocking(int file_descriptor) override {
+  void OnFileCanReadWithoutBlocking(int file_descriptor) override {
     const bool success = dbus_watch_handle(raw_watch_, DBUS_WATCH_READABLE);
     CHECK(success) << "Unable to allocate memory";
   }
 
   // Implement MessagePumpLibevent::Watcher.
-  virtual void OnFileCanWriteWithoutBlocking(int file_descriptor) override {
+  void OnFileCanWriteWithoutBlocking(int file_descriptor) override {
     const bool success = dbus_watch_handle(raw_watch_, DBUS_WATCH_WRITABLE);
     CHECK(success) << "Unable to allocate memory";
   }
 
   DBusWatch* raw_watch_;
   base::MessagePumpLibevent::FileDescriptorWatcher file_descriptor_watcher_;
 };
 
 // The class is used for monitoring the timeout used for D-Bus method
 // calls.
@@ skipping 1104 matching lines @@
                              kNameOwnerChangedSignal)) {
     Bus* self = static_cast<Bus*>(data);
     self->OnServiceOwnerChanged(message);
   }
   // Always return unhandled to let others, e.g. ObjectProxies, handle the same
   // signal.
   return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 }
 
 }  // namespace dbus