Switch to standard integer types in chrome/.

chrome/installer/util/shell_util.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.
 //
 // This file defines functions that integrate Chrome in Windows shell. These
 // functions can be used by Chrome as well as Chrome installer. All of the
 // work is done by the local functions defined in anonymous namespace in
 // this class.
 
 #include "chrome/installer/util/shell_util.h"
 
 #include <windows.h>
 #include <shlobj.h>
 #include <shobjidl.h>
 
 #include <limits>
 #include <string>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/md5.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/path_service.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 575 matching lines @@
   // start->Internet shortcut.
   base::string16 start_menu(ShellUtil::kRegStartMenuInternet);
   base::string16 app_name = dist->GetBaseAppName() + suffix;
   entries->push_back(new RegistryEntry(start_menu, app_name));
 }
 
 // Checks that all |entries| are present on this computer (or absent if their
 // |removal_flag_| is set). |look_for_in| is passed to
 // RegistryEntry::ExistsInRegistry(). Documentation for it can be found there.
 bool AreEntriesAsDesired(const ScopedVector<RegistryEntry>& entries,
-                          uint32 look_for_in) {
+                         uint32_t look_for_in) {
   for (const auto* entry : entries) {
     if (entry->ExistsInRegistry(look_for_in) != !entry->IsFlaggedForRemoval())
       return false;
   }
   return true;
 }
 
 // Checks that all required registry entries for Chrome are already present on
 // this computer (or absent if their |removal_flag_| is set).
 // See RegistryEntry::ExistsInRegistry for the behavior of |look_for_in|.
 // Note: between r133333 and r154145 we were registering parts of Chrome in HKCU
 // and parts in HKLM for user-level installs; we now always register everything
 // under a single registry root. Not doing so caused http://crbug.com/144910 for
 // users who first-installed Chrome in that revision range (those users are
 // still impacted by http://crbug.com/144910). This method will keep returning
 // true for affected users (i.e. who have all the registrations, but over both
 // registry roots).
 bool IsChromeRegistered(BrowserDistribution* dist,
                         const base::FilePath& chrome_exe,
                         const base::string16& suffix,
-                        uint32 look_for_in) {
+                        uint32_t look_for_in) {
   ScopedVector<RegistryEntry> entries;
   GetChromeProgIdEntries(dist, chrome_exe, suffix, &entries);
   GetShellIntegrationEntries(dist, chrome_exe, suffix, &entries);
   GetChromeAppRegistrationEntries(chrome_exe, suffix, &entries);
   return AreEntriesAsDesired(entries, look_for_in);
 }
 
 // This method checks if Chrome is already registered on the local machine
 // for the requested protocol. It just checks the one value required for this.
 // See RegistryEntry::ExistsInRegistry for the behavior of |look_for_in|.
 bool IsChromeRegisteredForProtocol(BrowserDistribution* dist,
                                    const base::string16& suffix,
                                    const base::string16& protocol,
-                                   uint32 look_for_in) {
+                                   uint32_t look_for_in) {
   ScopedVector<RegistryEntry> entries;
   GetProtocolCapabilityEntries(dist, suffix, protocol, &entries);
   return AreEntriesAsDesired(entries, look_for_in);
 }
 
 // This method registers Chrome on Vista by launching an elevated setup.exe.
 // That will show the user the standard Vista elevation prompt. If the user
 // accepts it the new process will make the necessary changes and return SUCCESS
 // that we capture and return.
 // If protocol is non-empty we will also register Chrome as being capable of
@@ skipping 1359 matching lines @@
 
   RemoveRunVerbOnWindows8(dist, chrome_exe);
 
   bool user_level = InstallUtil::IsPerUserInstall(chrome_exe);
   HKEY root = DetermineRegistrationRoot(user_level);
 
   // Look only in HKLM for system-level installs (otherwise, if a user-level
   // install is also present, it will lead IsChromeRegistered() to think this
   // system-level install isn't registered properly as it is shadowed by the
   // user-level install's registrations).
