Switch to standard integer types in chrome/browser/, part 4 of 4.

chrome/browser/spellchecker/feedback_sender.cc

 // Copyright (c) 2013 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.
 //
 // The |FeedbackSender| object stores the user feedback to spellcheck
 // suggestions in a |Feedback| object.
 //
 // When spelling service returns spellcheck results, these results first arrive
 // in |FeedbackSender| to assign hash identifiers for each
 // misspelling-suggestion pair. If the spelling service identifies the same
@@ skipping 51 matching lines @@
 const size_t kMaxFeedbackSizeBytes = 10 * 1024 * 1024;  // 10 MB
 
 // The default URL where feedback data is sent.
 const char kFeedbackServiceURL[] = "https://www.googleapis.com/rpc";
 
 // The minimum number of seconds between sending batches of feedback.
 const int kMinIntervalSeconds = 5;
 
 // Returns a hash of |session_start|, the current timestamp, and
 // |suggestion_index|.
-uint32 BuildHash(const base::Time& session_start, size_t suggestion_index) {
+uint32_t BuildHash(const base::Time& session_start, size_t suggestion_index) {
   return base::Hash(
       base::StringPrintf("%" PRId64 "%" PRId64 "%" PRIuS,
                          session_start.ToInternalValue(),
                          base::Time::Now().ToInternalValue(),
                          suggestion_index));
 }
 
 // Returns a pending feedback data structure for the spellcheck |result| and
 // |text|.
 Misspelling BuildFeedback(const SpellCheckResult& result,
@@ skipping 95 matching lines @@
           switches::kSpellingServiceFeedbackUrl)) {
     feedback_service_url_ =
         GURL(base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
             switches::kSpellingServiceFeedbackUrl));
   }
 }
 
 FeedbackSender::~FeedbackSender() {
 }
 
