Standardize usage of virtual/override/final in content/browser/

content/browser/renderer_host/media/webrtc_identity_service_host_unittest.cc

 // Copyright 2013 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 <deque>
 
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/media/webrtc_identity_store.h"
 #include "content/browser/renderer_host/media/webrtc_identity_service_host.h"
 #include "content/common/media/webrtc_identity_messages.h"
@@ skipping 11 matching lines @@
 const char FAKE_COMMON_NAME[] = "fake common name";
 const char FAKE_CERTIFICATE[] = "fake cert";
 const char FAKE_PRIVATE_KEY[] = "fake private key";
 const int FAKE_RENDERER_ID = 10;
 const int FAKE_SEQUENCE_NUMBER = 1;
 
 class MockWebRTCIdentityStore : public WebRTCIdentityStore {
  public:
   MockWebRTCIdentityStore() : WebRTCIdentityStore(base::FilePath(), NULL) {}
 
-  virtual base::Closure RequestIdentity(
-      const GURL& origin,
-      const std::string& identity_name,
-      const std::string& common_name,
-      const CompletionCallback& callback) override {
+  base::Closure RequestIdentity(const GURL& origin,
+                                const std::string& identity_name,
+                                const std::string& common_name,
+                                const CompletionCallback& callback) override {
     EXPECT_TRUE(callback_.is_null());
 
     callback_ = callback;
     return base::Bind(&MockWebRTCIdentityStore::OnCancel,
                       base::Unretained(this));
   }
 
   bool HasPendingRequest() const { return !callback_.is_null(); }
 
   void RunCompletionCallback(int error,
                              const std::string& cert,
                              const std::string& key) {
     callback_.Run(error, cert, key);
     callback_.Reset();
   }
 
  private:
-  virtual ~MockWebRTCIdentityStore() {}
+  ~MockWebRTCIdentityStore() override {}
 
   void OnCancel() { callback_.Reset(); }
 
   CompletionCallback callback_;
 };
 
 class WebRTCIdentityServiceHostForTest : public WebRTCIdentityServiceHost {
  public:
   explicit WebRTCIdentityServiceHostForTest(WebRTCIdentityStore* identity_store)
       : WebRTCIdentityServiceHost(FAKE_RENDERER_ID, identity_store) {
     ChildProcessSecurityPolicyImpl* policy =
         ChildProcessSecurityPolicyImpl::GetInstance();
     policy->Add(FAKE_RENDERER_ID);
   }
 
-  virtual bool Send(IPC::Message* message) override {
+  bool Send(IPC::Message* message) override {
     messages_.push_back(*message);
     delete message;
     return true;
   }
 
-  virtual bool OnMessageReceived(const IPC::Message& message) override {
+  bool OnMessageReceived(const IPC::Message& message) override {
     return WebRTCIdentityServiceHost::OnMessageReceived(message);
   }
 
   IPC::Message GetLastMessage() { return messages_.back(); }
 
   int GetNumberOfMessages() { return messages_.size(); }
 
   void ClearMessages() { messages_.clear(); }
 
  private:
-  virtual ~WebRTCIdentityServiceHostForTest() {
+  ~WebRTCIdentityServiceHostForTest() override {
     ChildProcessSecurityPolicyImpl* policy =
         ChildProcessSecurityPolicyImpl::GetInstance();
     policy->Remove(FAKE_RENDERER_ID);
   }
 
   std::deque<IPC::Message> messages_;
 };
 
 class WebRTCIdentityServiceHostTest : public ::testing::Test {
  public:
@@ skipping 84 matching lines @@
 }
 
 // Verifies that we do not crash if we try to cancel a completed request.
 TEST_F(WebRTCIdentityServiceHostTest, TestCancelAfterRequestCompleted) {
   SendRequestToHost();
   store_->RunCompletionCallback(net::OK, FAKE_CERTIFICATE, FAKE_PRIVATE_KEY);
   SendCancelRequestToHost();
 }
 
 }  // namespace content