Switch to standard integer types in components/, part 3 of 4.

components/omnibox/browser/url_index_private_data.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 "components/omnibox/browser/url_index_private_data.h"
 
+#include <stdint.h>
+
 #include <functional>
 #include <iterator>
 #include <limits>
 #include <numeric>
 #include <string>
 #include <vector>
 
-#include "base/basictypes.h"
 #include "base/files/file_util.h"
 #include "base/i18n/break_iterator.h"
 #include "base/i18n/case_conversion.h"
+#include "base/macros.h"
 #include "base/metrics/histogram.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 "components/bookmarks/browser/bookmark_model.h"
 #include "components/bookmarks/browser/bookmark_utils.h"
 #include "components/history/core/browser/history_database.h"
 #include "components/history/core/browser/history_db_task.h"
 #include "components/history/core/browser/history_service.h"
@@ skipping 1042 matching lines @@
   return RestoreWordList(cache) && RestoreWordMap(cache) &&
       RestoreCharWordMap(cache) && RestoreWordIDHistoryMap(cache) &&
       RestoreHistoryInfoMap(cache) && RestoreWordStartsMap(cache, languages);
 }
 
 bool URLIndexPrivateData::RestoreWordList(
     const InMemoryURLIndexCacheItem& cache) {
   if (!cache.has_word_list())
     return false;
   const WordListItem& list_item(cache.word_list());
-  uint32 expected_item_count = list_item.word_count();
-  uint32 actual_item_count = list_item.word_size();
+  uint32_t expected_item_count = list_item.word_count();
+  uint32_t actual_item_count = list_item.word_size();
   if (actual_item_count == 0 || actual_item_count != expected_item_count)
     return false;
   const RepeatedPtrField<std::string>& words(list_item.word());
   for (RepeatedPtrField<std::string>::const_iterator iter = words.begin();
        iter != words.end(); ++iter)
     word_list_.push_back(base::UTF8ToUTF16(*iter));
   return true;
 }
 
 bool URLIndexPrivateData::RestoreWordMap(
     const InMemoryURLIndexCacheItem& cache) {
   if (!cache.has_word_map())
     return false;
   const WordMapItem& list_item(cache.word_map());
-  uint32 expected_item_count = list_item.item_count();
-  uint32 actual_item_count = list_item.word_map_entry_size();
+  uint32_t expected_item_count = list_item.item_count();
+  uint32_t actual_item_count = list_item.word_map_entry_size();
   if (actual_item_count == 0 || actual_item_count != expected_item_count)
     return false;
   const RepeatedPtrField<WordMapEntry>& entries(list_item.word_map_entry());
   for (RepeatedPtrField<WordMapEntry>::const_iterator iter = entries.begin();
        iter != entries.end(); ++iter)
     word_map_[base::UTF8ToUTF16(iter->word())] = iter->word_id();
   return true;
 }
 
 bool URLIndexPrivateData::RestoreCharWordMap(
     const InMemoryURLIndexCacheItem& cache) {
   if (!cache.has_char_word_map())
     return false;
   const CharWordMapItem& list_item(cache.char_word_map());
-  uint32 expected_item_count = list_item.item_count();
-  uint32 actual_item_count = list_item.char_word_map_entry_size();
+  uint32_t expected_item_count = list_item.item_count();
+  uint32_t actual_item_count = list_item.char_word_map_entry_size();
   if (actual_item_count == 0 || actual_item_count != expected_item_count)
     return false;
   const RepeatedPtrField<CharWordMapEntry>&
       entries(list_item.char_word_map_entry());
   for (RepeatedPtrField<CharWordMapEntry>::const_iterator iter =
        entries.begin(); iter != entries.end(); ++iter) {
     expected_item_count = iter->item_count();
     actual_item_count = iter->word_id_size();
     if (actual_item_count == 0 || actual_item_count != expected_item_count)
       return false;
     base::char16 uni_char = static_cast<base::char16>(iter->char_16());
     WordIDSet word_id_set;
-    const RepeatedField<int32>& word_ids(iter->word_id());
-    for (RepeatedField<int32>::const_iterator jiter = word_ids.begin();
+    const RepeatedField<int32_t>& word_ids(iter->word_id());
+    for (RepeatedField<int32_t>::const_iterator jiter = word_ids.begin();
          jiter != word_ids.end(); ++jiter)
       word_id_set.insert(*jiter);
     char_word_map_[uni_char] = word_id_set;
   }
   return true;
 }
 
 bool URLIndexPrivateData::RestoreWordIDHistoryMap(
     const InMemoryURLIndexCacheItem& cache) {
   if (!cache.has_word_id_history_map())
     return false;
   const WordIDHistoryMapItem& list_item(cache.word_id_history_map());
-  uint32 expected_item_count = list_item.item_count();
-  uint32 actual_item_count = list_item.word_id_history_map_entry_size();
+  uint32_t expected_item_count = list_item.item_count();
+  uint32_t actual_item_count = list_item.word_id_history_map_entry_size();
   if (actual_item_count == 0 || actual_item_count != expected_item_count)
     return false;
   const RepeatedPtrField<WordIDHistoryMapEntry>&
       entries(list_item.word_id_history_map_entry());
   for (RepeatedPtrField<WordIDHistoryMapEntry>::const_iterator iter =
        entries.begin(); iter != entries.end(); ++iter) {
     expected_item_count = iter->item_count();
     actual_item_count = iter->history_id_size();
     if (actual_item_count == 0 || actual_item_count != expected_item_count)
       return false;
     WordID word_id = iter->word_id();
     HistoryIDSet history_id_set;
-    const RepeatedField<int64>& history_ids(iter->history_id());
-    for (RepeatedField<int64>::const_iterator jiter = history_ids.begin();
+    const RepeatedField<int64_t>& history_ids(iter->history_id());
+    for (RepeatedField<int64_t>::const_iterator jiter = history_ids.begin();
          jiter != history_ids.end(); ++jiter) {
       history_id_set.insert(*jiter);
       AddToHistoryIDWordMap(*jiter, word_id);
     }
     word_id_history_map_[word_id] = history_id_set;
   }
   return true;
 }
 
 bool URLIndexPrivateData::RestoreHistoryInfoMap(
     const InMemoryURLIndexCacheItem& cache) {
   if (!cache.has_history_info_map())
     return false;
   const HistoryInfoMapItem& list_item(cache.history_info_map());
-  uint32 expected_item_count = list_item.item_count();
-  uint32 actual_item_count = list_item.history_info_map_entry_size();
+  uint32_t expected_item_count = list_item.item_count();
+  uint32_t actual_item_count = list_item.history_info_map_entry_size();
   if (actual_item_count == 0 || actual_item_count != expected_item_count)
     return false;
   const RepeatedPtrField<HistoryInfoMapEntry>&
       entries(list_item.history_info_map_entry());
   for (RepeatedPtrField<HistoryInfoMapEntry>::const_iterator iter =
        entries.begin(); iter != entries.end(); ++iter) {
     HistoryID history_id = iter->history_id();
     GURL url(iter->url());
     history::URLRow url_row(url, history_id);
     url_row.set_visit_count(iter->visit_count());
@@ skipping 19 matching lines @@
 }
 
 bool URLIndexPrivateData::RestoreWordStartsMap(
     const InMemoryURLIndexCacheItem& cache,
     const std::string& languages) {
   // Note that this function must be called after RestoreHistoryInfoMap() has
   // been run as the word starts may have to be recalculated from the urls and
   // page titles.
   if (cache.has_word_starts_map()) {
     const WordStartsMapItem& list_item(cache.word_starts_map());
-    uint32 expected_item_count = list_item.item_count();
-    uint32 actual_item_count = list_item.word_starts_map_entry_size();
+    uint32_t expected_item_count = list_item.item_count();
+    uint32_t actual_item_count = list_item.word_starts_map_entry_size();
     if (actual_item_count == 0 || actual_item_count != expected_item_count)
       return false;
     const RepeatedPtrField<WordStartsMapEntry>&
         entries(list_item.word_starts_map_entry());
     for (RepeatedPtrField<WordStartsMapEntry>::const_iterator iter =
          entries.begin(); iter != entries.end(); ++iter) {
       HistoryID history_id = iter->history_id();
       RowWordStarts word_starts;
       // Restore the URL word starts.
-      const RepeatedField<int32>& url_starts(iter->url_word_starts());
-      for (RepeatedField<int32>::const_iterator jiter = url_starts.begin();
+      const RepeatedField<int32_t>& url_starts(iter->url_word_starts());
+      for (RepeatedField<int32_t>::const_iterator jiter = url_starts.begin();
            jiter != url_starts.end(); ++jiter)
         word_starts.url_word_starts_.push_back(*jiter);
       // Restore the page title word starts.
-      const RepeatedField<int32>& title_starts(iter->title_word_starts());
-      for (RepeatedField<int32>::const_iterator jiter = title_starts.begin();
+      const RepeatedField<int32_t>& title_starts(iter->title_word_starts());
+      for (RepeatedField<int32_t>::const_iterator jiter = title_starts.begin();
            jiter != title_starts.end(); ++jiter)
         word_starts.title_word_starts_.push_back(*jiter);
       word_starts_map_[history_id] = word_starts;
     }
   } else {
     // Since the cache did not contain any word starts we must rebuild then from
     // the URL and page titles.
     for (HistoryInfoMap::const_iterator iter = history_info_map_.begin();
          iter != history_info_map_.end(); ++iter) {
       RowWordStarts word_starts;
@@ skipping 116 matching lines @@
   // First cut: typed count, visit count, recency.
   // TODO(mrossetti): This is too simplistic. Consider an approach which ranks
   // recently visited (within the last 12/24 hours) as highly important. Get
   // input from mpearson.
   if (r1.typed_count() != r2.typed_count())
     return (r1.typed_count() > r2.typed_count());
   if (r1.visit_count() != r2.visit_count())
     return (r1.visit_count() > r2.visit_count());
   return (r1.last_visit() > r2.last_visit());
 }