-void FeedbackSender::SelectedSuggestion(uint32 hash, int suggestion_index) {
+void FeedbackSender::SelectedSuggestion(uint32_t hash, int suggestion_index) {
   Misspelling* misspelling = feedback_.GetMisspelling(hash);
   // GetMisspelling() returns null for flushed feedback. Feedback is flushed
   // when the session expires every |kSessionHours| hours.
   if (!misspelling)
     return;
   misspelling->action.set_type(SpellcheckAction::TYPE_SELECT);
   misspelling->action.set_index(suggestion_index);
   misspelling->timestamp = base::Time::Now();
 }
 
-void FeedbackSender::AddedToDictionary(uint32 hash) {
+void FeedbackSender::AddedToDictionary(uint32_t hash) {
   Misspelling* misspelling = feedback_.GetMisspelling(hash);
   // GetMisspelling() returns null for flushed feedback. Feedback is flushed
   // when the session expires every |kSessionHours| hours.
   if (!misspelling)
     return;
   misspelling->action.set_type(SpellcheckAction::TYPE_ADD_TO_DICT);
   misspelling->timestamp = base::Time::Now();
-  const std::set<uint32>& hashes =
+  const std::set<uint32_t>& hashes =
       feedback_.FindMisspellings(GetMisspelledString(*misspelling));
-  for (std::set<uint32>::const_iterator hash_it = hashes.begin();
-       hash_it != hashes.end();
-       ++hash_it) {
+  for (std::set<uint32_t>::const_iterator hash_it = hashes.begin();
+       hash_it != hashes.end(); ++hash_it) {
     Misspelling* duplicate_misspelling = feedback_.GetMisspelling(*hash_it);
     if (!duplicate_misspelling || duplicate_misspelling->action.IsFinal())
       continue;
     duplicate_misspelling->action.set_type(SpellcheckAction::TYPE_ADD_TO_DICT);
     duplicate_misspelling->timestamp = misspelling->timestamp;
   }
 }
 
-void FeedbackSender::RecordInDictionary(uint32 hash) {
+void FeedbackSender::RecordInDictionary(uint32_t hash) {
   Misspelling* misspelling = feedback_.GetMisspelling(hash);
   // GetMisspelling() returns null for flushed feedback. Feedback is flushed
   // when the session expires every |kSessionHours| hours.
   if (!misspelling)
     return;
   misspelling->action.set_type(SpellcheckAction::TYPE_IN_DICTIONARY);
 }
 
-void FeedbackSender::IgnoredSuggestions(uint32 hash) {
+void FeedbackSender::IgnoredSuggestions(uint32_t hash) {
   Misspelling* misspelling = feedback_.GetMisspelling(hash);
   // GetMisspelling() returns null for flushed feedback. Feedback is flushed
   // when the session expires every |kSessionHours| hours.
   if (!misspelling)
     return;
   misspelling->action.set_type(SpellcheckAction::TYPE_PENDING_IGNORE);
   misspelling->timestamp = base::Time::Now();
 }
 
-void FeedbackSender::ManuallyCorrected(uint32 hash,
+void FeedbackSender::ManuallyCorrected(uint32_t hash,
                                        const base::string16& correction) {
   Misspelling* misspelling = feedback_.GetMisspelling(hash);
   // GetMisspelling() returns null for flushed feedback. Feedback is flushed
   // when the session expires every |kSessionHours| hours.
   if (!misspelling)
     return;
   misspelling->action.set_type(SpellcheckAction::TYPE_MANUALLY_CORRECTED);
   misspelling->action.set_value(correction);
   misspelling->timestamp = base::Time::Now();
 }
 
 void FeedbackSender::OnReceiveDocumentMarkers(
     int renderer_process_id,
-    const std::vector<uint32>& markers) {
+    const std::vector<uint32_t>& markers) {
   if ((base::Time::Now() - session_start_).InHours() >=
       chrome::spellcheck_common::kSessionHours) {
     FlushFeedback();
     return;
   }
 
   if (!feedback_.RendererHasMisspellings(renderer_process_id))
     return;
 
   feedback_.FinalizeRemovedMisspellings(renderer_process_id, markers);
   SendFeedback(feedback_.GetMisspellingsInRenderer(renderer_process_id),
                !renderers_sent_feedback_.count(renderer_process_id));
   renderers_sent_feedback_.insert(renderer_process_id);
   feedback_.EraseFinalizedMisspellings(renderer_process_id);
 }
 
 void FeedbackSender::OnSpellcheckResults(
     int renderer_process_id,
     const base::string16& text,
     const std::vector<SpellCheckMarker>& markers,
     std::vector<SpellCheckResult>* results) {
   // Don't collect feedback if not going to send it.
   if (!timer_.IsRunning())
     return;
 
   // Generate a map of marker offsets to marker hashes. This map helps to
   // efficiently lookup feedback data based on the position of the misspelling
   // in text.
-  typedef std::map<size_t, uint32> MarkerMap;
+  typedef std::map<size_t, uint32_t> MarkerMap;
   MarkerMap marker_map;
   for (size_t i = 0; i < markers.size(); ++i)
     marker_map[markers[i].offset] = markers[i].hash;
 
   for (std::vector<SpellCheckResult>::iterator result_it = results->begin();
        result_it != results->end();
        ++result_it) {
     if (!IsInBounds(result_it->location, result_it->length, text.length()))
       continue;
     MarkerMap::const_iterator marker_it = marker_map.find(result_it->location);
@@ skipping 83 matching lines @@
   std::vector<int> known_renderers = feedback_.GetRendersWithMisspellings();
   std::sort(known_renderers.begin(), known_renderers.end());
   std::vector<int> dead_renderers =
       base::STLSetDifference<std::vector<int> >(known_renderers,
                                                 alive_renderers);
   for (std::vector<int>::const_iterator it = dead_renderers.begin();
        it != dead_renderers.end();
        ++it) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&FeedbackSender::OnReceiveDocumentMarkers,
-                              AsWeakPtr(), *it, std::vector<uint32>()));
+                              AsWeakPtr(), *it, std::vector<uint32_t>()));
   }
 }
 
 void FeedbackSender::FlushFeedback() {
   if (feedback_.Empty())
     return;
   feedback_.FinalizeAllMisspellings();
   SendFeedback(feedback_.GetAllMisspellings(),
                renderers_sent_feedback_.empty());
   feedback_.Clear();
@@ skipping 25 matching lines @@
   senders_.push_back(sender);
 
   // Request context is NULL in testing.
   if (request_context_.get()) {
     sender->SetRequestContext(request_context_.get());
     sender->Start();
   }
 }
 
 }  // namespace spellcheck