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

content/renderer/media/webrtc/peer_connection_dependency_factory.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 "content/renderer/media/webrtc/peer_connection_dependency_factory.h"
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 105 matching lines @@
  public:
   P2PPortAllocatorFactory(
       P2PSocketDispatcher* socket_dispatcher,
       rtc::NetworkManager* network_manager,
       rtc::PacketSocketFactory* socket_factory)
       : socket_dispatcher_(socket_dispatcher),
         network_manager_(network_manager),
         socket_factory_(socket_factory) {
   }
 
-  virtual cricket::PortAllocator* CreatePortAllocator(
+  cricket::PortAllocator* CreatePortAllocator(
       const std::vector<StunConfiguration>& stun_servers,
       const std::vector<TurnConfiguration>& turn_configurations) override {
     P2PPortAllocator::Config config;
     for (size_t i = 0; i < stun_servers.size(); ++i) {
       config.stun_servers.insert(rtc::SocketAddress(
           stun_servers[i].server.hostname(),
           stun_servers[i].server.port()));
     }
     for (size_t i = 0; i < turn_configurations.size(); ++i) {
       P2PPortAllocator::Config::RelayServerConfig relay_config;
       relay_config.server_address = turn_configurations[i].server.hostname();
       relay_config.port = turn_configurations[i].server.port();
       relay_config.username = turn_configurations[i].username;
       relay_config.password = turn_configurations[i].password;
       relay_config.transport_type = turn_configurations[i].transport_type;
       relay_config.secure = turn_configurations[i].secure;
       config.relays.push_back(relay_config);
 
       // Use turn servers as stun servers.
       config.stun_servers.insert(rtc::SocketAddress(
           turn_configurations[i].server.hostname(),
           turn_configurations[i].server.port()));
     }
 
     return new P2PPortAllocator(
         socket_dispatcher_.get(), network_manager_, socket_factory_, config);
   }
 
  protected:
-  virtual ~P2PPortAllocatorFactory() {}
+  ~P2PPortAllocatorFactory() override {}
 
  private:
   scoped_refptr<P2PSocketDispatcher> socket_dispatcher_;
   // |network_manager_| and |socket_factory_| are a weak references, owned by
   // PeerConnectionDependencyFactory.
   rtc::NetworkManager* network_manager_;
   rtc::PacketSocketFactory* socket_factory_;
 };
 
 PeerConnectionDependencyFactory::PeerConnectionDependencyFactory(
@@ skipping 482 matching lines @@
 }
 
 void PeerConnectionDependencyFactory::EnsureWebRtcAudioDeviceImpl() {
   if (audio_device_.get())
     return;
 
   audio_device_ = new WebRtcAudioDeviceImpl();
 }
 
 }  // namespace content