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

chrome/browser/extensions/api/desktop_capture/desktop_capture_apitest.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 <queue>
 
 #include "base/command_line.h"
 #include "base/path_service.h"
 #include "base/thread_task_runner_handle.h"
 #include "chrome/browser/extensions/api/desktop_capture/desktop_capture_api.h"
@@ skipping 24 matching lines @@
   bool picker_deleted;
 };
 
 class FakeDesktopMediaPicker : public DesktopMediaPicker {
  public:
   explicit FakeDesktopMediaPicker(TestFlags* expectation)
       : expectation_(expectation),
         weak_factory_(this) {
     expectation_->picker_created = true;
   }
-  virtual ~FakeDesktopMediaPicker() {
-    expectation_->picker_deleted = true;
-  }
+  ~FakeDesktopMediaPicker() override { expectation_->picker_deleted = true; }
 
   // DesktopMediaPicker interface.
-  virtual void Show(content::WebContents* web_contents,
-                    gfx::NativeWindow context,
-                    gfx::NativeWindow parent,
-                    const base::string16& app_name,
-                    const base::string16& target_name,
-                    scoped_ptr<DesktopMediaList> model,
-                    const DoneCallback& done_callback) override {
+  void Show(content::WebContents* web_contents,
+            gfx::NativeWindow context,
+            gfx::NativeWindow parent,
+            const base::string16& app_name,
+            const base::string16& target_name,
+            scoped_ptr<DesktopMediaList> model,
+            const DoneCallback& done_callback) override {
     if (!expectation_->cancelled) {
       // Post a task to call the callback asynchronously.
       base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE,
           base::Bind(&FakeDesktopMediaPicker::CallCallback,
                      weak_factory_.GetWeakPtr(), done_callback));
     } else {
       // If we expect the dialog to be cancelled then store the callback to
       // retain reference to the callback handler.
       done_callback_ = done_callback;
@@ skipping 10 matching lines @@
 
   base::WeakPtrFactory<FakeDesktopMediaPicker> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeDesktopMediaPicker);
 };
 
 class FakeDesktopMediaPickerFactory :
     public DesktopCaptureChooseDesktopMediaFunction::PickerFactory {
  public:
   FakeDesktopMediaPickerFactory() {}
-  virtual ~FakeDesktopMediaPickerFactory() {}
+  ~FakeDesktopMediaPickerFactory() override {}
 
   void SetTestFlags(TestFlags* test_flags, int tests_count) {
     test_flags_ = test_flags;
     tests_count_ = tests_count;
     current_test_ = 0;
   }
 
   // DesktopCaptureChooseDesktopMediaFunction::PickerFactory interface.
-  virtual scoped_ptr<DesktopMediaList> CreateModel(
-      bool show_screens,
-      bool show_windows) override {
+  scoped_ptr<DesktopMediaList> CreateModel(bool show_screens,
+                                           bool show_windows) override {
     EXPECT_LE(current_test_, tests_count_);
     if (current_test_ >= tests_count_)
       return scoped_ptr<DesktopMediaList>();
     EXPECT_EQ(test_flags_[current_test_].expect_screens, show_screens);
     EXPECT_EQ(test_flags_[current_test_].expect_windows, show_windows);
     return scoped_ptr<DesktopMediaList>(new FakeDesktopMediaList());
   }
 
-  virtual scoped_ptr<DesktopMediaPicker> CreatePicker() override {
+  scoped_ptr<DesktopMediaPicker> CreatePicker() override {
     EXPECT_LE(current_test_, tests_count_);
     if (current_test_ >= tests_count_)
       return scoped_ptr<DesktopMediaPicker>();
     ++current_test_;
     return scoped_ptr<DesktopMediaPicker>(
         new FakeDesktopMediaPicker(test_flags_ + current_test_ - 1));
   }
 
  private:
   TestFlags* test_flags_;
@@ skipping 116 matching lines @@
   EXPECT_TRUE(result);
   EXPECT_TRUE(test_flags[2].picker_created);
   EXPECT_FALSE(test_flags[2].picker_deleted);
 
   web_contents->Close();
   destroyed_watcher.Wait();
   EXPECT_TRUE(test_flags[2].picker_deleted);
 }
 
 }  // namespace extensions