replace OVERRIDE and FINAL with override and final in chromeos/

chromeos/dbus/power_manager_client.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 "chromeos/dbus/power_manager_client.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 50 matching lines @@
     // Here we should unregister suspend notifications from powerd,
     // however:
     // - The lifetime of the PowerManagerClientImpl can extend past that of
     //   the objectproxy,
     // - power_manager can already detect that the client is gone and
     //   unregister our suspend delay.
   }
 
   // PowerManagerClient overrides:
 
-  virtual void AddObserver(Observer* observer) OVERRIDE {
+  virtual void AddObserver(Observer* observer) override {
     CHECK(observer);  // http://crbug.com/119976
     observers_.AddObserver(observer);
   }
 
-  virtual void RemoveObserver(Observer* observer) OVERRIDE {
+  virtual void RemoveObserver(Observer* observer) override {
     observers_.RemoveObserver(observer);
   }
 
-  virtual bool HasObserver(Observer* observer) OVERRIDE {
+  virtual bool HasObserver(Observer* observer) override {
     return observers_.HasObserver(observer);
   }
 
-  virtual void DecreaseScreenBrightness(bool allow_off) OVERRIDE {
+  virtual void DecreaseScreenBrightness(bool allow_off) override {
     dbus::MethodCall method_call(
         power_manager::kPowerManagerInterface,
         power_manager::kDecreaseScreenBrightnessMethod);
     dbus::MessageWriter writer(&method_call);
     writer.AppendBool(allow_off);
     power_manager_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         dbus::ObjectProxy::EmptyResponseCallback());
   }
 
-  virtual void IncreaseScreenBrightness() OVERRIDE {
+  virtual void IncreaseScreenBrightness() override {
     SimpleMethodCallToPowerManager(
         power_manager::kIncreaseScreenBrightnessMethod);
   }
 
-  virtual void DecreaseKeyboardBrightness() OVERRIDE {
+  virtual void DecreaseKeyboardBrightness() override {
     SimpleMethodCallToPowerManager(
         power_manager::kDecreaseKeyboardBrightnessMethod);
   }
 
-  virtual void IncreaseKeyboardBrightness() OVERRIDE {
+  virtual void IncreaseKeyboardBrightness() override {
     SimpleMethodCallToPowerManager(
         power_manager::kIncreaseKeyboardBrightnessMethod);
   }
 
   virtual void SetScreenBrightnessPercent(double percent,
-                                          bool gradual) OVERRIDE {
+                                          bool gradual) override {
     dbus::MethodCall method_call(
         power_manager::kPowerManagerInterface,
         power_manager::kSetScreenBrightnessPercentMethod);
     dbus::MessageWriter writer(&method_call);
     writer.AppendDouble(percent);
     writer.AppendInt32(
         gradual ?
         power_manager::kBrightnessTransitionGradual :
         power_manager::kBrightnessTransitionInstant);
     power_manager_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         dbus::ObjectProxy::EmptyResponseCallback());
   }
 
   virtual void GetScreenBrightnessPercent(
-      const GetScreenBrightnessPercentCallback& callback) OVERRIDE {
+      const GetScreenBrightnessPercentCallback& callback) override {
     dbus::MethodCall method_call(
         power_manager::kPowerManagerInterface,
         power_manager::kGetScreenBrightnessPercentMethod);
     power_manager_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&PowerManagerClientImpl::OnGetScreenBrightnessPercent,
                    weak_ptr_factory_.GetWeakPtr(), callback));
   }
 
-  virtual void RequestStatusUpdate() OVERRIDE {
+  virtual void RequestStatusUpdate() override {
     dbus::MethodCall method_call(
         power_manager::kPowerManagerInterface,
         power_manager::kGetPowerSupplyPropertiesMethod);
     power_manager_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&PowerManagerClientImpl::OnGetPowerSupplyPropertiesMethod,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
-  virtual void RequestSuspend() OVERRIDE {
+  virtual void RequestSuspend() override {
     SimpleMethodCallToPowerManager(power_manager::kRequestSuspendMethod);
   }
 
-  virtual void RequestRestart() OVERRIDE {
+  virtual void RequestRestart() override {
     SimpleMethodCallToPowerManager(power_manager::kRequestRestartMethod);
   }
 
-  virtual void RequestShutdown() OVERRIDE {
+  virtual void RequestShutdown() override {
     SimpleMethodCallToPowerManager(power_manager::kRequestShutdownMethod);
   }
 
   virtual void NotifyUserActivity(
-      power_manager::UserActivityType type) OVERRIDE {
+      power_manager::UserActivityType type) override {
     dbus::MethodCall method_call(
         power_manager::kPowerManagerInterface,
         power_manager::kHandleUserActivityMethod);
     dbus::MessageWriter writer(&method_call);
     writer.AppendInt32(type);
 
     power_manager_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         dbus::ObjectProxy::EmptyResponseCallback());
   }
 
-  virtual void NotifyVideoActivity(bool is_fullscreen) OVERRIDE {
+  virtual void NotifyVideoActivity(bool is_fullscreen) override {
     dbus::MethodCall method_call(
         power_manager::kPowerManagerInterface,
         power_manager::kHandleVideoActivityMethod);
     dbus::MessageWriter writer(&method_call);
     writer.AppendBool(is_fullscreen);
 
     power_manager_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         dbus::ObjectProxy::EmptyResponseCallback());
   }
 
   virtual void SetPolicy(
-      const power_manager::PowerManagementPolicy& policy) OVERRIDE {
+      const power_manager::PowerManagementPolicy& policy) override {
     dbus::MethodCall method_call(
         power_manager::kPowerManagerInterface,
         power_manager::kSetPolicyMethod);
     dbus::MessageWriter writer(&method_call);
     if (!writer.AppendProtoAsArrayOfBytes(policy)) {
       LOG(ERROR) << "Error calling " << power_manager::kSetPolicyMethod;
       return;
     }
     power_manager_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         dbus::ObjectProxy::EmptyResponseCallback());
   }
 
-  virtual void SetIsProjecting(bool is_projecting) OVERRIDE {
+  virtual void SetIsProjecting(bool is_projecting) override {
     dbus::MethodCall method_call(
         power_manager::kPowerManagerInterface,
         power_manager::kSetIsProjectingMethod);
     dbus::MessageWriter writer(&method_call);
     writer.AppendBool(is_projecting);
     power_manager_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         dbus::ObjectProxy::EmptyResponseCallback());
     last_is_projecting_ = is_projecting;
   }
 
-  virtual base::Closure GetSuspendReadinessCallback() OVERRIDE {
+  virtual base::Closure GetSuspendReadinessCallback() override {
     DCHECK(OnOriginThread());
     DCHECK(suspend_is_pending_);
     num_pending_suspend_readiness_callbacks_++;
     return base::Bind(&PowerManagerClientImpl::HandleObserverSuspendReadiness,
                       weak_ptr_factory_.GetWeakPtr(), pending_suspend_id_,
                       suspending_from_dark_resume_);
   }
 
-  virtual int GetNumPendingSuspendReadinessCallbacks() OVERRIDE {
+  virtual int GetNumPendingSuspendReadinessCallbacks() override {
     return num_pending_suspend_readiness_callbacks_;
   }
 
  protected:
-  virtual void Init(dbus::Bus* bus) OVERRIDE {
+  virtual void Init(dbus::Bus* bus) override {
     power_manager_proxy_ = bus->GetObjectProxy(
         power_manager::kPowerManagerServiceName,
         dbus::ObjectPath(power_manager::kPowerManagerServicePath));
 
     power_manager_proxy_->SetNameOwnerChangedCallback(
         base::Bind(&PowerManagerClientImpl::NameOwnerChangedReceived,
                    weak_ptr_factory_.GetWeakPtr()));
 
     // Monitor the D-Bus signal for brightness changes. Only the power
     // manager knows the actual brightness level. We don't cache the
@@ skipping 500 matching lines @@
         num_pending_suspend_readiness_callbacks_(0),
         weak_ptr_factory_(this) {}
 
   virtual ~PowerManagerClientStubImpl() {}
 
   int num_pending_suspend_readiness_callbacks() const {
     return num_pending_suspend_readiness_callbacks_;
   }
 
   // PowerManagerClient overrides:
-  virtual void Init(dbus::Bus* bus) OVERRIDE {
+  virtual void Init(dbus::Bus* bus) override {
     ParseCommandLineSwitch();
     if (power_cycle_delay_ != base::TimeDelta()) {
       update_timer_.Start(FROM_HERE,
                           power_cycle_delay_,
                           this,
                           &PowerManagerClientStubImpl::UpdateStatus);
     }
   }
 
-  virtual void AddObserver(Observer* observer) OVERRIDE {
+  virtual void AddObserver(Observer* observer) override {
     observers_.AddObserver(observer);
   }
 
-  virtual void RemoveObserver(Observer* observer) OVERRIDE {
+  virtual void RemoveObserver(Observer* observer) override {
     observers_.RemoveObserver(observer);
   }
 
-  virtual bool HasObserver(Observer* observer) OVERRIDE {
+  virtual bool HasObserver(Observer* observer) override {
     return observers_.HasObserver(observer);
   }
 
-  virtual void DecreaseScreenBrightness(bool allow_off) OVERRIDE {
+  virtual void DecreaseScreenBrightness(bool allow_off) override {
     VLOG(1) << "Requested to descrease screen brightness";
     SetBrightness(brightness_ - 5.0, true);
   }
 
-  virtual void IncreaseScreenBrightness() OVERRIDE {
+  virtual void IncreaseScreenBrightness() override {
     VLOG(1) << "Requested to increase screen brightness";
     SetBrightness(brightness_ + 5.0, true);
   }
 
   virtual void SetScreenBrightnessPercent(double percent,
-                                          bool gradual) OVERRIDE {
+                                          bool gradual) override {
     VLOG(1) << "Requested to set screen brightness to " << percent << "% "
             << (gradual ? "gradually" : "instantaneously");
     SetBrightness(percent, false);
   }
 
   virtual void GetScreenBrightnessPercent(
-      const GetScreenBrightnessPercentCallback& callback) OVERRIDE {
+      const GetScreenBrightnessPercentCallback& callback) override {
     callback.Run(brightness_);
   }
 
-  virtual void DecreaseKeyboardBrightness() OVERRIDE {
+  virtual void DecreaseKeyboardBrightness() override {
     VLOG(1) << "Requested to descrease keyboard brightness";
   }
 
-  virtual void IncreaseKeyboardBrightness() OVERRIDE {
+  virtual void IncreaseKeyboardBrightness() override {
     VLOG(1) << "Requested to increase keyboard brightness";
   }
 
-  virtual void RequestStatusUpdate() OVERRIDE {
+  virtual void RequestStatusUpdate() override {
     base::MessageLoop::current()->PostTask(FROM_HERE,
         base::Bind(&PowerManagerClientStubImpl::UpdateStatus,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
-  virtual void RequestSuspend() OVERRIDE {}
-  virtual void RequestRestart() OVERRIDE {}
-  virtual void RequestShutdown() OVERRIDE {}
+  virtual void RequestSuspend() override {}
+  virtual void RequestRestart() override {}
+  virtual void RequestShutdown() override {}
 
   virtual void NotifyUserActivity(
-      power_manager::UserActivityType type) OVERRIDE {}
-  virtual void NotifyVideoActivity(bool is_fullscreen) OVERRIDE {}
+      power_manager::UserActivityType type) override {}
+  virtual void NotifyVideoActivity(bool is_fullscreen) override {}
   virtual void SetPolicy(
-      const power_manager::PowerManagementPolicy& policy) OVERRIDE {}
-  virtual void SetIsProjecting(bool is_projecting) OVERRIDE {}
-  virtual base::Closure GetSuspendReadinessCallback() OVERRIDE {
+      const power_manager::PowerManagementPolicy& policy) override {}
+  virtual void SetIsProjecting(bool is_projecting) override {}
+  virtual base::Closure GetSuspendReadinessCallback() override {
     num_pending_suspend_readiness_callbacks_++;
     return base::Bind(&PowerManagerClientStubImpl::HandleSuspendReadiness,
                       weak_ptr_factory_.GetWeakPtr());
   }
-  virtual int GetNumPendingSuspendReadinessCallbacks() OVERRIDE {
+  virtual int GetNumPendingSuspendReadinessCallbacks() override {
     return num_pending_suspend_readiness_callbacks_;
   }
 
  private:
   void HandleSuspendReadiness() {
     num_pending_suspend_readiness_callbacks_--;
   }
 
   void UpdateStatus() {
     if (pause_count_ > 0) {
@@ skipping 121 matching lines @@
 // static
 PowerManagerClient* PowerManagerClient::Create(
     DBusClientImplementationType type) {
   if (type == REAL_DBUS_CLIENT_IMPLEMENTATION)
     return new PowerManagerClientImpl();
   DCHECK_EQ(STUB_DBUS_CLIENT_IMPLEMENTATION, type);
   return new PowerManagerClientStubImpl();
 }
 
 }  // namespace chromeos