Replacing the OVERRIDE with override and FINAL with final in content/browser/renderer_host

content/browser/renderer_host/media/video_capture_controller.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 "content/browser/renderer_host/media/video_capture_controller.h"
 
 #include <map>
 #include <set>
 
 #include "base/bind.h"
@@ skipping 44 matching lines @@
  private:
   virtual ~PoolBuffer() { pool_->RelinquishProducerReservation(id()); }
 
   const scoped_refptr<VideoCaptureBufferPool> pool_;
 };
 
 class SyncPointClientImpl : public media::VideoFrame::SyncPointClient {
  public:
   explicit SyncPointClientImpl(GLHelper* gl_helper) : gl_helper_(gl_helper) {}
   virtual ~SyncPointClientImpl() {}
-  virtual uint32 InsertSyncPoint() OVERRIDE {
+  virtual uint32 InsertSyncPoint() override {
     return gl_helper_->InsertSyncPoint();
   }
-  virtual void WaitSyncPoint(uint32 sync_point) OVERRIDE {
+  virtual void WaitSyncPoint(uint32 sync_point) override {
     gl_helper_->WaitSyncPoint(sync_point);
   }
 
  private:
   GLHelper* gl_helper_;
 };
 
 void ReturnVideoFrame(const scoped_refptr<media::VideoFrame>& video_frame,
                       uint32 sync_point) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
@@ skipping 75 matching lines @@
     : public media::VideoCaptureDevice::Client {
  public:
   explicit VideoCaptureDeviceClient(
       const base::WeakPtr<VideoCaptureController>& controller,
       const scoped_refptr<VideoCaptureBufferPool>& buffer_pool);
   virtual ~VideoCaptureDeviceClient();
 
   // VideoCaptureDevice::Client implementation.
   virtual scoped_refptr<Buffer> ReserveOutputBuffer(
       media::VideoFrame::Format format,
-      const gfx::Size& size) OVERRIDE;
+      const gfx::Size& size) override;
   virtual void OnIncomingCapturedData(const uint8* data,
                                       int length,
                                       const VideoCaptureFormat& frame_format,
                                       int rotation,
-                                      base::TimeTicks timestamp) OVERRIDE;
+                                      base::TimeTicks timestamp) override;
   virtual void OnIncomingCapturedVideoFrame(
       const scoped_refptr<Buffer>& buffer,
       const VideoCaptureFormat& buffer_format,
       const scoped_refptr<media::VideoFrame>& frame,
-      base::TimeTicks timestamp) OVERRIDE;
-  virtual void OnError(const std::string& reason) OVERRIDE;
-  virtual void OnLog(const std::string& message) OVERRIDE;
+      base::TimeTicks timestamp) override;
+  virtual void OnError(const std::string& reason) override;
+  virtual void OnLog(const std::string& message) override;
 
  private:
   scoped_refptr<Buffer> DoReserveOutputBuffer(media::VideoFrame::Format format,
                                               const gfx::Size& dimensions);
 
   // The controller to which we post events.
   const base::WeakPtr<VideoCaptureController> controller_;
 
   // The pool of shared-memory buffers used for capturing.
   const scoped_refptr<VideoCaptureBufferPool> buffer_pool_;
@@ skipping 527 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   int active_client_count = 0;
   for (ControllerClient* client : controller_clients_) {
     if (!client->paused)
       ++active_client_count;
   }
   return active_client_count;
 }
 
 }  // namespace content