Switch to standard integer types in chrome/.

chrome/installer/test/alternate_version_generator.cc

 // Copyright (c) 2011 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.
 
 // The file contains the implementation of the mini_installer re-versioner.
 // The main function (GenerateNextVersion) does the following in a temp dir:
 // - Extracts and unpacks setup.exe and the Chrome-bin folder from
 //   mini_installer.exe.
 // - Inspects setup.exe to determine the current version.
 // - Runs through all .dll and .exe files:
 //   - Replacing all occurrences of the Unicode version string in the files'
 //     resources with the updated string.
 //   - For all resources in which the string substitution is made, the binary
 //     form of the version is also replaced.
 // - Re-packs setup.exe and Chrome-bin.
 // - Inserts them into the target mini_installer.exe.
 //
 // This code assumes that the host program 1) initializes the process-wide
 // CommandLine instance, and 2) resides in the output directory of a build
 // tree.  When #2 is not the case, the --7za_path command-line switch may be
 // used to provide the (relative or absolute) path to the directory containing
 // 7za.exe.
 
 #include "chrome/installer/test/alternate_version_generator.h"
 
 #include <windows.h>
+#include <stddef.h>
+#include <stdint.h>
 
 #include <algorithm>
 #include <limits>
 #include <sstream>
 #include <utility>
 #include <vector>
 
-#include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/files/file.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/path_service.h"
 #include "base/process/launch.h"
 #include "base/process/process_handle.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/version.h"
 #include "base/win/pe_image.h"
 #include "base/win/scoped_handle.h"
 #include "chrome/installer/test/pe_image_resources.h"
 #include "chrome/installer/test/resource_loader.h"
