Switch to standard integer types in third_party/hunspell/google/.

third_party/hunspell/google/bdict_reader.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 "third_party/hunspell/google/bdict_reader.h"
 
+#include <stdint.h>
+
 #include "base/logging.h"
 
 namespace hunspell {
 
 // Like the "Visitor" design pattern, this lightweight object provides an
 // interface around a serialized trie node at the given address in the memory.
 class NodeReader {
  public:
   // Return values for GetChildAt.
   enum FindResult {
@@ skipping 308 matching lines @@
   // We may or may not need to ignore that first value we just read, since it
   // could be a dummy placeholder value. The |list_offset| is the starting
   // position in the output list to write the rest of the values, which may
   // overwrite the first value.
   int list_offset = 1;
   if (affix_indices[0] == BDict::FIRST_AFFIX_IS_UNUSED)
     list_offset = 0;
 
   // Save the end pointer (accounting for an odd number of bytes).
   size_t array_start = node_offset_ + additional_bytes + 2;
-  const uint16* const bdict_short_end = reinterpret_cast<const uint16*>(
+  const uint16_t* const bdict_short_end = reinterpret_cast<const uint16_t*>(
       &bdict_data_[((bdict_length_ - array_start) & -2) + array_start]);
   // Process all remaining matches.
-  const uint16* following_array = reinterpret_cast<const uint16*>(
-      &bdict_data_[array_start]);
+  const uint16_t* following_array =
+      reinterpret_cast<const uint16_t*>(&bdict_data_[array_start]);
   for (int i = 0; i < BDict::MAX_AFFIXES_PER_WORD - list_offset; i++) {
     if (&following_array[i] >= bdict_short_end) {
       is_valid_ = false;
       return 0;
     }
     if (following_array[i] == BDict::LEAF_NODE_FOLLOWING_LIST_TERMINATOR)
       return i + list_offset;  // Found the end of the list.
     affix_indices[i + list_offset] = following_array[i];
   }
   return BDict::MAX_AFFIXES_PER_WORD;
@@ skipping 365 matching lines @@
       header_->dic_offset > bdict_length)
     return false;
 
   // Get the affix header, make sure there is enough room for it.
   if (header_->aff_offset + sizeof(BDict::AffHeader) > bdict_length)
     return false;
   aff_header_ = reinterpret_cast<const BDict::AffHeader*>(
       &bdict_data[header_->aff_offset]);
 
   // Make sure there is enough room for the affix group count dword.
-  if (aff_header_->affix_group_offset > bdict_length - sizeof(uint32))
+  if (aff_header_->affix_group_offset > bdict_length - sizeof(uint32_t))
     return false;
 
   // This function is called from SpellCheck::SpellCheckWord(), which blocks
   // WebKit. To avoid blocking WebKit for a long time, we do not check the MD5
   // digest here. Instead we check the MD5 digest when Chrome finishes
   // downloading a dictionary.
 
   // Don't set these until the end. This way, NULL bdict_data_ will indicate
   // failure.
   bdict_data_ = bdict_data;
@@ skipping 48 matching lines @@
                              aff_header_->rep_offset);
 }
 
 
 WordIterator BDictReader::GetAllWordIterator() const {
   NodeReader reader(bdict_data_, bdict_length_, header_->dic_offset, 0);
   return WordIterator(reader);
 }
 
 }  // namespace hunspell