Remove redundant virtual keywords

According to google coding style, should not use
both virtual and override.

Change-Id: Ic0074184542d8604c6645f0e8567bd44804ab795
Signed-off-by: Bin Chen <pierr.chen@gmail.com>

2 files changed, 93 insertions, 93 deletions

diff --git a/daemon/peripheral_manager.h b/daemon/peripheral_manager.h
index 2c97a56..8b5568f 100644
--- a/daemon/peripheral_manager.h
+++ b/daemon/peripheral_manager.h
@@ -42,7 +42,7 @@ class PeripheralManager : public BnPeripheralManager,
   Status GetClient(const sp<IBinder>& lifeline,
                    sp<os::IPeripheralManagerClient>* _aidl_return);
 
-  virtual void binderDied(const wp<IBinder>& who) override;
+  void binderDied(const wp<IBinder>& who) override;
 
  private:
   bool InitHal();
diff --git a/daemon/peripheral_manager_client.h b/daemon/peripheral_manager_client.h
index bdba9ef..ee9abe4 100644
--- a/daemon/peripheral_manager_client.h
+++ b/daemon/peripheral_manager_client.h
@@ -42,145 +42,145 @@ class PeripheralManagerClient : public BnPeripheralManagerClient {
   ~PeripheralManagerClient();
 
   // Gpio functions.
-  virtual Status ListGpio(std::vector<std::string>* gpios) override;
+  Status ListGpio(std::vector<std::string>* gpios) override;
 
-  virtual Status OpenGpio(const std::string& name) override;
+  Status OpenGpio(const std::string& name) override;
 
-  virtual Status ReleaseGpio(const std::string& name) override;
+  Status ReleaseGpio(const std::string& name) override;
 
-  virtual Status SetGpioEdge(const std::string& name, int type) override;
+  Status SetGpioEdge(const std::string& name, int type) override;
 
-  virtual Status SetGpioActiveType(const std::string& name, int type) override;
+  Status SetGpioActiveType(const std::string& name, int type) override;
 
-  virtual Status SetGpioDirection(const std::string& name,
-                                  int direction) override;
+  Status SetGpioDirection(const std::string& name,
+                          int direction) override;
 
-  virtual Status SetGpioValue(const std::string& name, bool value) override;
+  Status SetGpioValue(const std::string& name, bool value) override;
 
-  virtual Status GetGpioValue(const std::string& name, bool* value) override;
+  Status GetGpioValue(const std::string& name, bool* value) override;
 
-  virtual Status GetGpioPollingFd(const std::string& name,
-                                  ::android::base::unique_fd* fd) override;
+  Status GetGpioPollingFd(const std::string& name,
+                          ::android::base::unique_fd* fd) override;
 
   // Spi functions.
-  virtual Status ListSpiBuses(std::vector<std::string>* buses) override;
+  Status ListSpiBuses(std::vector<std::string>* buses) override;
 
-  virtual Status OpenSpiDevice(const std::string& name) override;
+  Status OpenSpiDevice(const std::string& name) override;
 
-  virtual Status ReleaseSpiDevice(const std::string& name) override;
+  Status ReleaseSpiDevice(const std::string& name) override;
 
-  virtual Status SpiDeviceWriteByte(const std::string& name,
-                                    int8_t byte) override;
+  Status SpiDeviceWriteByte(const std::string& name,
+                            int8_t byte) override;
 
-  virtual Status SpiDeviceWriteBuffer(
+  Status SpiDeviceWriteBuffer(
       const std::string& name,
       const std::vector<uint8_t>& buffer) override;
 
-  virtual Status SpiDeviceTransfer(
+  Status SpiDeviceTransfer(
       const std::string& name,
       const std::unique_ptr<std::vector<uint8_t>>& tx_data,
       std::unique_ptr<std::vector<uint8_t>>* rx_data,
       int len) override;
 
-  virtual Status SpiDeviceSetMode(const std::string& name, int mode) override;
+  Status SpiDeviceSetMode(const std::string& name, int mode) override;
 
-  virtual Status SpiDeviceSetFrequency(const std::string& name,
-                                       int frequency_hz) override;
+  Status SpiDeviceSetFrequency(const std::string& name,
+                               int frequency_hz) override;
 
-  virtual Status SpiDeviceSetBitJustification(const std::string& name,
-                                              bool lsb_first) override;
+  Status SpiDeviceSetBitJustification(const std::string& name,
+                                      bool lsb_first) override;
 
-  virtual Status SpiDeviceSetBitsPerWord(const std::string& name,
-                                         int nbits) override;
+  Status SpiDeviceSetBitsPerWord(const std::string& name,
+                                 int nbits) override;
 
-  virtual Status SpiDeviceSetDelay(const std::string& name,
-                                   int delay_usecs) override;
+  Status SpiDeviceSetDelay(const std::string& name,
+                           int delay_usecs) override;
 
   // Led functions.
-  virtual Status ListLeds(std::vector<std::string>* leds) override;
+  Status ListLeds(std::vector<std::string>* leds) override;
 
-  virtual Status OpenLed(const std::string& name) override;
+  Status OpenLed(const std::string& name) override;
 
-  virtual Status ReleaseLed(const std::string& name) override;
+  Status ReleaseLed(const std::string& name) override;
 
-  virtual Status LedGetBrightness(const std::string& name,
-                                  int* brightness) override;
-  virtual Status LedGetMaxBrightness(const std::string& name,
-                                     int* max_brightness) override;
-  virtual Status LedSetBrightness(const std::string& name,
-                                  int brightness) override;
+  Status LedGetBrightness(const std::string& name,
+                          int* brightness) override;
+  Status LedGetMaxBrightness(const std::string& name,
+                             int* max_brightness) override;
+  Status LedSetBrightness(const std::string& name,
+                          int brightness) override;
 
   // I2c functions.
-  virtual Status ListI2cBuses(std::vector<std::string>* buses) override;
+  Status ListI2cBuses(std::vector<std::string>* buses) override;
 
-  virtual Status OpenI2cDevice(const std::string& name,
-                               int32_t address) override;
+  Status OpenI2cDevice(const std::string& name,
+                       int32_t address) override;
 
-  virtual Status ReleaseI2cDevice(const std::string& name,
-                                  int32_t address) override;
+  Status ReleaseI2cDevice(const std::string& name,
+                          int32_t address) override;
 
-  virtual Status I2cRead(const std::string& name,
-                         int32_t address,
-                         std::vector<uint8_t>* data,
-                         int32_t size,
-                         int32_t* bytes_read) override;
-
-  virtual Status I2cReadRegByte(const std::string& name,
-                                int32_t address,
-                                int32_t reg,
-                                int32_t* val) override;
-
-  virtual Status I2cReadRegWord(const std::string& name,
-                                int32_t address,
-                                int32_t reg,
-                                int32_t* val) override;
-
-  virtual Status I2cReadRegBuffer(const std::string& name,
-                                  int32_t address,
-                                  int32_t reg,
-                                  std::vector<uint8_t>* data,
-                                  int32_t size,
-                                  int32_t* bytes_read) override;
-
-  virtual Status I2cWrite(const std::string& name,
+  Status I2cRead(const std::string& name,
+                 int32_t address,
+                 std::vector<uint8_t>* data,
+                 int32_t size,
+                 int32_t* bytes_read) override;
+
+  Status I2cReadRegByte(const std::string& name,
+                        int32_t address,
+                        int32_t reg,
+                        int32_t* val) override;
+
+  Status I2cReadRegWord(const std::string& name,
+                        int32_t address,
+                        int32_t reg,
+                        int32_t* val) override;
+
+  Status I2cReadRegBuffer(const std::string& name,
                           int32_t address,
-                          const std::vector<uint8_t>& data,
-                          int32_t* bytes_written) override;
+                          int32_t reg,
+                          std::vector<uint8_t>* data,
+                          int32_t size,
+                          int32_t* bytes_read) override;
 
-  virtual Status I2cWriteRegByte(const std::string& name,
-                                 int32_t address,
-                                 int32_t reg,
-                                 int8_t val) override;
+  Status I2cWrite(const std::string& name,
+                  int32_t address,
+                  const std::vector<uint8_t>& data,
+                  int32_t* bytes_written) override;
 
-  virtual Status I2cWriteRegWord(const std::string& name,
-                                 int32_t address,
-                                 int32_t reg,
-                                 int32_t val) override;
+  Status I2cWriteRegByte(const std::string& name,
+                         int32_t address,
+                         int32_t reg,
+                         int8_t val) override;
+
+  Status I2cWriteRegWord(const std::string& name,
+                         int32_t address,
+                         int32_t reg,
+                         int32_t val) override;
 
-  virtual Status I2cWriteRegBuffer(const std::string& name,
-                                   int32_t address,
-                                   int32_t reg,
-                                   const std::vector<uint8_t>& data,
-                                   int32_t* bytes_written) override;
+  Status I2cWriteRegBuffer(const std::string& name,
+                           int32_t address,
+                           int32_t reg,
+                           const std::vector<uint8_t>& data,
+                           int32_t* bytes_written) override;
 
   // Uart functions.
-  virtual Status ListUartDevices(std::vector<std::string>* devices) override;
+  Status ListUartDevices(std::vector<std::string>* devices) override;
 
-  virtual Status OpenUartDevice(const std::string& name) override;
+  Status OpenUartDevice(const std::string& name) override;
 
-  virtual Status ReleaseUartDevice(const std::string& name) override;
+  Status ReleaseUartDevice(const std::string& name) override;
 
-  virtual Status SetUartDeviceBaudrate(const std::string& name,
-                                       int32_t baudrate) override;
+  Status SetUartDeviceBaudrate(const std::string& name,
+                               int32_t baudrate) override;
 
-  virtual Status UartDeviceWrite(const std::string& name,
-                                 const std::vector<uint8_t>& data,
-                                 int* bytes_written) override;
+  Status UartDeviceWrite(const std::string& name,
+                         const std::vector<uint8_t>& data,
+                         int* bytes_written) override;
 
-  virtual Status UartDeviceRead(const std::string& name,
-                                std::vector<uint8_t>* data,
-                                int size,
-                                int* bytes_read) override;
+  Status UartDeviceRead(const std::string& name,
+                        std::vector<uint8_t>* data,
+                        int size,
+                        int* bytes_read) override;
 
  private:
   std::map<std::string, std::unique_ptr<GpioPin>> gpios_;