@@ skipping 125 matching lines @@
   }
 }
 
 bool MappedFile::Initialize(base::File file) {
   DCHECK(mapping_ == NULL);
   bool result = false;
   base::File::Info file_info;
 
   if (file.GetInfo(&file_info)) {
     if (file_info.size <=
-        static_cast<int64>(std::numeric_limits<DWORD>::max())) {
+        static_cast<int64_t>(std::numeric_limits<DWORD>::max())) {
       mapping_ = CreateFileMapping(file.GetPlatformFile(), NULL, PAGE_READWRITE,
                                    0, static_cast<DWORD>(file_info.size), NULL);
       if (mapping_ != NULL) {
         view_ = MapViewOfFile(mapping_, FILE_MAP_WRITE, 0, 0,
                               static_cast<size_t>(file_info.size));
         if (view_ != NULL) {
           result = true;
         } else {
           PLOG(DFATAL) << "MapViewOfFile failed";
         }
@@ skipping 37 matching lines @@
 
   return result;
 }
 
 // Retrieves the version number of |pe_file| from its version
 // resource, placing the value in |version|.  Returns true on success.
 bool GetFileVersion(const base::FilePath& pe_file, ChromeVersion* version) {
   DCHECK(version);
   bool result = false;
   upgrade_test::ResourceLoader pe_file_loader;
-  std::pair<const uint8*, DWORD> version_info_data;
+  std::pair<const uint8_t*, DWORD> version_info_data;
 
   if (pe_file_loader.Initialize(pe_file) &&
       pe_file_loader.Load(
           VS_VERSION_INFO,
           static_cast<WORD>(reinterpret_cast<uintptr_t>(RT_VERSION)),
           &version_info_data)) {
     const VS_FIXEDFILEINFO* fixed_file_info;
     UINT ver_info_len;
     if (VerQueryValue(version_info_data.first, L"\\",
                       reinterpret_cast<void**>(
@@ skipping 16 matching lines @@
 bool GetSetupExeVersion(const base::FilePath& work_dir,
                         ChromeVersion* version) {
   return GetFileVersion(work_dir.Append(&kSetupExe[0]), version);
 }
 
 
 // Replace all occurrences in the sequence [|dest_first|, |dest_last) that
 // equals [|src_first|, |src_last) with the sequence at |replacement_first| of
 // the same length.  Returns true on success.  If non-NULL, |replacements_made|
 // is set to true/false accordingly.
-bool ReplaceAll(uint8* dest_first, uint8* dest_last,
-                const uint8* src_first, const uint8* src_last,
-                const uint8* replacement_first, bool* replacements_made) {
+bool ReplaceAll(uint8_t* dest_first,
+                uint8_t* dest_last,
+                const uint8_t* src_first,
+                const uint8_t* src_last,
+                const uint8_t* replacement_first,
+                bool* replacements_made) {
   bool result = true;
   bool changed = false;
   do {
     dest_first = std::search(dest_first, dest_last, src_first, src_last);
     if (dest_first == dest_last) {
       break;
     }
     changed = true;
     if (memcpy_s(dest_first, dest_last - dest_first,
                  replacement_first, src_last - src_first) != 0) {
@@ skipping 15 matching lines @@
   ChromeVersion current_version;
   std::wstring current_version_str;
   ChromeVersion new_version;
   std::wstring new_version_str;
 };  // struct VisitResourceContext
 
 // Replaces the old version with the new in a resource.  A first pass is made to
 // replace the string form (e.g., "9.0.584.0").  If any replacements are made, a
 // second pass is made to replace the binary form (e.g., 0x0000024800000009).
 void VisitResource(const upgrade_test::EntryPath& path,
-                   uint8* data, DWORD size, DWORD code_page,
+                   uint8_t* data,
+                   DWORD size,
+                   DWORD code_page,
                    uintptr_t context) {
   VisitResourceContext& ctx = *reinterpret_cast<VisitResourceContext*>(context);
 
   // Replace all occurrences of current_version_str with new_version_str
   bool changing_version = false;
   if (ReplaceAll(
-          data,
-          data + size,
-          reinterpret_cast<const uint8*>(ctx.current_version_str.c_str()),
-          reinterpret_cast<const uint8*>(ctx.current_version_str.c_str() +
-              ctx.current_version_str.size() + 1),
-          reinterpret_cast<const uint8*>(ctx.new_version_str.c_str()),
+          data, data + size,
+          reinterpret_cast<const uint8_t*>(ctx.current_version_str.c_str()),
+          reinterpret_cast<const uint8_t*>(ctx.current_version_str.c_str() +
+                                           ctx.current_version_str.size() + 1),
+          reinterpret_cast<const uint8_t*>(ctx.new_version_str.c_str()),
           &changing_version) &&
       changing_version) {
     // Replace all occurrences of current_version with new_version
     struct VersionPair {
       DWORD high;
       DWORD low;
     };
     VersionPair cur_ver = {
       ctx.current_version.high(), ctx.current_version.low()
     };
     VersionPair new_ver = {
       ctx.new_version.high(), ctx.new_version.low()
     };
-    ReplaceAll(data, data + size, reinterpret_cast<const uint8*>(&cur_ver),
-               reinterpret_cast<const uint8*>(&cur_ver) + sizeof(cur_ver),
-               reinterpret_cast<const uint8*>(&new_ver), NULL);
+    ReplaceAll(data, data + size, reinterpret_cast<const uint8_t*>(&cur_ver),
+               reinterpret_cast<const uint8_t*>(&cur_ver) + sizeof(cur_ver),
+               reinterpret_cast<const uint8_t*>(&new_ver), NULL);
   }
 }
 
 // Updates the version strings and numbers in all of |image_file|'s resources.
 bool UpdateVersionIfMatch(const base::FilePath& image_file,
                           VisitResourceContext* context) {
   if (!context ||
       context->current_version_str.size() < context->new_version_str.size()) {
     return false;
   }
 
   bool result = false;
-  uint32 flags = base::File::FLAG_OPEN | base::File::FLAG_READ |
-                 base::File::FLAG_WRITE | base::File::FLAG_EXCLUSIVE_READ |
-                 base::File::FLAG_EXCLUSIVE_WRITE;
+  uint32_t flags = base::File::FLAG_OPEN | base::File::FLAG_READ |
+                   base::File::FLAG_WRITE | base::File::FLAG_EXCLUSIVE_READ |
+                   base::File::FLAG_EXCLUSIVE_WRITE;
   base::File file(image_file, flags);
   // It turns out that the underlying CreateFile can fail due to unhelpful
   // security software locking the newly created DLL. So add a few brief
   // retries to help tests that use this pass on machines thusly encumbered.
   int retries = 3;
   while (!file.IsValid() && retries-- > 0) {
     LOG(WARNING) << "Failed to open \"" << image_file.value() << "\"."
                  << " Retrying " << retries << " more times.";
     Sleep(1000);
     file.Initialize(image_file, flags);
@@ skipping 156 matching lines @@
                 << "\" to \"" << mini_installer.value() << "\"";
     return false;
   }
 
   base::FilePath setup_ex_ = work_dir.directory().Append(&kSetupEx_[0]);
   base::FilePath chrome_packed_7z =
       work_dir.directory().Append(&kChromePacked7z[0]);
   // Load the original file and extract setup.ex_ and chrome.packed.7z
   {
     ResourceLoader resource_loader;
-    std::pair<const uint8*, DWORD> resource_data;
+    std::pair<const uint8_t*, DWORD> resource_data;
 
     if (!resource_loader.Initialize(mini_installer))
       return false;
 
     // Write out setup.ex_
     if (!resource_loader.Load(&kSetupEx_[0], &kBl[0], &resource_data))
       return false;
     int written =
         base::WriteFile(setup_ex_,
                         reinterpret_cast<const char*>(resource_data.first),
@@ skipping 142 matching lines @@
     return false;
   }
   ctx.current_version_str = ctx.current_version.ToString();
   ctx.new_version = ChromeVersion::FromString(version.GetString());
   ctx.new_version_str = ctx.new_version.ToString();
 
   return UpdateVersionIfMatch(target_file, &ctx);
 }
 
 }  // namespace upgrade_test