Standardize usage of virtual/override/final in extensions/

extensions/renderer/api/serial/serial_api_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 "device/serial/serial_device_enumerator.h"
 #include "device/serial/serial_service_impl.h"
 #include "device/serial/test_serial_io_handler.h"
 #include "extensions/renderer/api_test_base.h"
 #include "grit/extensions_renderer_resources.h"
 
 // A test launcher for tests for the serial API defined in
 // extensions/test/data/serial_unittest.js. Each C++ test function sets up a
 // fake DeviceEnumerator or SerialIoHandler expecting or returning particular
 // values for that test.
 
 namespace extensions {
 
 namespace {
 
 class FakeSerialDeviceEnumerator : public device::SerialDeviceEnumerator {
-  virtual mojo::Array<device::serial::DeviceInfoPtr> GetDevices() override {
+  mojo::Array<device::serial::DeviceInfoPtr> GetDevices() override {
     mojo::Array<device::serial::DeviceInfoPtr> result(3);
     result[0] = device::serial::DeviceInfo::New();
     result[0]->path = "device";
     result[0]->vendor_id = 1234;
     result[0]->has_vendor_id = true;
     result[0]->product_id = 5678;
     result[0]->has_product_id = true;
     result[0]->display_name = "foo";
     result[1] = device::serial::DeviceInfo::New();
     result[1]->path = "another_device";
@@ skipping 69 matching lines @@
   return result;
 }
 
 class TestIoHandlerBase : public device::TestSerialIoHandler {
  public:
   TestIoHandlerBase() : calls_(0) {}
 
   size_t num_calls() const { return calls_; }
 
  protected:
-  virtual ~TestIoHandlerBase() {}
+  ~TestIoHandlerBase() override {}
   void record_call() const { calls_++; }
 
  private:
   mutable size_t calls_;
 
   DISALLOW_COPY_AND_ASSIGN(TestIoHandlerBase);
 };
 
 class SetControlSignalsTestIoHandler : public TestIoHandlerBase {
  public:
   SetControlSignalsTestIoHandler() {}
 
-  virtual bool SetControlSignals(
+  bool SetControlSignals(
       const device::serial::HostControlSignals& signals) override {
     static const device::serial::HostControlSignals expected_signals[] = {
         GenerateControlSignals(OPTIONAL_VALUE_UNSET, OPTIONAL_VALUE_UNSET),
         GenerateControlSignals(OPTIONAL_VALUE_FALSE, OPTIONAL_VALUE_UNSET),
         GenerateControlSignals(OPTIONAL_VALUE_TRUE, OPTIONAL_VALUE_UNSET),
         GenerateControlSignals(OPTIONAL_VALUE_UNSET, OPTIONAL_VALUE_FALSE),
         GenerateControlSignals(OPTIONAL_VALUE_FALSE, OPTIONAL_VALUE_FALSE),
         GenerateControlSignals(OPTIONAL_VALUE_TRUE, OPTIONAL_VALUE_FALSE),
         GenerateControlSignals(OPTIONAL_VALUE_UNSET, OPTIONAL_VALUE_TRUE),
         GenerateControlSignals(OPTIONAL_VALUE_FALSE, OPTIONAL_VALUE_TRUE),
         GenerateControlSignals(OPTIONAL_VALUE_TRUE, OPTIONAL_VALUE_TRUE),
     };
     if (num_calls() >= arraysize(expected_signals))
       return false;
 
     EXPECT_EQ(expected_signals[num_calls()].has_dtr, signals.has_dtr);
     EXPECT_EQ(expected_signals[num_calls()].dtr, signals.dtr);
     EXPECT_EQ(expected_signals[num_calls()].has_rts, signals.has_rts);
     EXPECT_EQ(expected_signals[num_calls()].rts, signals.rts);
     record_call();
     return true;
   }
 
  private:
-  virtual ~SetControlSignalsTestIoHandler() {}
+  ~SetControlSignalsTestIoHandler() override {}
 
   DISALLOW_COPY_AND_ASSIGN(SetControlSignalsTestIoHandler);
 };
 
 class GetControlSignalsTestIoHandler : public TestIoHandlerBase {
  public:
   GetControlSignalsTestIoHandler() {}
 
-  virtual device::serial::DeviceControlSignalsPtr GetControlSignals()
-      const override {
+  device::serial::DeviceControlSignalsPtr GetControlSignals() const override {
     device::serial::DeviceControlSignalsPtr signals(
         device::serial::DeviceControlSignals::New());
     signals->dcd = num_calls() & 1;
     signals->cts = num_calls() & 2;
     signals->ri = num_calls() & 4;
     signals->dsr = num_calls() & 8;
     record_call();
     return signals.Pass();
   }
 
  private:
-  virtual ~GetControlSignalsTestIoHandler() {}
+  ~GetControlSignalsTestIoHandler() override {}
 
   DISALLOW_COPY_AND_ASSIGN(GetControlSignalsTestIoHandler);
 };
 
 class ConfigurePortTestIoHandler : public TestIoHandlerBase {
  public:
   ConfigurePortTestIoHandler() {}
-  virtual bool ConfigurePort(
+  bool ConfigurePort(
       const device::serial::ConnectionOptions& options) override {
     static const device::serial::ConnectionOptions expected_options[] = {
         GenerateConnectionOptions(9600,
                                   device::serial::DATA_BITS_EIGHT,
                                   device::serial::PARITY_BIT_NO,
                                   device::serial::STOP_BITS_ONE,
                                   OPTIONAL_VALUE_FALSE),
         GenerateConnectionOptions(57600,
                                   device::serial::DATA_BITS_NONE,
                                   device::serial::PARITY_BIT_NONE,
@@ skipping 54 matching lines @@
     EXPECT_EQ(expected_options[num_calls()].stop_bits, options.stop_bits);
     EXPECT_EQ(expected_options[num_calls()].has_cts_flow_control,
               options.has_cts_flow_control);
     EXPECT_EQ(expected_options[num_calls()].cts_flow_control,
               options.cts_flow_control);
     record_call();
     return TestSerialIoHandler::ConfigurePort(options);
   }
 
  private:
-  virtual ~ConfigurePortTestIoHandler() {}
+  ~ConfigurePortTestIoHandler() override {}
 
   DISALLOW_COPY_AND_ASSIGN(ConfigurePortTestIoHandler);
 };
 
 class FlushTestIoHandler : public TestIoHandlerBase {
  public:
   FlushTestIoHandler() {}
 
-  virtual bool Flush() const override {
+  bool Flush() const override {
     record_call();
     return true;
   }
 
  private:
-  virtual ~FlushTestIoHandler() {}
+  ~FlushTestIoHandler() override {}
 
   DISALLOW_COPY_AND_ASSIGN(FlushTestIoHandler);
 };
 
 class FailToConnectTestIoHandler : public TestIoHandlerBase {
  public:
   FailToConnectTestIoHandler() {}
-  virtual void Open(const std::string& port,
-                    const OpenCompleteCallback& callback) override {
+  void Open(const std::string& port,
+            const OpenCompleteCallback& callback) override {
     callback.Run(false);
     return;
   }
 
  private:
-  virtual ~FailToConnectTestIoHandler() {}
+  ~FailToConnectTestIoHandler() override {}
 
   DISALLOW_COPY_AND_ASSIGN(FailToConnectTestIoHandler);
 };
 
 class FailToGetInfoTestIoHandler : public TestIoHandlerBase {
  public:
   explicit FailToGetInfoTestIoHandler(int times_to_succeed)
       : times_to_succeed_(times_to_succeed) {}
-  virtual device::serial::ConnectionInfoPtr GetPortInfo() const override {
+  device::serial::ConnectionInfoPtr GetPortInfo() const override {
     if (times_to_succeed_-- > 0)
       return device::TestSerialIoHandler::GetPortInfo();
     return device::serial::ConnectionInfoPtr();
   }
 
  private:
-  virtual ~FailToGetInfoTestIoHandler() {}
+  ~FailToGetInfoTestIoHandler() override {}
 
   mutable int times_to_succeed_;
 
   DISALLOW_COPY_AND_ASSIGN(FailToGetInfoTestIoHandler);
 };
 
 class SendErrorTestIoHandler : public TestIoHandlerBase {
  public:
   explicit SendErrorTestIoHandler(device::serial::SendError error)
       : error_(error) {}
 
-  virtual void WriteImpl() override { QueueWriteCompleted(0, error_); }
+  void WriteImpl() override { QueueWriteCompleted(0, error_); }
 
  private:
-  virtual ~SendErrorTestIoHandler() {}
+  ~SendErrorTestIoHandler() override {}
 
   device::serial::SendError error_;
 
   DISALLOW_COPY_AND_ASSIGN(SendErrorTestIoHandler);
 };
 
 class FixedDataReceiveTestIoHandler : public TestIoHandlerBase {
  public:
   explicit FixedDataReceiveTestIoHandler(const std::string& data)
       : data_(data) {}
 
-  virtual void ReadImpl() override {
+  void ReadImpl() override {
     if (pending_read_buffer_len() < data_.size())
       return;
     memcpy(pending_read_buffer(), data_.c_str(), data_.size());
     QueueReadCompleted(static_cast<uint32_t>(data_.size()),
                        device::serial::RECEIVE_ERROR_NONE);
   }
 
  private:
-  virtual ~FixedDataReceiveTestIoHandler() {}
+  ~FixedDataReceiveTestIoHandler() override {}
 
   const std::string data_;
 
   DISALLOW_COPY_AND_ASSIGN(FixedDataReceiveTestIoHandler);
 };
 
 class ReceiveErrorTestIoHandler : public TestIoHandlerBase {
  public:
   explicit ReceiveErrorTestIoHandler(device::serial::ReceiveError error)
       : error_(error) {}
 
-  virtual void ReadImpl() override { QueueReadCompleted(0, error_); }
+  void ReadImpl() override { QueueReadCompleted(0, error_); }
 
  private:
-  virtual ~ReceiveErrorTestIoHandler() {}
+  ~ReceiveErrorTestIoHandler() override {}
 
   device::serial::ReceiveError error_;
 
   DISALLOW_COPY_AND_ASSIGN(ReceiveErrorTestIoHandler);
 };
 
 class SendDataWithErrorIoHandler : public TestIoHandlerBase {
  public:
   SendDataWithErrorIoHandler() : sent_error_(false) {}
-  virtual void WriteImpl() override {
+  void WriteImpl() override {
     if (sent_error_) {
       WriteCompleted(pending_write_buffer_len(),
                      device::serial::SEND_ERROR_NONE);
       return;
     }
     sent_error_ = true;
     // We expect the JS test code to send a 4 byte buffer.
     ASSERT_LT(2u, pending_write_buffer_len());
     WriteCompleted(2, device::serial::SEND_ERROR_SYSTEM_ERROR);
   }
 
  private:
-  virtual ~SendDataWithErrorIoHandler() {}
+  ~SendDataWithErrorIoHandler() override {}
 
   bool sent_error_;
 
   DISALLOW_COPY_AND_ASSIGN(SendDataWithErrorIoHandler);
 };
 
 class BlockSendsForeverSendIoHandler : public TestIoHandlerBase {
  public:
   BlockSendsForeverSendIoHandler() {}
-  virtual void WriteImpl() override {}
+  void WriteImpl() override {}
 
  private:
-  virtual ~BlockSendsForeverSendIoHandler() {}
+  ~BlockSendsForeverSendIoHandler() override {}
 
   DISALLOW_COPY_AND_ASSIGN(BlockSendsForeverSendIoHandler);
 };
 
 }  // namespace
 
 class SerialApiTest : public ApiTestBase {
  public:
   SerialApiTest() {}
 
@@ skipping 237 matching lines @@
 
 TEST_F(SerialApiTest, SetPausedUnknownConnectionId) {
   RunTest("serial_unittest.js", "testSetPausedUnknownConnectionId");
 }
 
 TEST_F(SerialApiTest, SendUnknownConnectionId) {
   RunTest("serial_unittest.js", "testSendUnknownConnectionId");
 }
 
 }  // namespace extensions