replace OVERRIDE and FINAL with override and final in chrome/browser/[a-i]*

chrome/browser/diagnostics/recon_diagnostics.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 "chrome/browser/diagnostics/recon_diagnostics.h"
 
 #include <string>
 
 #include "base/files/file_util.h"
 #include "base/json/json_reader.h"
@@ skipping 33 matching lines @@
 
 class InstallTypeTest;
 InstallTypeTest* g_install_type = 0;
 
 // Check if any conflicting DLLs are loaded.
 class ConflictingDllsTest : public DiagnosticsTest {
  public:
   ConflictingDllsTest()
       : DiagnosticsTest(DIAGNOSTICS_CONFLICTING_DLLS_TEST) {}
 
-  virtual bool ExecuteImpl(DiagnosticsModel::Observer* observer) OVERRIDE {
+  virtual bool ExecuteImpl(DiagnosticsModel::Observer* observer) override {
 #if defined(OS_WIN)
     EnumerateModulesModel* model = EnumerateModulesModel::GetInstance();
     model->set_limited_mode(true);
     model->ScanNow();
     scoped_ptr<base::ListValue> list(model->GetModuleList());
     if (!model->confirmed_bad_modules_detected() &&
         !model->suspected_bad_modules_detected()) {
       RecordSuccess("No conflicting modules found");
       return true;
     }
@@ skipping 35 matching lines @@
  private:
   DISALLOW_COPY_AND_ASSIGN(ConflictingDllsTest);
 };
 
 // Check that the disk space in the volume where the user data directory
 // normally lives is not dangerously low.
 class DiskSpaceTest : public DiagnosticsTest {
  public:
   DiskSpaceTest() : DiagnosticsTest(DIAGNOSTICS_DISK_SPACE_TEST) {}
 
-  virtual bool ExecuteImpl(DiagnosticsModel::Observer* observer) OVERRIDE {
+  virtual bool ExecuteImpl(DiagnosticsModel::Observer* observer) override {
     base::FilePath data_dir;
     if (!PathService::Get(chrome::DIR_USER_DATA, &data_dir))
       return false;
     int64 disk_space = base::SysInfo::AmountOfFreeDiskSpace(data_dir);
     if (disk_space < 0) {
       RecordFailure(DIAG_RECON_UNABLE_TO_QUERY, "Unable to query free space");
       return true;
     }
     std::string printable_size = base::Int64ToString(disk_space);
     if (disk_space < 80 * kOneMegabyte) {
       RecordFailure(DIAG_RECON_LOW_DISK_SPACE,
                     "Low disk space: " + printable_size);
       return true;
     }
     RecordSuccess("Free space: " + printable_size);
     return true;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DiskSpaceTest);
 };
 
 // Check if it is system install or per-user install.
 class InstallTypeTest : public DiagnosticsTest {
  public:
   InstallTypeTest()
       : DiagnosticsTest(DIAGNOSTICS_INSTALL_TYPE_TEST), user_level_(false) {}
 
-  virtual bool ExecuteImpl(DiagnosticsModel::Observer* observer) OVERRIDE {
+  virtual bool ExecuteImpl(DiagnosticsModel::Observer* observer) override {
 #if defined(OS_WIN)
     base::FilePath chrome_exe;
     if (!PathService::Get(base::FILE_EXE, &chrome_exe)) {
       RecordFailure(DIAG_RECON_INSTALL_PATH_PROVIDER, "Path provider failure");
       return false;
     }
     user_level_ = InstallUtil::IsPerUserInstall(chrome_exe.value().c_str());
     const char* type = user_level_ ? "User Level" : "System Level";
     std::string install_type(type);
 #else
@@ skipping 21 matching lines @@
 
   JSONTest(const base::FilePath& path,
            DiagnosticsTestId id,
            int64 max_file_size,
            FileImportance importance)
       : DiagnosticsTest(id),
         path_(path),
         max_file_size_(max_file_size),
         importance_(importance) {}
 
-  virtual bool ExecuteImpl(DiagnosticsModel::Observer* observer) OVERRIDE {
+  virtual bool ExecuteImpl(DiagnosticsModel::Observer* observer) override {
     if (!base::PathExists(path_)) {
       if (importance_ == CRITICAL) {
         RecordOutcome(DIAG_RECON_FILE_NOT_FOUND,
                       "File not found",
                       DiagnosticsModel::TEST_FAIL_CONTINUE);
       } else {
         RecordOutcome(DIAG_RECON_FILE_NOT_FOUND_OK,
                       "File not found (but that is OK)",
                       DiagnosticsModel::TEST_OK);
       }
@@ skipping 41 matching lines @@
   FileImportance importance_;
   DISALLOW_COPY_AND_ASSIGN(JSONTest);
 };
 
 // Check that the flavor of the operating system is supported.
 class OperatingSystemTest : public DiagnosticsTest {
  public:
   OperatingSystemTest()
       : DiagnosticsTest(DIAGNOSTICS_OPERATING_SYSTEM_TEST) {}
 
-  virtual bool ExecuteImpl(DiagnosticsModel::Observer* observer) OVERRIDE {
+  virtual bool ExecuteImpl(DiagnosticsModel::Observer* observer) override {
 #if defined(OS_WIN)
     base::win::Version version = base::win::GetVersion();
     if ((version < base::win::VERSION_XP) ||
         ((version == base::win::VERSION_XP) &&
          (base::win::OSInfo::GetInstance()->service_pack().major < 2))) {
       RecordFailure(DIAG_RECON_PRE_WINDOW_XP_SP2,
                     "Must have Windows XP SP2 or later");
       return false;
     }
 #else
@@ skipping 32 matching lines @@
 
 // Check that the user's data directory exists and the paths are writable.
 // If it is a system-wide install some paths are not expected to be writable.
 // This test depends on |InstallTypeTest| having run successfully.
 class PathTest : public DiagnosticsTest {
  public:
   explicit PathTest(const TestPathInfo& path_info)
       : DiagnosticsTest(path_info.test_id),
         path_info_(path_info) {}
 
-  virtual bool ExecuteImpl(DiagnosticsModel::Observer* observer) OVERRIDE {
+  virtual bool ExecuteImpl(DiagnosticsModel::Observer* observer) override {
     if (!g_install_type) {
       RecordStopFailure(DIAG_RECON_DEPENDENCY, "Install dependency failure");
       return false;
     }
     base::FilePath dir_or_file;
     if (!PathService::Get(path_info_.path_id, &dir_or_file)) {
       RecordStopFailure(DIAG_RECON_PATH_PROVIDER, "Path provider failure");
       return false;
     }
     if (!base::PathExists(dir_or_file)) {
@@ skipping 43 matching lines @@
  private:
   TestPathInfo path_info_;
   DISALLOW_COPY_AND_ASSIGN(PathTest);
 };
 
 // Check the version of Chrome.
 class VersionTest : public DiagnosticsTest {
  public:
   VersionTest() : DiagnosticsTest(DIAGNOSTICS_VERSION_TEST) {}
 
-  virtual bool ExecuteImpl(DiagnosticsModel::Observer* observer) OVERRIDE {
+  virtual bool ExecuteImpl(DiagnosticsModel::Observer* observer) override {
     chrome::VersionInfo version_info;
     std::string current_version = version_info.Version();
     if (current_version.empty()) {
       RecordFailure(DIAG_RECON_EMPTY_VERSION, "Empty Version");
       return true;
     }
     std::string version_modifier =
         chrome::VersionInfo::GetVersionStringModifier();
     if (!version_modifier.empty())
       current_version += " " + version_modifier;
@@ skipping 57 matching lines @@
 
 DiagnosticsTest* MakeResourcesFileTest() {
   return new PathTest(kPathsToTest[2]);
 }
 
 DiagnosticsTest* MakeUserDirTest() { return new PathTest(kPathsToTest[3]); }
 
 DiagnosticsTest* MakeVersionTest() { return new VersionTest(); }
 
 }  // namespace diagnostics