replace OVERRIDE and FINAL with override and final in device/

device/bluetooth/bluetooth_chromeos_unittest.cc

 // Copyright 2013 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/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/fake_bluetooth_adapter_client.h"
 #include "chromeos/dbus/fake_bluetooth_agent_manager_client.h"
@@ skipping 37 matching lines @@
         last_device_(NULL),
         adapter_(adapter) {
     adapter_->AddObserver(this);
   }
 
   virtual ~TestObserver() {
     adapter_->RemoveObserver(this);
   }
 
   virtual void AdapterPresentChanged(BluetoothAdapter* adapter,
-                                     bool present) OVERRIDE {
+                                     bool present) override {
     EXPECT_EQ(adapter_.get(), adapter);
 
     ++present_changed_count_;
     last_present_ = present;
   }
 
   virtual void AdapterPoweredChanged(BluetoothAdapter* adapter,
-                                     bool powered) OVERRIDE {
+                                     bool powered) override {
     EXPECT_EQ(adapter_.get(), adapter);
 
     ++powered_changed_count_;
     last_powered_ = powered;
   }
 
   virtual void AdapterDiscoverableChanged(BluetoothAdapter* adapter,
-                                          bool discoverable) OVERRIDE {
+                                          bool discoverable) override {
     EXPECT_EQ(adapter_.get(), adapter);
 
     ++discoverable_changed_count_;
   }
 
   virtual void AdapterDiscoveringChanged(BluetoothAdapter* adapter,
-                                         bool discovering) OVERRIDE {
+                                         bool discovering) override {
     EXPECT_EQ(adapter_.get(), adapter);
 
     ++discovering_changed_count_;
     last_discovering_ = discovering;
   }
 
   virtual void DeviceAdded(BluetoothAdapter* adapter,
-                           BluetoothDevice* device) OVERRIDE {
+                           BluetoothDevice* device) override {
     EXPECT_EQ(adapter_.get(), adapter);
 
     ++device_added_count_;
     last_device_ = device;
     last_device_address_ = device->GetAddress();
 
     QuitMessageLoop();
   }
 
   virtual void DeviceChanged(BluetoothAdapter* adapter,
-                             BluetoothDevice* device) OVERRIDE {
+                             BluetoothDevice* device) override {
     EXPECT_EQ(adapter_.get(), adapter);
 
     ++device_changed_count_;
     last_device_ = device;
     last_device_address_ = device->GetAddress();
 
     QuitMessageLoop();
   }
 
   virtual void DeviceRemoved(BluetoothAdapter* adapter,
-                             BluetoothDevice* device) OVERRIDE {
+                             BluetoothDevice* device) override {
     EXPECT_EQ(adapter_.get(), adapter);
 
     ++device_removed_count_;
     // Can't save device, it may be freed
     last_device_address_ = device->GetAddress();
 
     QuitMessageLoop();
   }
 
   int present_changed_count_;
@@ skipping 31 matching lines @@
         request_passkey_count_(0),
         display_pincode_count_(0),
         display_passkey_count_(0),
         keys_entered_count_(0),
         confirm_passkey_count_(0),
         authorize_pairing_count_(0),
         last_passkey_(9999999U),
         last_entered_(999U) {}
   virtual ~TestPairingDelegate() {}
 
-  virtual void RequestPinCode(BluetoothDevice* device) OVERRIDE {
+  virtual void RequestPinCode(BluetoothDevice* device) override {
     ++call_count_;
     ++request_pincode_count_;
     QuitMessageLoop();
   }
 
-  virtual void RequestPasskey(BluetoothDevice* device) OVERRIDE {
+  virtual void RequestPasskey(BluetoothDevice* device) override {
     ++call_count_;
     ++request_passkey_count_;
     QuitMessageLoop();
   }
 
   virtual void DisplayPinCode(BluetoothDevice* device,
-                              const std::string& pincode) OVERRIDE {
+                              const std::string& pincode) override {
     ++call_count_;
     ++display_pincode_count_;
     last_pincode_ = pincode;
     QuitMessageLoop();
   }
 
   virtual void DisplayPasskey(BluetoothDevice* device,
-                              uint32 passkey) OVERRIDE {
+                              uint32 passkey) override {
     ++call_count_;
     ++display_passkey_count_;
     last_passkey_ = passkey;
     QuitMessageLoop();
   }
 
-  virtual void KeysEntered(BluetoothDevice* device, uint32 entered) OVERRIDE {
+  virtual void KeysEntered(BluetoothDevice* device, uint32 entered) override {
     ++call_count_;
     ++keys_entered_count_;
     last_entered_ = entered;
     QuitMessageLoop();
   }
 
   virtual void ConfirmPasskey(BluetoothDevice* device,
-                              uint32 passkey) OVERRIDE {
+                              uint32 passkey) override {
     ++call_count_;
     ++confirm_passkey_count_;
     last_passkey_ = passkey;
     QuitMessageLoop();
   }
 
-  virtual void AuthorizePairing(BluetoothDevice* device) OVERRIDE {
+  virtual void AuthorizePairing(BluetoothDevice* device) override {
     ++call_count_;
     ++authorize_pairing_count_;
     QuitMessageLoop();
   }
 
   int call_count_;
   int request_pincode_count_;
   int request_passkey_count_;
   int display_pincode_count_;
   int display_passkey_count_;
@@ skipping 2959 matching lines @@
   // Unknown vendor specification identifier.
   properties->modalias.ReplaceValue("chrome:v00E0p2400d0400");
 
   EXPECT_EQ(BluetoothDevice::VENDOR_ID_UNKNOWN, device->GetVendorIDSource());
   EXPECT_EQ(0, device->GetVendorID());
   EXPECT_EQ(0, device->GetProductID());
   EXPECT_EQ(0, device->GetDeviceID());
 }
 
 }  // namespace chromeos