Switch to standard integer types in chrome/.

chrome/renderer/safe_browsing/phishing_term_feature_extractor.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/renderer/safe_browsing/phishing_term_feature_extractor.h"
 
 #include <list>
 #include <map>
 
 #include "base/bind.h"
@@ skipping 66 matching lines @@
     if (i->Init()) {
       iterator = i.Pass();
     } else {
       DLOG(ERROR) << "failed to open iterator";
     }
   }
 };
 
 PhishingTermFeatureExtractor::PhishingTermFeatureExtractor(
     const base::hash_set<std::string>* page_term_hashes,
-    const base::hash_set<uint32>* page_word_hashes,
+    const base::hash_set<uint32_t>* page_word_hashes,
     size_t max_words_per_term,
-    uint32 murmurhash3_seed,
+    uint32_t murmurhash3_seed,
     size_t max_shingles_per_page,
     size_t shingle_size,
     FeatureExtractorClock* clock)
     : page_term_hashes_(page_term_hashes),
       page_word_hashes_(page_word_hashes),
       max_words_per_term_(max_words_per_term),
       murmurhash3_seed_(murmurhash3_seed),
       max_shingles_per_page_(max_shingles_per_page),
       shingle_size_(shingle_size),
       clock_(clock),
       weak_factory_(this) {
   Clear();
 }
 
 PhishingTermFeatureExtractor::~PhishingTermFeatureExtractor() {
   // The RenderView should have called CancelPendingExtraction() before
   // we are destroyed.
   CheckNoPendingExtraction();
 }
 
 void PhishingTermFeatureExtractor::ExtractFeatures(
     const base::string16* page_text,
     FeatureMap* features,
-    std::set<uint32>* shingle_hashes,
+    std::set<uint32_t>* shingle_hashes,
     const DoneCallback& done_callback) {
   // The RenderView should have called CancelPendingExtraction() before
   // starting a new extraction, so DCHECK this.
   CheckNoPendingExtraction();
   // However, in an opt build, we will go ahead and clean up the pending
   // extraction so that we can start in a known state.
   CancelPendingExtraction();
 
   page_text_ = page_text;
   features_ = features;
@@ skipping 77 matching lines @@
   state_->shingle_word_sizes.push_back(word_lower.size() + 1);
   if (state_->shingle_word_sizes.size() == shingle_size_) {
     shingle_hashes_->insert(
         MurmurHash3String(state_->current_shingle, murmurhash3_seed_));
     state_->current_shingle.erase(0, state_->shingle_word_sizes.front());
     state_->shingle_word_sizes.pop_front();
   }
   // Check if the size of shingle hashes is over the limit.
   if (shingle_hashes_->size() > max_shingles_per_page_) {
     // Pop the largest one.
-    std::set<uint32>::iterator it = shingle_hashes_->end();
+    std::set<uint32_t>::iterator it = shingle_hashes_->end();
     shingle_hashes_->erase(--it);
   }
 
   // Next, extract page terms.
-  uint32 word_hash = MurmurHash3String(word_lower, murmurhash3_seed_);
+  uint32_t word_hash = MurmurHash3String(word_lower, murmurhash3_seed_);
 
   // Quick out if the word is not part of any term, which is the common case.
   if (page_word_hashes_->find(word_hash) == page_word_hashes_->end()) {
     // Word doesn't exist in our terms so we can clear the n-gram state.
     state_->previous_words.clear();
     state_->previous_word_sizes.clear();
     return;
   }
 
   // Find all of the n-grams that we need to check and compute their SHA-256
@@ skipping 63 matching lines @@
 
 void PhishingTermFeatureExtractor::Clear() {
   page_text_ = NULL;
   features_ = NULL;
   shingle_hashes_ = NULL;
   done_callback_.Reset();
   state_.reset(NULL);
 }
 
 }  // namespace safe_browsing