Replace FINAL and OVERRIDE with their C++11 counterparts in content/renderer

content/renderer/media/user_media_client_impl_unittest.cc

 // Copyright (c) 2012 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 "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/child/child_process.h"
 #include "content/renderer/media/media_stream.h"
 #include "content/renderer/media/media_stream_track.h"
@@ skipping 59 matching lines @@
   }
 
   void RequestSources() {
     blink::WebMediaStreamTrackSourcesRequest sources_request;
     state_ = REQUEST_NOT_COMPLETE;
     requestSources(sources_request);
   }
 
   virtual void GetUserMediaRequestSucceeded(
       const blink::WebMediaStream& stream,
-      blink::WebUserMediaRequest* request_info) OVERRIDE {
+      blink::WebUserMediaRequest* request_info) override {
     last_generated_stream_ = stream;
     state_ = REQUEST_SUCCEEDED;
   }
 
   virtual void GetUserMediaRequestFailed(
       blink::WebUserMediaRequest* request_info,
-      content::MediaStreamRequestResult result) OVERRIDE {
+      content::MediaStreamRequestResult result) override {
     last_generated_stream_.reset();
     state_ = REQUEST_FAILED;
     result_ = result;
   }
 
   virtual void GetUserMediaRequestTrackStartedFailed(
       blink::WebUserMediaRequest* request_info,
       MediaStreamRequestResult result,
-      const blink::WebString& result_name) OVERRIDE {
+      const blink::WebString& result_name) override {
     last_generated_stream_.reset();
     state_ = REQUEST_FAILED;
     result_ = result;
     result_name_ = result_name;
   }
 
   virtual void EnumerateDevicesSucceded(
       blink::WebMediaDevicesRequest* request,
-      blink::WebVector<blink::WebMediaDeviceInfo>& devices) OVERRIDE {
+      blink::WebVector<blink::WebMediaDeviceInfo>& devices) override {
     state_ = REQUEST_SUCCEEDED;
     last_devices_ = devices;
   }
 
   virtual void EnumerateSourcesSucceded(
       blink::WebMediaStreamTrackSourcesRequest* request,
-      blink::WebVector<blink::WebSourceInfo>& sources) OVERRIDE {
+      blink::WebVector<blink::WebSourceInfo>& sources) override {
     state_ = REQUEST_SUCCEEDED;
     last_sources_ = sources;
   }
 
   virtual MediaStreamVideoSource* CreateVideoSource(
       const StreamDeviceInfo& device,
-      const MediaStreamSource::SourceStoppedCallback& stop_callback) OVERRIDE {
+      const MediaStreamSource::SourceStoppedCallback& stop_callback) override {
     video_source_ = new MockMediaStreamVideoCapturerSource(device,
                                                            stop_callback,
                                                            factory_);
     return video_source_;
   }
 
   const blink::WebMediaStream& last_generated_stream() {
     return last_generated_stream_;
   }
 
@@ skipping 33 matching lines @@
   virtual void SetUp() {
     // Create our test object.
     child_process_.reset(new ChildProcess());
     dependency_factory_.reset(new MockPeerConnectionDependencyFactory());
     ms_dispatcher_ = new MockMediaStreamDispatcher();
     used_media_impl_.reset(new UserMediaClientImplUnderTest(
         dependency_factory_.get(),
         scoped_ptr<MediaStreamDispatcher>(ms_dispatcher_).Pass()));
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     used_media_impl_.reset();
     blink::WebHeap::collectAllGarbageForTesting();
   }
 
   blink::WebMediaStream RequestLocalMediaStream() {
     used_media_impl_->RequestUserMedia();
     FakeMediaStreamDispatcherRequestUserMediaComplete();
     StartMockedVideoSource();
 
     EXPECT_EQ(UserMediaClientImplUnderTest::REQUEST_SUCCEEDED,
@@ skipping 387 matching lines @@
 
   // Video input device environment facing.
   source = &used_media_impl_->last_sources()[3];
   EXPECT_FALSE(source->id().isEmpty());
   EXPECT_EQ(blink::WebSourceInfo::SourceKindVideo, source->kind());
   EXPECT_FALSE(source->label().isEmpty());
   EXPECT_EQ(blink::WebSourceInfo::VideoFacingModeEnvironment, source->facing());
 }
 
 }  // namespace content