Linux/ChromeOS Chromium style checker cleanup, chrome/browser edition.

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/file_util.h"
 #include "base/json/json_reader.h"
@@ skipping 27 matching lines @@
 namespace {
 
 class InstallTypeTest;
 InstallTypeTest* g_install_type = 0;
 
 // Check that the flavor of the operating system is supported.
 class OperatingSystemTest : public DiagnosticTest {
  public:
   OperatingSystemTest() : DiagnosticTest(ASCIIToUTF16("Operating System")) {}
 
-  virtual int GetId() { return 0; }
+  virtual int GetId() OVERRIDE { return 0; }
 
-  virtual bool ExecuteImpl(DiagnosticsModel::Observer* observer) {
+  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(ASCIIToUTF16("Must have Windows XP SP2 or later"));
       return false;
     }
 #else
     // TODO(port): define the OS criteria for Linux and Mac.
 #endif  // defined(OS_WIN)
     RecordSuccess(ASCIIToUTF16(base::StringPrintf(
         "%s %s",
         base::SysInfo::OperatingSystemName().c_str(),
         base::SysInfo::OperatingSystemVersion().c_str())));
     return true;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(OperatingSystemTest);
 };
 
 // Check if any conflicting DLLs are loaded.
 class ConflictingDllsTest : public DiagnosticTest {
  public:
   ConflictingDllsTest() : DiagnosticTest(ASCIIToUTF16("Conflicting modules")) {}
 
-  virtual int GetId() { return 0; }
+  virtual int GetId() OVERRIDE { return 0; }
 
-  virtual bool ExecuteImpl(DiagnosticsModel::Observer* observer) {
+  virtual bool ExecuteImpl(DiagnosticsModel::Observer* observer) OVERRIDE {
 #if defined(OS_WIN)
     EnumerateModulesModel* model = EnumerateModulesModel::GetInstance();
     model->set_limited_mode(true);
     model->ScanNow();
     scoped_ptr<ListValue> list(model->GetModuleList());
     if (!model->confirmed_bad_modules_detected() &&
         !model->suspected_bad_modules_detected()) {
       RecordSuccess(ASCIIToUTF16("No conflicting modules found"));
       return true;
     }
@@ skipping 33 matching lines @@
  private:
   DISALLOW_COPY_AND_ASSIGN(ConflictingDllsTest);
 };
 
 // Check if it is system install or per-user install.
 class InstallTypeTest : public DiagnosticTest {
  public:
   InstallTypeTest() : DiagnosticTest(ASCIIToUTF16("Install Type")),
                       user_level_(false) {}
 
-  virtual int GetId() { return 0; }
+  virtual int GetId() OVERRIDE { return 0; }
 
-  virtual bool ExecuteImpl(DiagnosticsModel::Observer* observer) {
+  virtual bool ExecuteImpl(DiagnosticsModel::Observer* observer) OVERRIDE {
 #if defined(OS_WIN)
     FilePath chrome_exe;
     if (!PathService::Get(base::FILE_EXE, &chrome_exe)) {
       RecordFailure(ASCIIToUTF16("Path provider failure"));
       return false;
     }
     user_level_ = InstallUtil::IsPerUserInstall(chrome_exe.value().c_str());
     const char* type = user_level_ ? "User Level" : "System Level";
     string16 install_type(ASCIIToUTF16(type));
 #else
     string16 install_type(ASCIIToUTF16("System Level"));
 #endif  // defined(OS_WIN)
     RecordSuccess(install_type);
     g_install_type = this;
     return true;
   }
 
   bool system_level() const { return !user_level_; }
 
  private:
   bool user_level_;
   DISALLOW_COPY_AND_ASSIGN(InstallTypeTest);
 };
 
 // Check the version of Chrome.
 class VersionTest : public DiagnosticTest {
  public:
   VersionTest() : DiagnosticTest(ASCIIToUTF16("Browser Version")) {}
 
-  virtual int GetId() { return 0; }
+  virtual int GetId() OVERRIDE { return 0; }
 
-  virtual bool ExecuteImpl(DiagnosticsModel::Observer* observer) {
+  virtual bool ExecuteImpl(DiagnosticsModel::Observer* observer) OVERRIDE {
     chrome::VersionInfo version_info;
     if (!version_info.is_valid()) {
       RecordFailure(ASCIIToUTF16("No Version"));
       return true;
     }
     std::string current_version = version_info.Version();
     if (current_version.empty()) {
       RecordFailure(ASCIIToUTF16("Empty Version"));
       return true;
     }
@@ skipping 37 matching lines @@
 
 // Check that the user's data directory exists and the paths are writable.
 // If it is a systemwide install some paths are not expected to be writable.
 // This test depends on |InstallTypeTest| having run successfully.
 class PathTest : public DiagnosticTest {
  public:
   explicit PathTest(const TestPathInfo& path_info)
       : DiagnosticTest(ASCIIToUTF16(path_info.test_name)),
         path_info_(path_info) {}
 
-  virtual int GetId() { return 0; }
+  virtual int GetId() OVERRIDE { return 0; }
 
-  virtual bool ExecuteImpl(DiagnosticsModel::Observer* observer) {
+  virtual bool ExecuteImpl(DiagnosticsModel::Observer* observer) OVERRIDE {
     if (!g_install_type) {
       RecordStopFailure(ASCIIToUTF16("dependency failure"));
       return false;
     }
     FilePath dir_or_file;
     if (!PathService::Get(path_info_.path_id, &dir_or_file)) {
       RecordStopFailure(ASCIIToUTF16("Path provider failure"));
       return false;
     }
     if (!file_util::PathExists(dir_or_file)) {
@@ skipping 42 matching lines @@
   TestPathInfo path_info_;
   DISALLOW_COPY_AND_ASSIGN(PathTest);
 };
 
 // Check that the disk space in the volume where the user data dir normally
 // lives is not dangerously low.
 class DiskSpaceTest : public DiagnosticTest {
  public:
   DiskSpaceTest() : DiagnosticTest(ASCIIToUTF16("Disk Space")) {}
 
-  virtual int GetId() { return 0; }
+  virtual int GetId() OVERRIDE { return 0; }
 
-  virtual bool ExecuteImpl(DiagnosticsModel::Observer* observer) {
+  virtual bool ExecuteImpl(DiagnosticsModel::Observer* observer) OVERRIDE {
     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(ASCIIToUTF16("Unable to query free space"));
       return true;
     }
     string16 printable_size = ui::FormatBytes(disk_space);
     if (disk_space < 80 * kOneMeg) {
       RecordFailure(ASCIIToUTF16("Low disk space : ") + printable_size);
       return true;
     }
     RecordSuccess(ASCIIToUTF16("Free space : ") + printable_size);
     return true;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DiskSpaceTest);
 };
 
 // Checks that a given json file can be correctly parsed.
 class JSONTest : public DiagnosticTest {
  public:
   JSONTest(const FilePath& path, const string16& name, int64 max_file_size)
       : DiagnosticTest(name), path_(path), max_file_size_(max_file_size) {
   }
 
-  virtual int GetId() { return 0; }
+  virtual int GetId() OVERRIDE { return 0; }
 
-  virtual bool ExecuteImpl(DiagnosticsModel::Observer* observer) {
+  virtual bool ExecuteImpl(DiagnosticsModel::Observer* observer) OVERRIDE {
     if (!file_util::PathExists(path_)) {
       RecordFailure(ASCIIToUTF16("File not found"));
       return true;
     }
     int64 file_size;
     if (!file_util::GetFileSize(path_, &file_size)) {
       RecordFailure(ASCIIToUTF16("Cannot obtain file size"));
       return true;
     }
 
@@ skipping 80 matching lines @@
   path = path.Append(chrome::kBookmarksFileName);
   return new JSONTest(path, ASCIIToUTF16("BookMarks JSON"), 2 * kOneMeg);
 }
 
 DiagnosticTest* MakeLocalStateTest() {
   FilePath path;
   PathService::Get(chrome::DIR_USER_DATA, &path);
   path = path.Append(chrome::kLocalStateFilename);
   return new JSONTest(path, ASCIIToUTF16("Local State JSON"), 50 * kOneKilo);
 }