replace OVERRIDE and FINAL with override and final in chromeos/

chromeos/dbus/debug_daemon_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/debug_daemon_client.h"
 
 #include <fcntl.h>
 #include <unistd.h>
 #include <string>
 #include <vector>
@@ skipping 30 matching lines @@
 class DebugDaemonClientImpl : public DebugDaemonClient {
  public:
   DebugDaemonClientImpl() : debugdaemon_proxy_(NULL), weak_ptr_factory_(this) {}
 
   virtual ~DebugDaemonClientImpl() {}
 
   // DebugDaemonClient override.
   virtual void DumpDebugLogs(bool is_compressed,
                              base::File file,
                              scoped_refptr<base::TaskRunner> task_runner,
-                             const GetDebugLogsCallback& callback) OVERRIDE {
+                             const GetDebugLogsCallback& callback) override {
     dbus::FileDescriptor* file_descriptor = new dbus::FileDescriptor;
     file_descriptor->PutValue(file.TakePlatformFile());
     // Punt descriptor validity check to a worker thread; on return we'll
     // issue the D-Bus request to stop tracing and collect results.
     task_runner->PostTaskAndReply(
         FROM_HERE,
         base::Bind(&dbus::FileDescriptor::CheckValidity,
                    base::Unretained(file_descriptor)),
         base::Bind(&DebugDaemonClientImpl::OnCheckValidityGetDebugLogs,
                    weak_ptr_factory_.GetWeakPtr(),
                    is_compressed,
                    base::Owned(file_descriptor),
                    callback));
   }
 
   virtual void SetDebugMode(const std::string& subsystem,
-                            const SetDebugModeCallback& callback) OVERRIDE {
+                            const SetDebugModeCallback& callback) override {
     dbus::MethodCall method_call(debugd::kDebugdInterface,
                                  debugd::kSetDebugMode);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(subsystem);
     debugdaemon_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&DebugDaemonClientImpl::OnSetDebugMode,
                    weak_ptr_factory_.GetWeakPtr(),
                    callback));
   }
 
   virtual void GetRoutes(bool numeric, bool ipv6,
-                         const GetRoutesCallback& callback) OVERRIDE {
+                         const GetRoutesCallback& callback) override {
     dbus::MethodCall method_call(debugd::kDebugdInterface,
                                  debugd::kGetRoutes);
     dbus::MessageWriter writer(&method_call);
     dbus::MessageWriter sub_writer(NULL);
     writer.OpenArray("{sv}", &sub_writer);
     dbus::MessageWriter elem_writer(NULL);
     sub_writer.OpenDictEntry(&elem_writer);
     elem_writer.AppendString("numeric");
     elem_writer.AppendVariantOfBool(numeric);
     sub_writer.CloseContainer(&elem_writer);
     sub_writer.OpenDictEntry(&elem_writer);
     elem_writer.AppendString("v6");
     elem_writer.AppendVariantOfBool(ipv6);
     sub_writer.CloseContainer(&elem_writer);
     writer.CloseContainer(&sub_writer);
     debugdaemon_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&DebugDaemonClientImpl::OnGetRoutes,
                    weak_ptr_factory_.GetWeakPtr(),
                    callback));
   }
 
   virtual void GetNetworkStatus(const GetNetworkStatusCallback& callback)
-      OVERRIDE {
+      override {
     dbus::MethodCall method_call(debugd::kDebugdInterface,
                                  debugd::kGetNetworkStatus);
     debugdaemon_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&DebugDaemonClientImpl::OnGetNetworkStatus,
                    weak_ptr_factory_.GetWeakPtr(),
                    callback));
   }
 
   virtual void GetModemStatus(const GetModemStatusCallback& callback)
-      OVERRIDE {
+      override {
     dbus::MethodCall method_call(debugd::kDebugdInterface,
                                  debugd::kGetModemStatus);
     debugdaemon_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&DebugDaemonClientImpl::OnGetModemStatus,
                    weak_ptr_factory_.GetWeakPtr(),
                    callback));
   }
 
   virtual void GetWiMaxStatus(const GetWiMaxStatusCallback& callback)
-      OVERRIDE {
+      override {
     dbus::MethodCall method_call(debugd::kDebugdInterface,
                                  debugd::kGetWiMaxStatus);
     debugdaemon_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&DebugDaemonClientImpl::OnGetWiMaxStatus,
                    weak_ptr_factory_.GetWeakPtr(),
                    callback));
   }
 
   virtual void GetNetworkInterfaces(
-      const GetNetworkInterfacesCallback& callback) OVERRIDE {
+      const GetNetworkInterfacesCallback& callback) override {
     dbus::MethodCall method_call(debugd::kDebugdInterface,
                                  debugd::kGetInterfaces);
     debugdaemon_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&DebugDaemonClientImpl::OnGetNetworkInterfaces,
                    weak_ptr_factory_.GetWeakPtr(),
                    callback));
   }
 
   virtual void GetPerfData(uint32_t duration,
-                           const GetPerfDataCallback& callback) OVERRIDE {
+                           const GetPerfDataCallback& callback) override {
     dbus::MethodCall method_call(debugd::kDebugdInterface,
                                  debugd::kGetRichPerfData);
     dbus::MessageWriter writer(&method_call);
     writer.AppendUint32(duration);
 
     debugdaemon_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&DebugDaemonClientImpl::OnGetPerfData,
                    weak_ptr_factory_.GetWeakPtr(),
                    callback));
   }
 