-  uint32 look_for_in = user_level ?
-      RegistryEntry::LOOK_IN_HKCU_THEN_HKLM : RegistryEntry::LOOK_IN_HKLM;
+  uint32_t look_for_in = user_level ? RegistryEntry::LOOK_IN_HKCU_THEN_HKLM
+                                    : RegistryEntry::LOOK_IN_HKLM;
 
   // Check if chrome is already registered with this suffix.
   if (IsChromeRegistered(dist, chrome_exe, suffix, look_for_in))
     return true;
 
   bool result = true;
   if (root == HKEY_CURRENT_USER || IsUserAnAdmin()) {
     // Do the full registration if we can do it at user-level or if the user is
     // an admin.
     ScopedVector<RegistryEntry> progid_and_appreg_entries;
@@ skipping 60 matching lines @@
     return false;
   }
 
   bool user_level = InstallUtil::IsPerUserInstall(chrome_exe);
   HKEY root = DetermineRegistrationRoot(user_level);
 
   // Look only in HKLM for system-level installs (otherwise, if a user-level
   // install is also present, it could lead IsChromeRegisteredForProtocol() to
   // think this system-level install isn't registered properly as it may be
   // shadowed by the user-level install's registrations).
-  uint32 look_for_in = user_level ?
-      RegistryEntry::LOOK_IN_HKCU_THEN_HKLM : RegistryEntry::LOOK_IN_HKLM;
+  uint32_t look_for_in = user_level ? RegistryEntry::LOOK_IN_HKCU_THEN_HKLM
+                                    : RegistryEntry::LOOK_IN_HKLM;
 
   // Check if chrome is already registered with this suffix.
   if (IsChromeRegisteredForProtocol(dist, suffix, protocol, look_for_in))
     return true;
 
   if (root == HKEY_CURRENT_USER || IsUserAnAdmin()) {
     // We can do this operation directly.
     // First, make sure Chrome is fully registered on this machine.
     if (!RegisterChromeBrowser(dist, chrome_exe, suffix, false))
       return false;
@@ skipping 88 matching lines @@
   if (::GetUserName(user_name, &size) == 0 || size < 1) {
     NOTREACHED();
     return false;
   }
   suffix->reserve(size);
   suffix->assign(1, L'.');
   suffix->append(user_name, size - 1);
   return true;
 }
 
-base::string16 ShellUtil::ByteArrayToBase32(const uint8* bytes, size_t size) {
+base::string16 ShellUtil::ByteArrayToBase32(const uint8_t* bytes, size_t size) {
   static const char kEncoding[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
 
   // Eliminate special cases first.
   if (size == 0) {
     return base::string16();
   } else if (size == 1) {
     base::string16 ret;
     ret.push_back(kEncoding[(bytes[0] & 0xf8) >> 3]);
     ret.push_back(kEncoding[(bytes[0] & 0x07) << 2]);
     return ret;
   } else if (size >= std::numeric_limits<size_t>::max() / 8) {
     // If |size| is too big, the calculation of |encoded_length| below will
     // overflow.
     NOTREACHED();
     return base::string16();
   }
 
   // Overestimate the number of bits in the string by 4 so that dividing by 5
   // is the equivalent of rounding up the actual number of bits divided by 5.
   const size_t encoded_length = (size * 8 + 4) / 5;
 
   base::string16 ret;
   ret.reserve(encoded_length);
 
   // A bit stream which will be read from the left and appended to from the
   // right as it's emptied.
-  uint16 bit_stream = (bytes[0] << 8) + bytes[1];
+  uint16_t bit_stream = (bytes[0] << 8) + bytes[1];
   size_t next_byte_index = 2;
   int free_bits = 0;
   while (free_bits < 16) {
     // Extract the 5 leftmost bits in the stream
     ret.push_back(kEncoding[(bit_stream & 0xf800) >> 11]);
     bit_stream <<= 5;
     free_bits += 5;
 
     // If there is enough room in the bit stream, inject another byte (if there
     // are any left...).
@@ skipping 70 matching lines @@
        itr != entries.end(); ++itr)
     (*itr)->AddToWorkItemList(root, items.get());
 
   // Apply all the registry changes and if there is a problem, rollback
   if (!items->Do()) {
     items->Rollback();
     return false;
   }
   return true;
 }