Standardize usage of virtual/override/final in chrome/browser/media

chrome/browser/media/native_desktop_media_list_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 "chrome/browser/media/native_desktop_media_list.h"
 
 #include "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/lock.h"
 #include "chrome/browser/media/desktop_media_list_observer.h"
@@ skipping 14 matching lines @@
   MOCK_METHOD1(OnSourceAdded, void(int index));
   MOCK_METHOD1(OnSourceRemoved, void(int index));
   MOCK_METHOD2(OnSourceMoved, void(int old_index, int new_index));
   MOCK_METHOD1(OnSourceNameChanged, void(int index));
   MOCK_METHOD1(OnSourceThumbnailChanged, void(int index));
 };
 
 class FakeScreenCapturer : public webrtc::ScreenCapturer {
  public:
   FakeScreenCapturer() {}
-  virtual ~FakeScreenCapturer() {}
+  ~FakeScreenCapturer() override {}
 
   // webrtc::ScreenCapturer implementation.
-  virtual void Start(Callback* callback) override {
-    callback_ = callback;
-  }
+  void Start(Callback* callback) override { callback_ = callback; }
 
-  virtual void Capture(const webrtc::DesktopRegion& region) override {
+  void Capture(const webrtc::DesktopRegion& region) override {
     DCHECK(callback_);
     webrtc::DesktopFrame* frame =
         new webrtc::BasicDesktopFrame(webrtc::DesktopSize(10, 10));
     memset(frame->data(), 0, frame->stride() * frame->size().height());
     callback_->OnCaptureCompleted(frame);
   }
 
-  virtual void SetMouseShapeObserver(
+  void SetMouseShapeObserver(
       MouseShapeObserver* mouse_shape_observer) override {
     NOTIMPLEMENTED();
   }
 
-  virtual bool GetScreenList(ScreenList* screens) override {
+  bool GetScreenList(ScreenList* screens) override {
     webrtc::ScreenCapturer::Screen screen;
     screen.id = 0;
     screens->push_back(screen);
     return true;
   }
 
-  virtual bool SelectScreen(webrtc::ScreenId id) override {
+  bool SelectScreen(webrtc::ScreenId id) override {
     EXPECT_EQ(0, id);
     return true;
   }
 
  protected:
   Callback* callback_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeScreenCapturer);
 };
 
 class FakeWindowCapturer : public webrtc::WindowCapturer {
  public:
   FakeWindowCapturer()
       : callback_(NULL) {
   }
-  virtual ~FakeWindowCapturer() {}
+  ~FakeWindowCapturer() override {}
 
   void SetWindowList(const WindowList& list) {
     base::AutoLock lock(window_list_lock_);
     window_list_ = list;
   }
 
   // Sets |value| thats going to be used to memset() content of the frames
   // generated for |window_id|. By default generated frames are set to zeros.
   void SetNextFrameValue(WindowId window_id, int8_t value) {
     base::AutoLock lock(frame_values_lock_);
     frame_values_[window_id] = value;
   }
 
   // webrtc::WindowCapturer implementation.
-  virtual void Start(Callback* callback) override {
-    callback_ = callback;
-  }
+  void Start(Callback* callback) override { callback_ = callback; }
 
-  virtual void Capture(const webrtc::DesktopRegion& region) override {
+  void Capture(const webrtc::DesktopRegion& region) override {
     DCHECK(callback_);
 
     base::AutoLock lock(frame_values_lock_);
 
     std::map<WindowId, int8_t>::iterator it =
         frame_values_.find(selected_window_id_);
     int8_t value = (it != frame_values_.end()) ? it->second : 0;
     webrtc::DesktopFrame* frame =
         new webrtc::BasicDesktopFrame(webrtc::DesktopSize(10, 10));
     memset(frame->data(), value, frame->stride() * frame->size().height());
     callback_->OnCaptureCompleted(frame);
   }
 
-  virtual bool GetWindowList(WindowList* windows) override {
+  bool GetWindowList(WindowList* windows) override {
     base::AutoLock lock(window_list_lock_);
     *windows = window_list_;
     return true;
   }
 
-  virtual bool SelectWindow(WindowId id) override {
+  bool SelectWindow(WindowId id) override {
     selected_window_id_ = id;
     return true;
   }
 
-  virtual bool BringSelectedWindowToFront() override {
-    return true;
-  }
+  bool BringSelectedWindowToFront() override { return true; }
 
  private:
   Callback* callback_;
   WindowList window_list_;
   base::Lock window_list_lock_;
 
   WindowId selected_window_id_;
 
   // Frames to be captured per window.
   std::map<WindowId, int8_t> frame_values_;
@@ skipping 218 matching lines @@
   // Swap the two windows.
   webrtc::WindowCapturer::Window temp = list[0];
   list[0] = list[1];
   list[1] = temp;
   window_capturer_->SetWindowList(list);
 
   message_loop_.Run();
 }
 
 }  // namespace