Switch to standard integer types in ui/.

ui/accessibility/ax_tree.cc

 // Copyright 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.
 
 #include "ui/accessibility/ax_tree.h"
 
+#include <stddef.h>
+
 #include <set>
 
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "ui/accessibility/ax_node.h"
 
 namespace ui {
 
 namespace {
 
@@ skipping 48 matching lines @@
 
 AXTree::~AXTree() {
   if (root_)
     DestroyNodeAndSubtree(root_, nullptr);
 }
 
 void AXTree::SetDelegate(AXTreeDelegate* delegate) {
   delegate_ = delegate;
 }
 
-AXNode* AXTree::GetFromId(int32 id) const {
-  base::hash_map<int32, AXNode*>::const_iterator iter = id_map_.find(id);
+AXNode* AXTree::GetFromId(int32_t id) const {
+  base::hash_map<int32_t, AXNode*>::const_iterator iter = id_map_.find(id);
   return iter != id_map_.end() ? iter->second : NULL;
 }
 
 void AXTree::UpdateData(const AXTreeData& data) {
   data_ = data;
   if (delegate_)
     delegate_->OnTreeDataChanged(this);
 }
 
 bool AXTree::Unserialize(const AXTreeUpdate& update) {
   AXTreeUpdateState update_state;
-  int32 old_root_id = root_ ? root_->id() : 0;
+  int32_t old_root_id = root_ ? root_->id() : 0;
 
   if (update.has_tree_data)
     UpdateData(update.tree_data);
 
   if (update.node_id_to_clear != 0) {
     AXNode* node = GetFromId(update.node_id_to_clear);
     if (!node) {
       error_ = base::StringPrintf("Bad node_id_to_clear: %d",
                                   update.node_id_to_clear);
       return false;
@@ skipping 50 matching lines @@
         this, root_->id() != old_root_id, changes);
   }
 
   return true;
 }
 
 std::string AXTree::ToString() const {
   return "AXTree" + data_.ToString() + "\n" + TreeToStringHelper(root_, 0);
 }
 
-AXNode* AXTree::CreateNode(AXNode* parent, int32 id, int32 index_in_parent) {
+AXNode* AXTree::CreateNode(AXNode* parent,
+                           int32_t id,
+                           int32_t index_in_parent) {
   AXNode* new_node = new AXNode(parent, id, index_in_parent);
   id_map_[new_node->id()] = new_node;
   if (delegate_)
     delegate_->OnNodeCreated(this, new_node);
   return new_node;
 }
 
 bool AXTree::UpdateNode(const AXNodeData& src,
                         AXTreeUpdateState* update_state) {
   // This method updates one node in the tree based on serialized data
@@ skipping 71 matching lines @@
   id_map_.erase(node->id());
   for (int i = 0; i < node->child_count(); ++i)
     DestroyNodeAndSubtree(node->ChildAtIndex(i), update_state);
   if (update_state) {
     update_state->pending_nodes.erase(node);
   }
   node->Destroy();
 }
 
 bool AXTree::DeleteOldChildren(AXNode* node,
-                               const std::vector<int32>& new_child_ids,
+                               const std::vector<int32_t>& new_child_ids,
                                AXTreeUpdateState* update_state) {
   // Create a set of child ids in |src| for fast lookup, and return false
   // if a duplicate is found;
-  std::set<int32> new_child_id_set;
+  std::set<int32_t> new_child_id_set;
   for (size_t i = 0; i < new_child_ids.size(); ++i) {
     if (new_child_id_set.find(new_child_ids[i]) != new_child_id_set.end()) {
       error_ = base::StringPrintf("Node %d has duplicate child id %d",
                                   node->id(), new_child_ids[i]);
       return false;
     }
     new_child_id_set.insert(new_child_ids[i]);
   }
 
   // Delete the old children.
   const std::vector<AXNode*>& old_children = node->children();
   for (size_t i = 0; i < old_children.size(); ++i) {
     int old_id = old_children[i]->id();
     if (new_child_id_set.find(old_id) == new_child_id_set.end())
       DestroySubtree(old_children[i], update_state);
   }
 
   return true;
 }
 
 bool AXTree::CreateNewChildVector(AXNode* node,
-                                  const std::vector<int32>& new_child_ids,
+                                  const std::vector<int32_t>& new_child_ids,
                                   std::vector<AXNode*>* new_children,
                                   AXTreeUpdateState* update_state) {
   bool success = true;
   for (size_t i = 0; i < new_child_ids.size(); ++i) {
-    int32 child_id = new_child_ids[i];
-    int32 index_in_parent = static_cast<int32>(i);
+    int32_t child_id = new_child_ids[i];
+    int32_t index_in_parent = static_cast<int32_t>(i);
     AXNode* child = GetFromId(child_id);
     if (child) {
       if (child->parent() != node) {
         // This is a serious error - nodes should never be reparented.
         // If this case occurs, continue so this node isn't left in an
         // inconsistent state, but return failure at the end.
         error_ = base::StringPrintf(
             "Node %d reparented from %d to %d",
             child->id(),
             child->parent() ? child->parent()->id() : 0,
             node->id());
         success = false;
         continue;
       }
       child->SetIndexInParent(index_in_parent);
     } else {
       child = CreateNode(node, child_id, index_in_parent);
       update_state->pending_nodes.insert(child);
       update_state->new_nodes.insert(child);
     }
     new_children->push_back(child);
   }
 
   return success;
 }
 
 }  // namespace ui