Switch to standard integer types in chrome/.

chrome/utility/importer/ie_importer_win.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/utility/importer/ie_importer_win.h"
 
 #include <ole2.h>
 #include <intshcut.h>
 #include <shlobj.h>
+#include <stddef.h>
 #include <urlhist.h>
 #include <wininet.h>
 
 #include <algorithm>
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/files/file_enumerator.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
+#include "base/macros.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "base/win/registry.h"
 #include "base/win/scoped_co_mem.h"
 #include "base/win/scoped_comptr.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/scoped_propvariant.h"
@@ skipping 42 matching lines @@
                  FILE_ATTRIBUTE_NORMAL | FILE_FLAG_BACKUP_SEMANTICS, NULL));
   FILETIME creation_filetime;
   if (!file_handle.IsValid())
     return creation_time;
   if (GetFileTime(file_handle.Get(), &creation_filetime, NULL, NULL))
     creation_time = base::Time::FromFileTime(creation_filetime);
   return creation_time;
 }
 
 // Safely read an object of type T from a raw sequence of bytes.
-template<typename T>
-bool BinaryRead(T* data, size_t offset, const std::vector<uint8>& blob) {
+template <typename T>
+bool BinaryRead(T* data, size_t offset, const std::vector<uint8_t>& blob) {
   if (offset + sizeof(T) > blob.size())
     return false;
   memcpy(data, &blob[offset], sizeof(T));
   return true;
 }
 
 // Safely read an ITEMIDLIST from a raw sequence of bytes.
 //
 // An ITEMIDLIST is a list of SHITEMIDs, terminated by a SHITEMID with
 // .cb = 0. Here, before simply casting &blob[offset] to LPITEMIDLIST,
 // we verify that the list structure is not overrunning the boundary of
 // the binary blob.
-LPCITEMIDLIST BinaryReadItemIDList(size_t offset, size_t idlist_size,
-                                   const std::vector<uint8>& blob) {
+LPCITEMIDLIST BinaryReadItemIDList(size_t offset,
+                                   size_t idlist_size,
+                                   const std::vector<uint8_t>& blob) {
   size_t head = 0;
   while (true) {
     // Use a USHORT instead of SHITEMID to avoid buffer over read.
     USHORT id_cb;
     if (head >= idlist_size || !BinaryRead(&id_cb, offset + head, blob))
       return NULL;
     if (id_cb == 0)
       break;
     head += id_cb;
   }
   return reinterpret_cast<LPCITEMIDLIST>(&blob[offset]);
 }
 
 // Compares the two bookmarks in the order of IE's Favorites menu.
 // Returns true if rhs should come later than lhs (lhs < rhs).
 struct IEOrderBookmarkComparator {
   bool operator()(const ImportedBookmarkEntry& lhs,
                   const ImportedBookmarkEntry& rhs) const {
-    static const uint32 kNotSorted = 0xfffffffb;  // IE uses this magic value.
+    static const uint32_t kNotSorted = 0xfffffffb;  // IE uses this magic value.
     base::FilePath lhs_prefix;
     base::FilePath rhs_prefix;
     for (size_t i = 0; i <= lhs.path.size() && i <= rhs.path.size(); ++i) {
       const base::FilePath::StringType lhs_i =
         (i < lhs.path.size() ? lhs.path[i] : lhs.title + L".url");
       const base::FilePath::StringType rhs_i =
         (i < rhs.path.size() ? rhs.path[i] : rhs.title + L".url");
       lhs_prefix = lhs_prefix.Append(lhs_i);
       rhs_prefix = rhs_prefix.Append(rhs_i);
       if (lhs_i == rhs_i)
         continue;
       // The first path element that differs between the two.
-      std::map<base::FilePath, uint32>::const_iterator lhs_iter =
-        sort_index_->find(lhs_prefix);
-      std::map<base::FilePath, uint32>::const_iterator rhs_iter =
-        sort_index_->find(rhs_prefix);
-      uint32 lhs_sort_index = (lhs_iter == sort_index_->end() ? kNotSorted
-        : lhs_iter->second);
-      uint32 rhs_sort_index = (rhs_iter == sort_index_->end() ? kNotSorted
-        : rhs_iter->second);
+      std::map<base::FilePath, uint32_t>::const_iterator lhs_iter =
+          sort_index_->find(lhs_prefix);
+      std::map<base::FilePath, uint32_t>::const_iterator rhs_iter =
+          sort_index_->find(rhs_prefix);
+      uint32_t lhs_sort_index =
+          (lhs_iter == sort_index_->end() ? kNotSorted : lhs_iter->second);
+      uint32_t rhs_sort_index =
+          (rhs_iter == sort_index_->end() ? kNotSorted : rhs_iter->second);
       if (lhs_sort_index != rhs_sort_index)
         return lhs_sort_index < rhs_sort_index;
       // If they have the same sort order, sort alphabetically.
       return lhs_i < rhs_i;
     }
     return lhs.path.size() < rhs.path.size();
   }
-  const std::map<base::FilePath, uint32>* sort_index_;
+  const std::map<base::FilePath, uint32_t>* sort_index_;
 };
 
 // IE stores the order of the Favorites menu in registry under:
 // HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\MenuOrder\Favorites.
 // The folder hierarchy of Favorites menu is directly mapped to the key
 // hierarchy in the registry.
 //
 // If the order of the items in a folder is customized by user, the order is
 // recorded in the REG_BINARY value named "Order" of the corresponding key.
 // The content of the "Order" value is a raw binary dump of an array of the
 // following data structure
 //   struct {
-//     uint32 size;  // Note that ITEMIDLIST is variably-sized.
-//     uint32 sort_index;  // 0 means this is the first item, 1 the second, ...
+//     uint32_t size;  // Note that ITEMIDLIST is variably-sized.
+//     uint32_t sort_index;  // 0 means this is the first item, 1 the second,
+//     ...
 //     ITEMIDLIST item_id;
 //   };
 // where each item_id should correspond to a favorites link file (*.url) in
 // the current folder.
 // gcc, in its infinite wisdom, only allows WARN_UNUSED_RESULT for prototypes.
 // Clang, to be compatible with gcc, warns if WARN_UNUSED_RESULT is used in a
 // non-gcc compatible manner (-Wgcc-compat). So even though gcc isn't used to
 // build on Windows, declare some prototypes anyway to satisfy Clang's gcc
 // compatibility warnings.
 bool ParseFavoritesOrderBlob(const Importer* importer,
-                             const std::vector<uint8>& blob,
+                             const std::vector<uint8_t>& blob,
                              const base::FilePath& path,
-                             std::map<base::FilePath, uint32>* sort_index)
+                             std::map<base::FilePath, uint32_t>* sort_index)
     WARN_UNUSED_RESULT;
 bool ParseFavoritesOrderBlob(const Importer* importer,
-                             const std::vector<uint8>& blob,
+                             const std::vector<uint8_t>& blob,
                              const base::FilePath& path,
-                             std::map<base::FilePath, uint32>* sort_index) {
+                             std::map<base::FilePath, uint32_t>* sort_index) {
   static const int kItemCountOffset = 16;
   static const int kItemListStartOffset = 20;
 
   // Read the number of items.
-  uint32 item_count = 0;
+  uint32_t item_count = 0;
   if (!BinaryRead(&item_count, kItemCountOffset, blob))
     return false;
 
   // Traverse over the items.
   size_t base_offset = kItemListStartOffset;
-  for (uint32 i = 0; i < item_count && !importer->cancelled(); ++i) {
+  for (uint32_t i = 0; i < item_count && !importer->cancelled(); ++i) {
     static const int kSizeOffset = 0;
     static const int kSortIndexOffset = 4;
     static const int kItemIDListOffset = 8;
 
     // Read the size (number of bytes) of the current item.
-    uint32 item_size = 0;
+    uint32_t item_size = 0;
     if (!BinaryRead(&item_size, base_offset + kSizeOffset, blob) ||
         base_offset + item_size <= base_offset ||  // checking overflow
         base_offset + item_size > blob.size())
       return false;
 
     // Read the sort index of the current item.
-    uint32 item_sort_index = 0;
+    uint32_t item_sort_index = 0;
     if (!BinaryRead(&item_sort_index, base_offset + kSortIndexOffset, blob))
       return false;
 
     // Read the file name from the ITEMIDLIST structure.
     LPCITEMIDLIST idlist = BinaryReadItemIDList(
       base_offset + kItemIDListOffset, item_size - kItemIDListOffset, blob);
     TCHAR item_filename[MAX_PATH];
     if (!idlist || !SHGetPathFromIDList(idlist, item_filename))
       return false;
     base::FilePath item_relative_path =
       path.Append(base::FilePath(item_filename).BaseName());
 
     // Record the retrieved information and go to the next item.
     sort_index->insert(std::make_pair(item_relative_path, item_sort_index));
     base_offset += item_size;
   }
   return true;
 }
 
 bool ParseFavoritesOrderRegistryTree(
     const Importer* importer,
     const base::win::RegKey& key,
     const base::FilePath& path,
-    std::map<base::FilePath, uint32>* sort_index) WARN_UNUSED_RESULT;
+    std::map<base::FilePath, uint32_t>* sort_index) WARN_UNUSED_RESULT;
 bool ParseFavoritesOrderRegistryTree(
     const Importer* importer,
     const base::win::RegKey& key,
     const base::FilePath& path,
-    std::map<base::FilePath, uint32>* sort_index) {
+    std::map<base::FilePath, uint32_t>* sort_index) {
   // Parse the order information of the current folder.
   DWORD blob_length = 0;
   if (key.ReadValue(L"Order", NULL, &blob_length, NULL) == ERROR_SUCCESS) {
-    std::vector<uint8> blob(blob_length);
+    std::vector<uint8_t> blob(blob_length);
     if (blob_length > 0 &&
         key.ReadValue(L"Order", reinterpret_cast<DWORD*>(&blob[0]),
                       &blob_length, NULL) == ERROR_SUCCESS) {
       if (!ParseFavoritesOrderBlob(importer, blob, path, sort_index))
         return false;
     }
   }
 
   // Recursively parse subfolders.
   for (base::win::RegistryKeyIterator child(key.Handle(), L"");
        child.Valid() && !importer->cancelled();
        ++child) {
     base::win::RegKey subkey(key.Handle(), child.Name(), KEY_READ);
     if (subkey.Valid()) {
       base::FilePath subpath(path.Append(child.Name()));
       if (!ParseFavoritesOrderRegistryTree(importer, subkey, subpath,
                                            sort_index)) {
         return false;
       }
     }
   }
   return true;
 }
 
 bool ParseFavoritesOrderInfo(const Importer* importer,
-                             std::map<base::FilePath, uint32>* sort_index)
+                             std::map<base::FilePath, uint32_t>* sort_index)
     WARN_UNUSED_RESULT;
 bool ParseFavoritesOrderInfo(const Importer* importer,
-                             std::map<base::FilePath, uint32>* sort_index) {
+                             std::map<base::FilePath, uint32_t>* sort_index) {
   base::string16 key_path(importer::GetIEFavoritesOrderKey());
   base::win::RegKey key(HKEY_CURRENT_USER, key_path.c_str(), KEY_READ);
   if (!key.Valid())
     return false;
   return ParseFavoritesOrderRegistryTree(importer, key, base::FilePath(),
                                          sort_index);
 }
 
 // Reads the sort order from registry. If failed, we don't touch the list
 // and use the default (alphabetical) order.
 void SortBookmarksInIEOrder(
     const Importer* importer,
     std::vector<ImportedBookmarkEntry>* bookmarks) {
-  std::map<base::FilePath, uint32> sort_index;
+  std::map<base::FilePath, uint32_t> sort_index;
   if (!ParseFavoritesOrderInfo(importer, &sort_index))
     return;
   IEOrderBookmarkComparator compare = {&sort_index};
   std::sort(bookmarks->begin(), bookmarks->end(), compare);
 }
 
 // Reads an internet shortcut (*.url) |file| and returns a COM object
 // representing it.
 bool LoadInternetShortcut(
     const base::string16& file,
@@ skipping 129 matching lines @@
 };
 // {A79029D6-753E-4e27-B807-3D46AB1545DF}
 const GUID IEImporter::kUnittestGUID = {
     0xa79029d6, 0x753e, 0x4e27,
     { 0xb8, 0x7, 0x3d, 0x46, 0xab, 0x15, 0x45, 0xdf }
 };
 
 IEImporter::IEImporter() : edge_import_mode_(false) {}
 
 void IEImporter::StartImport(const importer::SourceProfile& source_profile,
-                             uint16 items,
+                             uint16_t items,
                              ImporterBridge* bridge) {
   edge_import_mode_ = source_profile.importer_type == importer::TYPE_EDGE;
   bridge_ = bridge;
 
   if (edge_import_mode_) {
     // When using for Edge imports we only support Favorites.
     DCHECK_EQ(items, importer::FAVORITES);
     // As coming from untrusted source ensure items is correct.
     items = importer::FAVORITES;
   }
@@ skipping 476 matching lines @@
   static int version = -1;
   if (version < 0) {
     wchar_t buffer[128];
     DWORD buffer_length = sizeof(buffer);
     base::win::RegKey reg_key(HKEY_LOCAL_MACHINE, kIEVersionKey, KEY_READ);
     LONG result = reg_key.ReadValue(L"Version", buffer, &buffer_length, NULL);
     version = ((result == ERROR_SUCCESS)? _wtoi(buffer) : 0);
   }
   return version;
 }