-  virtual void GetScrubbedLogs(const GetLogsCallback& callback) OVERRIDE {
+  virtual void GetScrubbedLogs(const GetLogsCallback& callback) override {
     dbus::MethodCall method_call(debugd::kDebugdInterface,
                                  debugd::kGetFeedbackLogs);
     debugdaemon_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&DebugDaemonClientImpl::OnGetAllLogs,
                    weak_ptr_factory_.GetWeakPtr(),
                    callback));
   }
 
   virtual void GetAllLogs(const GetLogsCallback& callback)
-      OVERRIDE {
+      override {
     dbus::MethodCall method_call(debugd::kDebugdInterface,
                                  debugd::kGetAllLogs);
     debugdaemon_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&DebugDaemonClientImpl::OnGetAllLogs,
                    weak_ptr_factory_.GetWeakPtr(),
                    callback));
   }
 
   virtual void GetUserLogFiles(
-      const GetLogsCallback& callback) OVERRIDE {
+      const GetLogsCallback& callback) override {
     dbus::MethodCall method_call(debugd::kDebugdInterface,
                                  debugd::kGetUserLogFiles);
     debugdaemon_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&DebugDaemonClientImpl::OnGetUserLogFiles,
                    weak_ptr_factory_.GetWeakPtr(),
                    callback));
   }
 
-  virtual void StartSystemTracing() OVERRIDE {
+  virtual void StartSystemTracing() override {
     dbus::MethodCall method_call(
         debugd::kDebugdInterface,
         debugd::kSystraceStart);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString("all"); // TODO(sleffler) parameterize category list
 
     DVLOG(1) << "Requesting a systrace start";
     debugdaemon_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&DebugDaemonClientImpl::OnStartMethod,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   virtual bool RequestStopSystemTracing(
       scoped_refptr<base::TaskRunner> task_runner,
-      const StopSystemTracingCallback& callback) OVERRIDE {
+      const StopSystemTracingCallback& callback) override {
     if (pipe_reader_ != NULL) {
       LOG(ERROR) << "Busy doing StopSystemTracing";
       return false;
     }
 
     pipe_reader_.reset(new PipeReaderForString(
         task_runner,
         base::Bind(&DebugDaemonClientImpl::OnIOComplete,
                    weak_ptr_factory_.GetWeakPtr())));
 
     base::File pipe_write_end = pipe_reader_->StartIO();
     // Create dbus::FileDescriptor on the worker thread; on return we'll
     // issue the D-Bus request to stop tracing and collect results.
     base::PostTaskAndReplyWithResult(
         task_runner.get(),
         FROM_HERE,
         base::Bind(
             &DebugDaemonClientImpl::CreateFileDescriptorToStopSystemTracing,
             base::Passed(&pipe_write_end)),
         base::Bind(
             &DebugDaemonClientImpl::OnCreateFileDescriptorRequestStopSystem,
             weak_ptr_factory_.GetWeakPtr(),
             callback));
     return true;
   }
 
   virtual void TestICMP(const std::string& ip_address,
-                        const TestICMPCallback& callback) OVERRIDE {
+                        const TestICMPCallback& callback) override {
     dbus::MethodCall method_call(debugd::kDebugdInterface,
                                  debugd::kTestICMP);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(ip_address);
     debugdaemon_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&DebugDaemonClientImpl::OnTestICMP,
                    weak_ptr_factory_.GetWeakPtr(),
                    callback));
   }
 
   virtual void TestICMPWithOptions(
       const std::string& ip_address,
       const std::map<std::string, std::string>& options,
-      const TestICMPCallback& callback) OVERRIDE {
+      const TestICMPCallback& callback) override {
     dbus::MethodCall method_call(debugd::kDebugdInterface,
                                  debugd::kTestICMPWithOptions);
     dbus::MessageWriter writer(&method_call);
     dbus::MessageWriter sub_writer(NULL);
     dbus::MessageWriter elem_writer(NULL);
 
     // Write the host.
     writer.AppendString(ip_address);
 
     // Write the options.
     writer.OpenArray("{ss}", &sub_writer);
     std::map<std::string, std::string>::const_iterator it;
     for (it = options.begin(); it != options.end(); ++it) {
       sub_writer.OpenDictEntry(&elem_writer);
       elem_writer.AppendString(it->first);
       elem_writer.AppendString(it->second);
       sub_writer.CloseContainer(&elem_writer);
     }
     writer.CloseContainer(&sub_writer);
 
     // Call the function.
     debugdaemon_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&DebugDaemonClientImpl::OnTestICMP,
                    weak_ptr_factory_.GetWeakPtr(),
                    callback));
   }
 
-  virtual void UploadCrashes() OVERRIDE {
+  virtual void UploadCrashes() override {
     dbus::MethodCall method_call(debugd::kDebugdInterface,
                                  debugd::kUploadCrashes);
     debugdaemon_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&DebugDaemonClientImpl::OnStartMethod,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
  protected:
-  virtual void Init(dbus::Bus* bus) OVERRIDE {
+  virtual void Init(dbus::Bus* bus) override {
     debugdaemon_proxy_ =
         bus->GetObjectProxy(debugd::kDebugdServiceName,
                             dbus::ObjectPath(debugd::kDebugdServicePath));
   }
 
  private:
   // Called when a CheckValidity response is received.
   void OnCheckValidityGetDebugLogs(bool is_compressed,
                                    dbus::FileDescriptor* file_descriptor,
                                    const GetDebugLogsCallback& callback) {
@@ skipping 228 matching lines @@
 DebugDaemonClient::EmptyStopSystemTracingCallback() {
   return base::Bind(&EmptyStopSystemTracingCallbackBody);
 }
 
 // static
 DebugDaemonClient* DebugDaemonClient::Create() {
   return new DebugDaemonClientImpl();
 }
 
 }  // namespace chromeos