Switch to standard integer types in chrome/browser/, part 1 of 4.

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 <stddef.h>
+#include <stdint.h>
+
 #include <string>
 
 #include "base/files/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_string_value_serializer.h"
+#include "base/macros.h"
 #include "base/path_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/sys_info.h"
+#include "build/build_config.h"
 #include "chrome/browser/diagnostics/diagnostics_test.h"
 #include "chrome/common/channel_info.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "components/bookmarks/common/bookmark_constants.h"
 #include "components/version_info/version_info.h"
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #include "chrome/browser/enumerate_modules_model_win.h"
 #include "chrome/installer/util/install_util.h"
 #endif
 
 // Reconnaissance diagnostics. These are the first and most critical
 // diagnostic tests. Here we check for the existence of critical files.
 // TODO(cpu): Define if it makes sense to localize strings.
 
 // TODO(cpu): There are a few maximum file sizes hard-coded in this file
 // that have little or no theoretical or experimental ground. Find a way
 // to justify them.
 
 namespace diagnostics {
 
 namespace {
 
-const int64 kOneKilobyte = 1024;
-const int64 kOneMegabyte = 1024 * kOneKilobyte;
+const int64_t kOneKilobyte = 1024;
+const int64_t kOneMegabyte = 1024 * kOneKilobyte;
 
 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) {}
 
@@ skipping 50 matching lines @@
 // 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) {}
 
   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);
+    int64_t 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;
     }
@@ skipping 39 matching lines @@
 // Checks that a given JSON file can be correctly parsed.
 class JSONTest : public DiagnosticsTest {
  public:
   enum FileImportance {
     NON_CRITICAL,
     CRITICAL
   };
 
   JSONTest(const base::FilePath& path,
            DiagnosticsTestId id,
-           int64 max_file_size,
+           int64_t max_file_size,
            FileImportance importance)
       : DiagnosticsTest(id),
         path_(path),
         max_file_size_(max_file_size),
         importance_(importance) {}
 
   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);
       }
       return true;
     }
-    int64 file_size;
+    int64_t file_size;
     if (!base::GetFileSize(path_, &file_size)) {
       RecordFailure(DIAG_RECON_CANNOT_OBTAIN_FILE_SIZE,
                     "Cannot obtain file size");
       return true;
     }
 
     if (file_size > max_file_size_) {
       RecordFailure(DIAG_RECON_FILE_TOO_BIG, "File too big");
       return true;
     }
@@ skipping 17 matching lines @@
       RecordFailure(DIAG_RECON_PARSE_ERROR, error_message);
       return true;
     }
 
     RecordSuccess("File parsed OK");
     return true;
   }
 
  private:
   base::FilePath path_;
-  int64 max_file_size_;
+  int64_t max_file_size_;
   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) {}
 
@@ skipping 20 matching lines @@
  private:
   DISALLOW_COPY_AND_ASSIGN(OperatingSystemTest);
 };
 
 struct TestPathInfo {
   DiagnosticsTestId test_id;
   int path_id;
   bool is_directory;
   bool is_optional;
   bool test_writable;
-  int64 max_size;
+  int64_t max_size;
 };
 
 const TestPathInfo kPathsToTest[] = {
     {DIAGNOSTICS_PATH_DICTIONARIES_TEST, chrome::DIR_APP_DICTIONARIES, true,
      true, false, 0},
     {DIAGNOSTICS_PATH_LOCAL_STATE_TEST, chrome::FILE_LOCAL_STATE, false, false,
      true, 500 * kOneKilobyte},
     {DIAGNOSTICS_PATH_RESOURCES_TEST, chrome::FILE_RESOURCES_PACK, false, false,
      false, 0},
     {DIAGNOSTICS_PATH_USER_DATA_TEST, chrome::DIR_USER_DATA, true, false, true,
@@ skipping 20 matching lines @@
       return false;
     }
     if (!base::PathExists(dir_or_file)) {
       RecordFailure(
           DIAG_RECON_PATH_NOT_FOUND,
           "Path not found: " +
               base::UTF16ToUTF8(dir_or_file.LossyDisplayName()));
       return true;
     }
 
-    int64 dir_or_file_size = 0;
+    int64_t dir_or_file_size = 0;
     if (path_info_.is_directory) {
       dir_or_file_size = base::ComputeDirectorySize(dir_or_file);
     } else {
       base::GetFileSize(dir_or_file, &dir_or_file_size);
     }
     if (!dir_or_file_size && !path_info_.is_optional) {
       RecordFailure(DIAG_RECON_CANNOT_OBTAIN_SIZE,
                     "Cannot obtain size for: " +
                         base::UTF16ToUTF8(dir_or_file.LossyDisplayName()));
       return true;
@@ skipping 101 matching lines @@
 
 DiagnosticsTest* MakeResourcesFileTest() {
   return new PathTest(kPathsToTest[2]);
 }
 
 DiagnosticsTest* MakeUserDirTest() { return new PathTest(kPathsToTest[3]); }
 
 DiagnosticsTest* MakeVersionTest() { return new VersionTest(); }
 
 }  // namespace diagnostics