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

chrome/browser/apps/drive/drive_app_provider_browsertest.cc

 // Copyright 2014 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/apps/drive/drive_app_provider.h"
 
 #include <set>
 #include <string>
 
 #include "base/logging.h"
@@ skipping 30 matching lines @@
 const char kLaunchUrl[] = "http://example.com/drive";
 
 // App id of hosted_app.crx.
 const char kChromeAppId[] = "kbmnembihfiondgfjekmnmcbddelicoi";
 
 // Stub drive service bridge.
 class TestDriveServiceBridge : public DriveServiceBridge {
  public:
   explicit TestDriveServiceBridge(drive::DriveAppRegistry* registry)
       : registry_(registry) {}
-  virtual ~TestDriveServiceBridge() {}
+  ~TestDriveServiceBridge() override {}
 
-  virtual drive::DriveAppRegistry* GetAppRegistry() override {
-    return registry_;
-  }
+  drive::DriveAppRegistry* GetAppRegistry() override { return registry_; }
 
  private:
   drive::DriveAppRegistry* registry_;
 
   DISALLOW_COPY_AND_ASSIGN(TestDriveServiceBridge);
 };
 
 class FakeUninstallSyncService : public DriveAppUninstallSyncService {
  public:
   FakeUninstallSyncService() {}
-  virtual ~FakeUninstallSyncService() {}
+  ~FakeUninstallSyncService() override {}
 
   bool IsUninstallTracked(const std::string& drive_app_id) const {
     return uninstalled_app_ids_.find(drive_app_id) !=
            uninstalled_app_ids_.end();
   }
 
   // DriveAppUninstallSyncService
-  virtual void TrackUninstalledDriveApp(
-      const std::string& drive_app_id) override {
+  void TrackUninstalledDriveApp(const std::string& drive_app_id) override {
     uninstalled_app_ids_.insert(drive_app_id);
   }
-  virtual void UntrackUninstalledDriveApp(
-      const std::string& drive_app_id) override {
+  void UntrackUninstalledDriveApp(const std::string& drive_app_id) override {
     auto it = uninstalled_app_ids_.find(drive_app_id);
     if (it == uninstalled_app_ids_.end())
       return;
     uninstalled_app_ids_.erase(it);
   }
 
  private:
   std::set<std::string> uninstalled_app_ids_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeUninstallSyncService);
 };
 
 }  // namespace
 
 class DriveAppProviderTest : public ExtensionBrowserTest,
                              public extensions::InstallObserver {
  public:
   DriveAppProviderTest() {}
   virtual ~DriveAppProviderTest() {}
 
   // ExtensionBrowserTest:
-  virtual void SetUpOnMainThread() override {
+  void SetUpOnMainThread() override {
     ExtensionBrowserTest::SetUpOnMainThread();
 
     fake_drive_service_.reset(new drive::FakeDriveService);
     fake_drive_service_->LoadAppListForDriveApi("drive/applist_empty.json");
     apps_registry_.reset(
         new drive::DriveAppRegistry(fake_drive_service_.get()));
 
     fake_uninstall_sync_service_.reset(new FakeUninstallSyncService);
 
     provider_.reset(
         new DriveAppProvider(profile(), fake_uninstall_sync_service_.get()));
     provider_->SetDriveServiceBridgeForTest(
         make_scoped_ptr(new TestDriveServiceBridge(apps_registry_.get())));
 
     // The DriveAppProvider in AppListSyncalbeService interferes with the
     // test. So resets it.
     app_list::AppListSyncableServiceFactory::GetForProfile(profile())
         ->ResetDriveAppProviderForTest();
   }
 
-  virtual void TearDownOnMainThread() override {
+  void TearDownOnMainThread() override {
     provider_.reset();
     apps_registry_.reset();
     fake_drive_service_.reset();
 
     ExtensionBrowserTest::TearDownOnMainThread();
   }
 
   const Extension* InstallChromeApp(int expected_change) {
     base::FilePath test_data_path;
     if (!PathService::Get(chrome::DIR_TEST_DATA, &test_data_path)) {
@@ skipping 67 matching lines @@
   DriveAppProvider* provider() { return provider_.get(); }
   DriveAppMapping* mapping() { return provider_->mapping_.get(); }
 
  private:
   void OnPendingDriveAppConverterCheckTimer() {
     if (!HasPendingConverters())
       runner_->Quit();
   }
 
   // extensions::InstallObserver
-  virtual void OnFinishCrxInstall(const std::string& extension_id,
-                                  bool success) override {
+  void OnFinishCrxInstall(const std::string& extension_id,
+                          bool success) override {
     runner_->Quit();
   }
 
   scoped_ptr<drive::FakeDriveService> fake_drive_service_;
   scoped_ptr<FakeUninstallSyncService> fake_uninstall_sync_service_;
   scoped_ptr<drive::DriveAppRegistry> apps_registry_;
   scoped_ptr<DriveAppProvider> provider_;
 
   base::RepeatingTimer<DriveAppProviderTest>
       pending_drive_app_converter_check_timer_;
@@ skipping 356 matching lines @@
       chrome_app_id, ExtensionRegistry::EVERYTHING));
 
   // Uninstall is removed from sync and the app is added again.
   provider()->RemoveUninstalledDriveAppFromSync(kDriveAppId);
   WaitForPendingDriveAppConverters();
   chrome_app_id = mapping()->GetChromeApp(kDriveAppId);
   EXPECT_FALSE(chrome_app_id.empty());
   EXPECT_TRUE(ExtensionRegistry::Get(profile())->GetExtensionById(
       chrome_app_id, ExtensionRegistry::EVERYTHING));
 }