Replace OVERRIDE and FINAL with override and final in content/shell/[a-s]*

content/shell/renderer/test_runner/mock_webrtc_peer_connection_handler.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/shell/renderer/test_runner/mock_webrtc_peer_connection_handler.h"
 
 #include "content/shell/renderer/test_runner/mock_constraints.h"
 #include "content/shell/renderer/test_runner/mock_webrtc_data_channel_handler.h"
 #include "content/shell/renderer/test_runner/mock_webrtc_dtmf_sender_handler.h"
 #include "content/shell/renderer/test_runner/test_interfaces.h"
@@ skipping 16 matching lines @@
     : public WebMethodTask<MockWebRTCPeerConnectionHandler> {
  public:
   RTCSessionDescriptionRequestSuccededTask(
       MockWebRTCPeerConnectionHandler* object,
       const WebRTCSessionDescriptionRequest& request,
       const WebRTCSessionDescription& result)
       : WebMethodTask<MockWebRTCPeerConnectionHandler>(object),
         request_(request),
         result_(result) {}
 
-  virtual void RunIfValid() OVERRIDE { request_.requestSucceeded(result_); }
+  virtual void RunIfValid() override { request_.requestSucceeded(result_); }
 
  private:
   WebRTCSessionDescriptionRequest request_;
   WebRTCSessionDescription result_;
 };
 
 class RTCSessionDescriptionRequestFailedTask
     : public WebMethodTask<MockWebRTCPeerConnectionHandler> {
  public:
   RTCSessionDescriptionRequestFailedTask(
       MockWebRTCPeerConnectionHandler* object,
       const WebRTCSessionDescriptionRequest& request)
       : WebMethodTask<MockWebRTCPeerConnectionHandler>(object),
         request_(request) {}
 
-  virtual void RunIfValid() OVERRIDE { request_.requestFailed("TEST_ERROR"); }
+  virtual void RunIfValid() override { request_.requestFailed("TEST_ERROR"); }
 
  private:
   WebRTCSessionDescriptionRequest request_;
 };
 
 class RTCStatsRequestSucceededTask
     : public WebMethodTask<MockWebRTCPeerConnectionHandler> {
  public:
   RTCStatsRequestSucceededTask(MockWebRTCPeerConnectionHandler* object,
                                const blink::WebRTCStatsRequest& request,
                                const blink::WebRTCStatsResponse& response)
       : WebMethodTask<MockWebRTCPeerConnectionHandler>(object),
         request_(request),
         response_(response) {}
 
-  virtual void RunIfValid() OVERRIDE { request_.requestSucceeded(response_); }
+  virtual void RunIfValid() override { request_.requestSucceeded(response_); }
 
  private:
   blink::WebRTCStatsRequest request_;
   blink::WebRTCStatsResponse response_;
 };
 
 class RTCVoidRequestTask
     : public WebMethodTask<MockWebRTCPeerConnectionHandler> {
  public:
   RTCVoidRequestTask(MockWebRTCPeerConnectionHandler* object,
                      const WebRTCVoidRequest& request,
                      bool succeeded)
       : WebMethodTask<MockWebRTCPeerConnectionHandler>(object),
         request_(request),
         succeeded_(succeeded) {}
 
-  virtual void RunIfValid() OVERRIDE {
+  virtual void RunIfValid() override {
     if (succeeded_)
       request_.requestSucceeded();
     else
       request_.requestFailed("TEST_ERROR");
   }
 
  private:
   WebRTCVoidRequest request_;
   bool succeeded_;
 };
 
 class RTCPeerConnectionStateTask
     : public WebMethodTask<MockWebRTCPeerConnectionHandler> {
  public:
   RTCPeerConnectionStateTask(
       MockWebRTCPeerConnectionHandler* object,
       WebRTCPeerConnectionHandlerClient* client,
       WebRTCPeerConnectionHandlerClient::ICEConnectionState connection_state,
       WebRTCPeerConnectionHandlerClient::ICEGatheringState gathering_state)
       : WebMethodTask<MockWebRTCPeerConnectionHandler>(object),
         client_(client),
         connection_state_(connection_state),
         gathering_state_(gathering_state) {}
 
-  virtual void RunIfValid() OVERRIDE {
+  virtual void RunIfValid() override {
     client_->didChangeICEGatheringState(gathering_state_);
     client_->didChangeICEConnectionState(connection_state_);
   }
 
  private:
   WebRTCPeerConnectionHandlerClient* client_;
   WebRTCPeerConnectionHandlerClient::ICEConnectionState connection_state_;
   WebRTCPeerConnectionHandlerClient::ICEGatheringState gathering_state_;
 };
 
 class RemoteDataChannelTask
     : public WebMethodTask<MockWebRTCPeerConnectionHandler> {
  public:
   RemoteDataChannelTask(MockWebRTCPeerConnectionHandler* object,
                         WebRTCPeerConnectionHandlerClient* client,
                         WebTestDelegate* delegate)
       : WebMethodTask<MockWebRTCPeerConnectionHandler>(object),
         client_(client),
         delegate_(delegate) {}
 
-  virtual void RunIfValid() OVERRIDE {
+  virtual void RunIfValid() override {
     WebRTCDataChannelInit init;
     WebRTCDataChannelHandler* remote_data_channel =
         new MockWebRTCDataChannelHandler(
             "MockRemoteDataChannel", init, delegate_);
     client_->didAddRemoteDataChannel(remote_data_channel);
   }
 
  private:
   WebRTCPeerConnectionHandlerClient* client_;
   WebTestDelegate* delegate_;
@@ skipping 168 matching lines @@
     const WebMediaStreamTrack& track) {
   return new MockWebRTCDTMFSenderHandler(track, interfaces_->GetDelegate());
 }
 
 void MockWebRTCPeerConnectionHandler::stop() {
   stopped_ = true;
   task_list_.RevokeAll();
 }
 
 }  // namespace content