Standardize usage of virtual/override/final in components/

components/proximity_auth/client_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/client.h"
 
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "components/proximity_auth/client_observer.h"
 #include "components/proximity_auth/connection.h"
@@ skipping 44 matching lines @@
     return decoded_message;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockSecureContext);
 };
 
 class FakeConnection : public Connection {
  public:
   FakeConnection() : Connection(RemoteDevice()) { Connect(); }
-  virtual ~FakeConnection() { Disconnect(); }
+  ~FakeConnection() override { Disconnect(); }
 
-  virtual void Connect() override { SetStatus(CONNECTED); }
+  void Connect() override { SetStatus(CONNECTED); }
 
-  virtual void Disconnect() override { SetStatus(DISCONNECTED); }
+  void Disconnect() override { SetStatus(DISCONNECTED); }
 
-  virtual void SendMessageImpl(scoped_ptr<WireMessage> message) override {
+  void SendMessageImpl(scoped_ptr<WireMessage> message) override {
     ASSERT_FALSE(current_message_);
     current_message_ = message.Pass();
   }
 
   // Completes the current send operation with success |success|.
   void FinishSendingMessageWithSuccess(bool success) {
     ASSERT_TRUE(current_message_);
     // Capture a copy of the message, as OnDidSendMessage() might reentrantly
     // call SendMessage().
     scoped_ptr<WireMessage> sent_message = current_message_.Pass();
     OnDidSendMessage(*sent_message, success);
   }
 
   // Simulates receiving a wire message with the given |payload|.
   void ReceiveMessageWithPayload(const std::string& payload) {
     pending_payload_ = payload;
     OnBytesReceived(std::string());
     pending_payload_.clear();
   }
 
   // Returns a message containing the payload set via
   // ReceiveMessageWithPayload().
-  virtual scoped_ptr<WireMessage> DeserializeWireMessage(
+  scoped_ptr<WireMessage> DeserializeWireMessage(
       bool* is_incomplete_message) override {
     *is_incomplete_message = false;
     return make_scoped_ptr(new WireMessage(std::string(), pending_payload_));
   }
 
   WireMessage* current_message() { return current_message_.get(); }
 
  private:
   // The message currently being sent. Only set between a call to
   // SendMessageImpl() and FinishSendingMessageWithSuccess().
@@ skipping 30 matching lines @@
   Client* const client_;
 
   DISALLOW_COPY_AND_ASSIGN(MockClientObserver);
 };
 
 class TestClient : public Client {
  public:
   TestClient()
       : Client(make_scoped_ptr(new NiceMock<FakeConnection>()),
                make_scoped_ptr(new NiceMock<MockSecureContext>())) {}
-  virtual ~TestClient() {}
+  ~TestClient() override {}
 
   // Simple getters for the mock objects owned by |this| client.
   FakeConnection* GetFakeConnection() {
     return static_cast<FakeConnection*>(connection());
   }
   MockSecureContext* GetMockSecureContext() {
     return static_cast<MockSecureContext*>(secure_context());
   }
 
  private:
@@ skipping 348 matching lines @@
       "\"data\":\"YSB3aW5uZXIgaXMgeW91\""
       "}, but encoded");
 
   // The unlock request should have remained buffered, and should only now be
   // sent.
   EXPECT_CALL(observer, OnUnlockResponse(false));
   client.GetFakeConnection()->FinishSendingMessageWithSuccess(false);
 }
 
 }  // namespace proximity_auth