replace OVERRIDE and FINAL with override and 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 {
+  virtual 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 83 matching lines @@
   mutable size_t calls_;
 
   DISALLOW_COPY_AND_ASSIGN(TestIoHandlerBase);
 };
 
 class SetControlSignalsTestIoHandler : public TestIoHandlerBase {
  public:
   SetControlSignalsTestIoHandler() {}
 
   virtual bool SetControlSignals(
-      const device::serial::HostControlSignals& signals) OVERRIDE {
+      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),
@@ skipping 13 matching lines @@
   virtual ~SetControlSignalsTestIoHandler() {}
 
   DISALLOW_COPY_AND_ASSIGN(SetControlSignalsTestIoHandler);
 };
 
 class GetControlSignalsTestIoHandler : public TestIoHandlerBase {
  public:
   GetControlSignalsTestIoHandler() {}
 
   virtual device::serial::DeviceControlSignalsPtr GetControlSignals()
-      const OVERRIDE {
+      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() {}
 
   DISALLOW_COPY_AND_ASSIGN(GetControlSignalsTestIoHandler);
 };
 
 class ConfigurePortTestIoHandler : public TestIoHandlerBase {
  public:
   ConfigurePortTestIoHandler() {}
   virtual bool ConfigurePort(
-      const device::serial::ConnectionOptions& options) OVERRIDE {
+      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,
                                   device::serial::STOP_BITS_NONE,
@@ skipping 62 matching lines @@
  private:
   virtual ~ConfigurePortTestIoHandler() {}
 
   DISALLOW_COPY_AND_ASSIGN(ConfigurePortTestIoHandler);
 };
 
 class FlushTestIoHandler : public TestIoHandlerBase {
  public:
   FlushTestIoHandler() {}
 
-  virtual bool Flush() const OVERRIDE {
+  virtual bool Flush() const override {
     record_call();
     return true;
   }
 
  private:
   virtual ~FlushTestIoHandler() {}
 
   DISALLOW_COPY_AND_ASSIGN(FlushTestIoHandler);
 };
 
 class FailToConnectTestIoHandler : public TestIoHandlerBase {
  public:
   FailToConnectTestIoHandler() {}
   virtual void Open(const std::string& port,
-                    const OpenCompleteCallback& callback) OVERRIDE {
+                    const OpenCompleteCallback& callback) override {
     callback.Run(false);
     return;
   }
 
  private:
   virtual ~FailToConnectTestIoHandler() {}
 
   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 {
+  virtual device::serial::ConnectionInfoPtr GetPortInfo() const override {
     if (times_to_succeed_-- > 0)
       return device::TestSerialIoHandler::GetPortInfo();
     return device::serial::ConnectionInfoPtr();
   }
 
  private:
   virtual ~FailToGetInfoTestIoHandler() {}
 
   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_); }
+  virtual void WriteImpl() override { QueueWriteCompleted(0, error_); }
 
  private:
   virtual ~SendErrorTestIoHandler() {}
 
   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 {
+  virtual 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() {}
 
   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_); }
+  virtual void ReadImpl() override { QueueReadCompleted(0, error_); }
 
  private:
   virtual ~ReceiveErrorTestIoHandler() {}
 
   device::serial::ReceiveError error_;
 
   DISALLOW_COPY_AND_ASSIGN(ReceiveErrorTestIoHandler);
 };
 
 class SendDataWithErrorIoHandler : public TestIoHandlerBase {
  public:
   SendDataWithErrorIoHandler() : sent_error_(false) {}
-  virtual void WriteImpl() OVERRIDE {
+  virtual 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() {}
 
   bool sent_error_;
 
   DISALLOW_COPY_AND_ASSIGN(SendDataWithErrorIoHandler);
 };
 
 class BlockSendsForeverSendIoHandler : public TestIoHandlerBase {
  public:
   BlockSendsForeverSendIoHandler() {}
-  virtual void WriteImpl() OVERRIDE {}
+  virtual void WriteImpl() override {}
 
  private:
   virtual ~BlockSendsForeverSendIoHandler() {}
 
   DISALLOW_COPY_AND_ASSIGN(BlockSendsForeverSendIoHandler);
 };
 
 }  // namespace
 
 class SerialApiTest : public ApiTestBase {
  public:
   SerialApiTest() {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     ApiTestBase::SetUp();
     env()->RegisterModule("async_waiter", IDR_ASYNC_WAITER_JS);
     env()->RegisterModule("data_receiver", IDR_DATA_RECEIVER_JS);
     env()->RegisterModule("data_sender", IDR_DATA_SENDER_JS);
     env()->RegisterModule("serial", IDR_SERIAL_CUSTOM_BINDINGS_JS);
     env()->RegisterModule("serial_service", IDR_SERIAL_SERVICE_JS);
     env()->RegisterModule("device/serial/data_stream.mojom",
                           IDR_DATA_STREAM_MOJOM_JS);
     env()->RegisterModule("device/serial/data_stream_serialization.mojom",
                           IDR_DATA_STREAM_SERIALIZATION_MOJOM_JS);
@@ skipping 201 matching lines @@
 
 TEST_F(SerialApiTest, SetPausedUnknownConnectionId) {
   RunTest("serial_unittest.js", "testSetPausedUnknownConnectionId");
 }
 
 TEST_F(SerialApiTest, SendUnknownConnectionId) {
   RunTest("serial_unittest.js", "testSendUnknownConnectionId");
 }
 
 }  // namespace extensions