replace OVERRIDE and FINAL with override and final in device/

device/bluetooth/bluetooth_adapter_unittest.cc

 // Copyright 2014 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 "base/memory/ref_counted.h"
 #include "device/bluetooth/bluetooth_adapter.h"
 #include "device/bluetooth/bluetooth_device.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using device::BluetoothAdapter;
 using device::BluetoothDevice;
 
 namespace device {
 
 class TestBluetoothAdapter : public BluetoothAdapter {
  public:
   TestBluetoothAdapter() {
   }
 
-  virtual void AddObserver(BluetoothAdapter::Observer* observer) OVERRIDE {
+  virtual void AddObserver(BluetoothAdapter::Observer* observer) override {
   }
 
-  virtual void RemoveObserver(BluetoothAdapter::Observer* observer) OVERRIDE {
+  virtual void RemoveObserver(BluetoothAdapter::Observer* observer) override {
 
   }
 
-  virtual std::string GetAddress() const OVERRIDE {
+  virtual std::string GetAddress() const override {
     return "";
   }
 
-  virtual std::string GetName() const OVERRIDE {
+  virtual std::string GetName() const override {
     return "";
   }
 
   virtual void SetName(const std::string& name,
                        const base::Closure& callback,
-                       const ErrorCallback& error_callback) OVERRIDE {
+                       const ErrorCallback& error_callback) override {
   }
 
-  virtual bool IsInitialized() const OVERRIDE {
+  virtual bool IsInitialized() const override {
     return false;
   }
 
-  virtual bool IsPresent() const OVERRIDE {
+  virtual bool IsPresent() const override {
     return false;
   }
 
-  virtual bool IsPowered() const OVERRIDE {
+  virtual bool IsPowered() const override {
     return false;
   }
 
   virtual void SetPowered(
       bool powered,
       const base::Closure& callback,
-      const ErrorCallback& error_callback) OVERRIDE {
+      const ErrorCallback& error_callback) override {
   }
 
-  virtual bool IsDiscoverable() const OVERRIDE {
+  virtual bool IsDiscoverable() const override {
     return false;
   }
 
   virtual void SetDiscoverable(
       bool discoverable,
       const base::Closure& callback,
-      const ErrorCallback& error_callback) OVERRIDE {
+      const ErrorCallback& error_callback) override {
   }
 
-  virtual bool IsDiscovering() const OVERRIDE {
+  virtual bool IsDiscovering() const override {
     return false;
   }
 
   virtual void StartDiscoverySession(
       const DiscoverySessionCallback& callback,
-      const ErrorCallback& error_callback) OVERRIDE {
+      const ErrorCallback& error_callback) override {
   }
 
   virtual void CreateRfcommService(
       const BluetoothUUID& uuid,
       const ServiceOptions& options,
       const CreateServiceCallback& callback,
-      const CreateServiceErrorCallback& error_callback) OVERRIDE {
+      const CreateServiceErrorCallback& error_callback) override {
   }
 
   virtual void CreateL2capService(
       const BluetoothUUID& uuid,
       const ServiceOptions& options,
       const CreateServiceCallback& callback,
-      const CreateServiceErrorCallback& error_callback) OVERRIDE {
+      const CreateServiceErrorCallback& error_callback) override {
   }
 
  protected:
   virtual ~TestBluetoothAdapter() {}
 
   virtual void AddDiscoverySession(
       const base::Closure& callback,
-      const ErrorCallback& error_callback) OVERRIDE {
+      const ErrorCallback& error_callback) override {
   }
 
   virtual void RemoveDiscoverySession(
       const base::Closure& callback,
-      const ErrorCallback& error_callback) OVERRIDE {
+      const ErrorCallback& error_callback) override {
   }
 
   virtual void RemovePairingDelegateInternal(
-      BluetoothDevice::PairingDelegate* pairing_delegate) OVERRIDE {
+      BluetoothDevice::PairingDelegate* pairing_delegate) override {
   }
 };
 
 class TestPairingDelegate : public BluetoothDevice::PairingDelegate {
   public:
-   virtual void RequestPinCode(BluetoothDevice* device) OVERRIDE {}
-   virtual void RequestPasskey(BluetoothDevice* device) OVERRIDE {}
+   virtual void RequestPinCode(BluetoothDevice* device) override {}
+   virtual void RequestPasskey(BluetoothDevice* device) override {}
    virtual void DisplayPinCode(BluetoothDevice* device,
-                               const std::string& pincode) OVERRIDE {}
+                               const std::string& pincode) override {}
    virtual void DisplayPasskey(BluetoothDevice* device,
-                               uint32 passkey) OVERRIDE {}
+                               uint32 passkey) override {}
    virtual void KeysEntered(BluetoothDevice* device,
-                            uint32 entered) OVERRIDE {}
+                            uint32 entered) override {}
    virtual void ConfirmPasskey(BluetoothDevice* device,
-                               uint32 passkey) OVERRIDE {}
-   virtual void AuthorizePairing(BluetoothDevice* device) OVERRIDE {}
+                               uint32 passkey) override {}
+   virtual void AuthorizePairing(BluetoothDevice* device) override {}
 };
 
 
 TEST(BluetoothAdapterTest, NoDefaultPairingDelegate) {
   scoped_refptr<BluetoothAdapter> adapter = new TestBluetoothAdapter();
 
   // Verify that when there is no registered pairing delegate, NULL is returned.
   EXPECT_TRUE(adapter->DefaultPairingDelegate() == NULL);
 }
 
@@ skipping 51 matching lines @@
   TestPairingDelegate delegate;
 
   adapter->AddPairingDelegate(&delegate,
                               BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_LOW);
   adapter->RemovePairingDelegate(&delegate);
 
   EXPECT_TRUE(adapter->DefaultPairingDelegate() == NULL);
 }
 
 }  // namespace device