Update {virtual,override} to follow C++11 style in components.

components/proximity_auth/bluetooth_connection_finder_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 "components/proximity_auth/bluetooth_connection_finder.h"
 
 #include "base/bind.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 17 matching lines @@
 
 const char kDeviceName[] = "Device name";
 const char kBluetoothAddress[] = "11:22:33:44:55:66";
 const RemoteDevice kRemoteDevice = {kDeviceName, kBluetoothAddress};
 
 const char kUuid[] = "DEADBEEF-CAFE-FEED-FOOD-D15EA5EBEEF";
 
 class MockConnection : public Connection {
  public:
   MockConnection() : Connection(kRemoteDevice) {}
-  virtual ~MockConnection() {}
+  ~MockConnection() override {}
 
   MOCK_METHOD0(Connect, void());
 
   using Connection::SetStatus;
 
  private:
-  void Disconnect() {}
-  void SendMessageImpl(scoped_ptr<WireMessage> message) {}
+  void Disconnect() override {}
+  void SendMessageImpl(scoped_ptr<WireMessage> message) override {}
 
   DISALLOW_COPY_AND_ASSIGN(MockConnection);
 };
 
 class MockBluetoothConnectionFinder : public BluetoothConnectionFinder {
  public:
   MockBluetoothConnectionFinder()
       : BluetoothConnectionFinder(kRemoteDevice,
                                   device::BluetoothUUID(kUuid),
                                   base::TimeDelta()) {}
-  virtual ~MockBluetoothConnectionFinder() {}
+  ~MockBluetoothConnectionFinder() override {}
 
   MOCK_METHOD0(CreateConnectionProxy, Connection*());
 
   // Creates a mock connection and sets an expectation that the mock connection
   // finder's CreateConnection() method will be called and will return the
   // created connection. Returns a reference to the created connection.
   // NOTE: The returned connection's lifetime is managed by the connection
   // finder.
   MockConnection* ExpectCreateConnection() {
     scoped_ptr<MockConnection> connection(new NiceMock<MockConnection>());
     MockConnection* connection_alias = connection.get();
     EXPECT_CALL(*this, CreateConnectionProxy())
         .WillOnce(Return(connection.release()));
     return connection_alias;
   }
 
   using BluetoothConnectionFinder::AdapterPresentChanged;
   using BluetoothConnectionFinder::AdapterPoweredChanged;
 
  protected:
-  virtual scoped_ptr<Connection> CreateConnection() override {
+  scoped_ptr<Connection> CreateConnection() override {
     return make_scoped_ptr(CreateConnectionProxy());
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockBluetoothConnectionFinder);
 };
 
 }  // namespace
 
 class ProximityAuthBluetoothConnectionFinderTest : public testing::Test {
@@ skipping 179 matching lines @@
   run_loop.RunUntilIdle();
   ON_CALL(*adapter_, IsPresent()).WillByDefault(Return(true));
 
   // Now that there is no pending task, events should once again trigger new
   // polling iterations.
   connection_finder.ExpectCreateConnection();
   connection_finder.AdapterPresentChanged(adapter_.get(), true);
 }
 
 }  // namespace proximity_auth