replace OVERRIDE and FINAL with override and final in chromeos/

chromeos/dbus/update_engine_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/update_engine_client.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 65 matching lines @@
 // The UpdateEngineClient implementation used in production.
 class UpdateEngineClientImpl : public UpdateEngineClient {
  public:
   UpdateEngineClientImpl()
       : update_engine_proxy_(NULL), last_status_(), weak_ptr_factory_(this) {}
 
   virtual ~UpdateEngineClientImpl() {
   }
 
   // UpdateEngineClient implementation:
-  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 RequestUpdateCheck(
-      const UpdateCheckCallback& callback) OVERRIDE {
+      const UpdateCheckCallback& callback) override {
     dbus::MethodCall method_call(
         update_engine::kUpdateEngineInterface,
         update_engine::kAttemptUpdate);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString("");  // Unused.
     writer.AppendString("");  // Unused.
 
     VLOG(1) << "Requesting an update check";
     update_engine_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&UpdateEngineClientImpl::OnRequestUpdateCheck,
                    weak_ptr_factory_.GetWeakPtr(),
                    callback));
   }
 
-  virtual void RebootAfterUpdate() OVERRIDE {
+  virtual void RebootAfterUpdate() override {
     dbus::MethodCall method_call(
         update_engine::kUpdateEngineInterface,
         update_engine::kRebootIfNeeded);
 
     VLOG(1) << "Requesting a reboot";
     update_engine_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&UpdateEngineClientImpl::OnRebootAfterUpdate,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
-  virtual void Rollback() OVERRIDE {
+  virtual void Rollback() override {
     VLOG(1) << "Requesting a rollback";
      dbus::MethodCall method_call(
         update_engine::kUpdateEngineInterface,
         update_engine::kAttemptRollback);
     dbus::MessageWriter writer(&method_call);
     writer.AppendBool(true /* powerwash */);
 
     update_engine_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&UpdateEngineClientImpl::OnRollback,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
 
   virtual void CanRollbackCheck(
-      const RollbackCheckCallback& callback) OVERRIDE {
+      const RollbackCheckCallback& callback) override {
     dbus::MethodCall method_call(
         update_engine::kUpdateEngineInterface,
         update_engine::kCanRollback);
 
     VLOG(1) << "Requesting to get rollback availability status";
     update_engine_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&UpdateEngineClientImpl::OnCanRollbackCheck,
                    weak_ptr_factory_.GetWeakPtr(),
                    callback));
   }
 
-  virtual Status GetLastStatus() OVERRIDE {
+  virtual Status GetLastStatus() override {
     return last_status_;
   }
 
   virtual void SetChannel(const std::string& target_channel,
-                          bool is_powerwash_allowed) OVERRIDE {
+                          bool is_powerwash_allowed) override {
     if (!IsValidChannel(target_channel)) {
       LOG(ERROR) << "Invalid channel name: " << target_channel;
       return;
     }
 
     dbus::MethodCall method_call(
         update_engine::kUpdateEngineInterface,
         update_engine::kSetChannel);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(target_channel);
     writer.AppendBool(is_powerwash_allowed);
 
     VLOG(1) << "Requesting to set channel: "
             << "target_channel=" << target_channel << ", "
             << "is_powerwash_allowed=" << is_powerwash_allowed;
     update_engine_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&UpdateEngineClientImpl::OnSetChannel,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   virtual void GetChannel(bool get_current_channel,
-                          const GetChannelCallback& callback) OVERRIDE {
+                          const GetChannelCallback& callback) override {
     dbus::MethodCall method_call(
         update_engine::kUpdateEngineInterface,
         update_engine::kGetChannel);
     dbus::MessageWriter writer(&method_call);
     writer.AppendBool(get_current_channel);
 
     VLOG(1) << "Requesting to get channel, get_current_channel="
             << get_current_channel;
     update_engine_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&UpdateEngineClientImpl::OnGetChannel,
                    weak_ptr_factory_.GetWeakPtr(),
                    callback));
   }
 
  protected:
-  virtual void Init(dbus::Bus* bus) OVERRIDE {
+  virtual void Init(dbus::Bus* bus) override {
     update_engine_proxy_ = bus->GetObjectProxy(
         update_engine::kUpdateEngineServiceName,
         dbus::ObjectPath(update_engine::kUpdateEngineServicePath));
 
     // Monitor the D-Bus signal for brightness changes. Only the power
     // manager knows the actual brightness level. We don't cache the
     // brightness level in Chrome as it will make things less reliable.
     update_engine_proxy_->ConnectToSignal(
         update_engine::kUpdateEngineInterface,
         update_engine::kStatusUpdate,
@@ skipping 177 matching lines @@
 
 // The UpdateEngineClient implementation used on Linux desktop,
 // which does nothing.
 class UpdateEngineClientStubImpl : public UpdateEngineClient {
  public:
   UpdateEngineClientStubImpl()
       : current_channel_(kReleaseChannelBeta),
         target_channel_(kReleaseChannelBeta) {}
 
   // UpdateEngineClient implementation:
-  virtual void Init(dbus::Bus* bus) OVERRIDE {}
-  virtual void AddObserver(Observer* observer) OVERRIDE {}
-  virtual void RemoveObserver(Observer* observer) OVERRIDE {}
-  virtual bool HasObserver(Observer* observer) OVERRIDE { return false; }
+  virtual void Init(dbus::Bus* bus) override {}
+  virtual void AddObserver(Observer* observer) override {}
+  virtual void RemoveObserver(Observer* observer) override {}
+  virtual bool HasObserver(Observer* observer) override { return false; }
 
   virtual void RequestUpdateCheck(
-      const UpdateCheckCallback& callback) OVERRIDE {
+      const UpdateCheckCallback& callback) override {
     callback.Run(UPDATE_RESULT_NOTIMPLEMENTED);
   }
-  virtual void RebootAfterUpdate() OVERRIDE {}
-  virtual void Rollback() OVERRIDE {}
+  virtual void RebootAfterUpdate() override {}
+  virtual void Rollback() override {}
   virtual void CanRollbackCheck(
-      const RollbackCheckCallback& callback) OVERRIDE {
+      const RollbackCheckCallback& callback) override {
     callback.Run(true);
   }
-  virtual Status GetLastStatus() OVERRIDE { return Status(); }
+  virtual Status GetLastStatus() override { return Status(); }
   virtual void SetChannel(const std::string& target_channel,
-                          bool is_powerwash_allowed) OVERRIDE {
+                          bool is_powerwash_allowed) override {
     VLOG(1) << "Requesting to set channel: "
             << "target_channel=" << target_channel << ", "
             << "is_powerwash_allowed=" << is_powerwash_allowed;
     target_channel_ = target_channel;
   }
   virtual void GetChannel(bool get_current_channel,
-                          const GetChannelCallback& callback) OVERRIDE {
+                          const GetChannelCallback& callback) override {
     VLOG(1) << "Requesting to get channel, get_current_channel="
             << get_current_channel;
     if (get_current_channel)
       callback.Run(current_channel_);
     else
       callback.Run(target_channel_);
   }
 
   std::string current_channel_;
   std::string target_channel_;
 };
 
 // The UpdateEngineClient implementation used on Linux desktop, which
 // tries to emulate real update engine client.
 class UpdateEngineClientFakeImpl : public UpdateEngineClientStubImpl {
  public:
   UpdateEngineClientFakeImpl() : weak_factory_(this) {
   }
 
   virtual ~UpdateEngineClientFakeImpl() {
   }
 
   // UpdateEngineClient implementation:
-  virtual void AddObserver(Observer* observer) OVERRIDE {
+  virtual void AddObserver(Observer* observer) override {
     if (observer)
       observers_.AddObserver(observer);
   }
 
-  virtual void RemoveObserver(Observer* observer) OVERRIDE {
+  virtual void RemoveObserver(Observer* observer) override {
     if (observer)
       observers_.RemoveObserver(observer);
   }
 
-  virtual bool HasObserver(Observer* observer) OVERRIDE {
+  virtual bool HasObserver(Observer* observer) override {
     return observers_.HasObserver(observer);
   }
 
   virtual void RequestUpdateCheck(
-      const UpdateCheckCallback& callback) OVERRIDE {
+      const UpdateCheckCallback& callback) override {
     if (last_status_.status != UPDATE_STATUS_IDLE) {
       callback.Run(UPDATE_RESULT_FAILED);
       return;
     }
     callback.Run(UPDATE_RESULT_SUCCESS);
     last_status_.status = UPDATE_STATUS_CHECKING_FOR_UPDATE;
     last_status_.download_progress = 0.0;
     last_status_.last_checked_time = 0;
     last_status_.new_size = 0;
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&UpdateEngineClientFakeImpl::StateTransition,
                    weak_factory_.GetWeakPtr()),
         base::TimeDelta::FromMilliseconds(kStateTransitionDefaultDelayMs));
   }
 
-  virtual Status GetLastStatus() OVERRIDE { return last_status_; }
+  virtual Status GetLastStatus() override { return last_status_; }
 
  private:
   void StateTransition() {
     UpdateStatusOperation next_status = UPDATE_STATUS_ERROR;
     int delay_ms = kStateTransitionDefaultDelayMs;
     switch (last_status_.status) {
       case UPDATE_STATUS_ERROR:
       case UPDATE_STATUS_IDLE:
       case UPDATE_STATUS_UPDATED_NEED_REBOOT:
       case UPDATE_STATUS_REPORTING_ERROR_EVENT:
@@ skipping 59 matching lines @@
   if (type == REAL_DBUS_CLIENT_IMPLEMENTATION)
     return new UpdateEngineClientImpl();
   DCHECK_EQ(STUB_DBUS_CLIENT_IMPLEMENTATION, type);
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kTestAutoUpdateUI))
     return new UpdateEngineClientFakeImpl();
   else
     return new UpdateEngineClientStubImpl();
 }
 
 }  // namespace chromeos