Switch to standard integer types in ui/.

ui/accessibility/ax_tree_serializer.h

 // 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.
 
 #ifndef UI_ACCESSIBILITY_AX_TREE_SERIALIZER_H_
 #define UI_ACCESSIBILITY_AX_TREE_SERIALIZER_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <set>
 
 #include "base/containers/hash_tables.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "ui/accessibility/ax_export.h"
 #include "ui/accessibility/ax_tree_source.h"
 #include "ui/accessibility/ax_tree_update.h"
 
 namespace ui {
@@ skipping 115 matching lines @@
   // source node and client node.
   AXSourceNode LeastCommonAncestor(AXSourceNode node);
 
   // Walk the subtree rooted at |node| and return true if any nodes that
   // would be updated are being reparented. If so, update |out_lca| to point
   // to the least common ancestor of the previous LCA and the previous
   // parent of the node being reparented.
   bool AnyDescendantWasReparented(AXSourceNode node,
                                   AXSourceNode* out_lca);
 
-  ClientTreeNode* ClientTreeNodeById(int32 id);
+  ClientTreeNode* ClientTreeNodeById(int32_t id);
 
   // Delete the given client tree node and recursively delete all of its
   // descendants.
   void DeleteClientSubtree(ClientTreeNode* client_node);
 
   // Helper function, called recursively with each new node to serialize.
   void SerializeChangedNodes(
       AXSourceNode node,
       AXTreeUpdateBase<AXNodeData, AXTreeData>* out_update);
 
   // Visit all of the descendants of |node| once.
   void WalkAllDescendants(AXSourceNode node);
 
   // The tree source.
   AXTreeSource<AXSourceNode, AXNodeData, AXTreeData>* tree_;
 
   // The tree data most recently sent to the client.
   AXTreeData client_tree_data_;
 
   // Our representation of the client tree.
   ClientTreeNode* client_root_;
 
   // A map from IDs to nodes in the client tree.
-  base::hash_map<int32, ClientTreeNode*> client_id_map_;
+  base::hash_map<int32_t, ClientTreeNode*> client_id_map_;
 
   // The maximum number of nodes to serialize in a given call to
   // SerializeChanges, or 0 if there's no maximum.
   size_t max_node_count_;
 };
 
 // In order to keep track of what nodes the client knows about, we keep a
 // representation of the client tree - just IDs and parent/child
 // relationships.
 struct AX_EXPORT ClientTreeNode {
   ClientTreeNode();
   virtual ~ClientTreeNode();
-  int32 id;
+  int32_t id;
   ClientTreeNode* parent;
   std::vector<ClientTreeNode*> children;
 };
 
 template <typename AXSourceNode, typename AXNodeData, typename AXTreeData>
 AXTreeSerializer<AXSourceNode, AXNodeData, AXTreeData>::AXTreeSerializer(
     AXTreeSource<AXSourceNode, AXNodeData, AXTreeData>* tree)
     : tree_(tree), client_root_(NULL), max_node_count_(0) {}
 
 template <typename AXSourceNode, typename AXNodeData, typename AXTreeData>
@@ skipping 106 matching lines @@
     // This is a new child or reparented child, check it recursively.
     if (AnyDescendantWasReparented(child, out_lca))
       result = true;
   }
   return result;
 }
 
 template <typename AXSourceNode, typename AXNodeData, typename AXTreeData>
 ClientTreeNode*
 AXTreeSerializer<AXSourceNode, AXNodeData, AXTreeData>::ClientTreeNodeById(
-    int32 id) {
-  base::hash_map<int32, ClientTreeNode*>::iterator iter =
+    int32_t id) {
+  base::hash_map<int32_t, ClientTreeNode*>::iterator iter =
       client_id_map_.find(id);
   if (iter != client_id_map_.end())
     return iter->second;
   else
     return NULL;
 }
 
 template <typename AXSourceNode, typename AXNodeData, typename AXTreeData>
 void AXTreeSerializer<AXSourceNode, AXNodeData, AXTreeData>::SerializeChanges(
     AXSourceNode node,
@@ skipping 104 matching lines @@
     client_node->parent = NULL;
     client_id_map_[client_node->id] = client_node;
   }
 
   // Iterate over the ids of the children of |node|.
   // Create a set of the child ids so we can quickly look
   // up which children are new and which ones were there before.
   // If we've hit the maximum number of serialized nodes, pretend
   // this node has no children but keep going so that we get
   // consistent results.
-  base::hash_set<int32> new_child_ids;
+  base::hash_set<int32_t> new_child_ids;
   std::vector<AXSourceNode> children;
   if (max_node_count_ == 0 || out_update->nodes.size() < max_node_count_) {
     tree_->GetChildren(node, &children);
   } else if (max_node_count_ > 0) {
     static bool logged_once = false;
     if (!logged_once) {
       LOG(WARNING) << "Warning: not serializing AX nodes after a max of "
                    << max_node_count_;
       logged_once = true;
     }
   }
   for (size_t i = 0; i < children.size(); ++i) {
     AXSourceNode& child = children[i];
     int new_child_id = tree_->GetId(child);
     new_child_ids.insert(new_child_id);
 
     // This is a sanity check - there shouldn't be any reparenting
     // because we've already handled it above.
     ClientTreeNode* client_child = client_id_map_[new_child_id];
     CHECK(!client_child || client_child->parent == client_node);
   }
 
   // Go through the old children and delete subtrees for child
   // ids that are no longer present, and create a map from
   // id to ClientTreeNode for the rest. It's important to delete
   // first in a separate pass so that nodes that are reparented
   // don't end up children of two different parents in the middle
   // of an update, which can lead to a double-free.
-  base::hash_map<int32, ClientTreeNode*> client_child_id_map;
+  base::hash_map<int32_t, ClientTreeNode*> client_child_id_map;
   std::vector<ClientTreeNode*> old_children;
   old_children.swap(client_node->children);
   for (size_t i = 0; i < old_children.size(); ++i) {
     ClientTreeNode* old_child = old_children[i];
     int old_child_id = old_child->id;
     if (new_child_ids.find(old_child_id) == new_child_ids.end()) {
       client_id_map_.erase(old_child_id);
       DeleteClientSubtree(old_child);
       delete old_child;
     } else {
@@ skipping 13 matching lines @@
 
     tree_->SerializeNode(node, serialized_node);
     // TODO(dmazzoni/dtseng): Make the serializer not depend on roles to
     // identify the root.
     if (serialized_node->id == client_root_->id && !serialized_node->IsRoot())
       serialized_node->SetRoot();
   }
 
   // Iterate over the children, serialize them, and update the ClientTreeNode
   // data structure to reflect the new tree.
-  std::vector<int32> actual_serialized_node_child_ids;
+  std::vector<int32_t> actual_serialized_node_child_ids;
   client_node->children.reserve(children.size());
   for (size_t i = 0; i < children.size(); ++i) {
     AXSourceNode& child = children[i];
     int child_id = tree_->GetId(child);
 
     // Skip if the child isn't valid.
     if (!tree_->IsValid(child))
       continue;
 
     // Skip if the same child is included more than once.
@@ skipping 26 matching lines @@
     AXSourceNode node) {
   std::vector<AXSourceNode> children;
   tree_->GetChildren(node, &children);
   for (size_t i = 0; i < children.size(); ++i)
     WalkAllDescendants(children[i]);
 }
 
 }  // namespace ui
 
 #endif  // UI_ACCESSIBILITY_AX_TREE_SERIALIZER_H_