Update {virtual,override,final} to follow C++11 style chrome/browser/ui.

chrome/browser/ui/ash/launcher/chrome_launcher_controller_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/ui/ash/launcher/chrome_launcher_controller.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 601 matching lines @@
 #if defined(OS_CHROMEOS)
 // A browser window proxy which is able to associate an aura native window with
 // it.
 class TestBrowserWindowAura : public TestBrowserWindow {
  public:
   // |native_window| will still be owned by the caller after the constructor
   // was called.
   explicit TestBrowserWindowAura(aura::Window* native_window)
       : native_window_(native_window) {
   }
-  virtual ~TestBrowserWindowAura() {}
+  ~TestBrowserWindowAura() override {}
 
-  virtual gfx::NativeWindow GetNativeWindow() const override {
+  gfx::NativeWindow GetNativeWindow() const override {
     return native_window_.get();
   }
 
   Browser* browser() { return browser_.get(); }
 
   void CreateBrowser(const Browser::CreateParams& params) {
     Browser::CreateParams create_params = params;
     create_params.window = this;
     browser_.reset(new Browser(create_params));
   }
@@ skipping 23 matching lines @@
 
 // Watches WebContents and blocks until it is destroyed. This is needed for
 // the destruction of a V2 application.
 class WebContentsDestroyedWatcher : public content::WebContentsObserver {
  public:
   explicit WebContentsDestroyedWatcher(content::WebContents* web_contents)
       : content::WebContentsObserver(web_contents),
         message_loop_runner_(new content::MessageLoopRunner) {
     EXPECT_TRUE(web_contents != NULL);
   }
-  virtual ~WebContentsDestroyedWatcher() {}
+  ~WebContentsDestroyedWatcher() override {}
 
   // Waits until the WebContents is destroyed.
   void Wait() {
     message_loop_runner_->Run();
   }
 
  private:
   // Overridden WebContentsObserver methods.
-  virtual void WebContentsDestroyed() override {
-    message_loop_runner_->Quit();
-  }
+  void WebContentsDestroyed() override { message_loop_runner_->Quit(); }
 
   scoped_refptr<content::MessageLoopRunner> message_loop_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(WebContentsDestroyedWatcher);
 };
 
 // A V1 windowed application.
 class V1App : public TestBrowserWindow {
  public:
   V1App(Profile* profile, const std::string& app_name) {
@@ skipping 10 matching lines @@
         Browser::CreateParams::CreateForApp(kCrxAppPrefix + app_name,
                                             true /* trusted_source */,
                                             gfx::Rect(),
                                             profile,
                                             chrome::HOST_DESKTOP_TYPE_ASH);
     params.window = this;
     browser_.reset(new Browser(params));
     chrome::AddTabAt(browser_.get(), GURL(), 0, true);
   }
 
-  virtual ~V1App() {
+  ~V1App() override {
     // close all tabs. Note that we do not need to destroy the browser itself.
     browser_->tab_strip_model()->CloseAllTabs();
   }
 
   Browser* browser() { return browser_.get(); }
 
   // TestBrowserWindow override:
-  virtual gfx::NativeWindow GetNativeWindow() const override {
+  gfx::NativeWindow GetNativeWindow() const override {
     return native_window_.get();
   }
 
  private:
   // The associated browser with this app.
   scoped_ptr<Browser> browser_;
 
   // The native window we use.
   scoped_ptr<aura::Window> native_window_;
 
@@ skipping 32 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(V2App);
 };
 
 // The testing framework to test multi profile scenarios.
 class MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest
     : public ChromeLauncherControllerTest {
  protected:
   MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest() {
   }
 
-  virtual ~MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest() {
-  }
+  ~MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest() override {}
 
   // Overwrite the Setup function to enable multi profile and needed objects.
-  virtual void SetUp() override {
+  void SetUp() override {
     profile_manager_.reset(
         new TestingProfileManager(TestingBrowserProcess::GetGlobal()));
 
     ASSERT_TRUE(profile_manager_->SetUp());
 
     // AvatarMenu and multiple profiles works after user logged in.
     profile_manager_->SetLoggedIn(true);
 
     // Initialize the UserManager singleton to a fresh FakeUserManager instance.
     user_manager_enabler_.reset(
         new chromeos::ScopedUserManagerEnabler(new chromeos::FakeUserManager));
 
     // Initialize the rest.
     ChromeLauncherControllerTest::SetUp();
 
     // Get some base objects.
     session_delegate()->set_logged_in_users(2);
     shell_delegate_ = static_cast<ash::test::TestShellDelegate*>(
         ash::Shell::GetInstance()->delegate());
     shell_delegate_->set_multi_profiles_enabled(true);
   }
 
-  virtual void TearDown() {
+  void TearDown() override {
     ChromeLauncherControllerTest::TearDown();
     user_manager_enabler_.reset();
     for (ProfileToNameMap::iterator it = created_profiles_.begin();
          it != created_profiles_.end(); ++it)
       profile_manager_->DeleteTestingProfile(it->second);
 
     // A Task is leaked if we don't destroy everything, then run the message
     // loop.
     base::MessageLoop::current()->PostTask(FROM_HERE,
                                            base::MessageLoop::QuitClosure());
@@ skipping 78 matching lines @@
     return v1_app;
   }
 
   ash::test::TestSessionStateDelegate* session_delegate() {
     return static_cast<ash::test::TestSessionStateDelegate*>(
         ash::Shell::GetInstance()->session_state_delegate());
   }
   ash::test::TestShellDelegate* shell_delegate() { return shell_delegate_; }
 
   // Override BrowserWithTestWindowTest:
-  virtual TestingProfile* CreateProfile() override {
+  TestingProfile* CreateProfile() override {
     return CreateMultiUserProfile("user1");
   }
-  virtual void DestroyProfile(TestingProfile* profile) override {
+  void DestroyProfile(TestingProfile* profile) override {
     // Delete the profile through our profile manager.
     ProfileToNameMap::iterator it = created_profiles_.find(profile);
     DCHECK(it != created_profiles_.end());
     profile_manager_->DeleteTestingProfile(it->second);
     created_profiles_.erase(it);
   }
 
  private:
   typedef std::map<Profile*, std::string> ProfileToNameMap;
   TestingProfileManager* profile_manager() { return profile_manager_.get(); }
@@ skipping 1769 matching lines @@
 
   EXPECT_EQ(1, app_icon_loader->fetch_count());
   ASSERT_EQ(initial_size + 1, model_->items().size());
   EXPECT_TRUE(launcher_controller_->IsAppPinned("1"));
   EXPECT_FALSE(launcher_controller_->IsAppPinned("0"));
   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[app_index].type);
 
   launcher_controller_->UnpinAppWithID("1");
   ASSERT_EQ(initial_size, model_->items().size());
 }