Switch to standard integer types in content/browser/.

content/browser/accessibility/browser_accessibility.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 "content/browser/accessibility/browser_accessibility.h"
 
+#include <stddef.h>
+
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/accessibility/browser_accessibility_manager.h"
 #include "content/common/accessibility_messages.h"
 #include "ui/accessibility/ax_text_utils.h"
 
@@ skipping 42 matching lines @@
     case ui::AX_ROLE_SCROLL_BAR:
     case ui::AX_ROLE_SLIDER:
     case ui::AX_ROLE_SPLITTER:
     case ui::AX_ROLE_PROGRESS_INDICATOR:
       return true;
     default:
       return false;
   }
 }
 
-uint32 BrowserAccessibility::PlatformChildCount() const {
+uint32_t BrowserAccessibility::PlatformChildCount() const {
   if (HasIntAttribute(ui::AX_ATTR_CHILD_TREE_ID)) {
     BrowserAccessibilityManager* child_manager =
         BrowserAccessibilityManager::FromID(
             GetIntAttribute(ui::AX_ATTR_CHILD_TREE_ID));
     if (child_manager)
       return 1;
 
     return 0;
   }
 
@@ skipping 14 matching lines @@
 
   return false;
 }
 
 bool BrowserAccessibility::IsTextOnlyObject() const {
   return GetRole() == ui::AX_ROLE_STATIC_TEXT ||
       GetRole() == ui::AX_ROLE_LINE_BREAK;
 }
 
 BrowserAccessibility* BrowserAccessibility::PlatformGetChild(
-    uint32 child_index) const {
+    uint32_t child_index) const {
   DCHECK(child_index < PlatformChildCount());
   BrowserAccessibility* result = nullptr;
 
   if (HasIntAttribute(ui::AX_ATTR_CHILD_TREE_ID)) {
     BrowserAccessibilityManager* child_manager =
         BrowserAccessibilityManager::FromID(
             GetIntAttribute(ui::AX_ATTR_CHILD_TREE_ID));
     if (child_manager)
       result = child_manager->GetRoot();
   } else {
@@ skipping 49 matching lines @@
 
   auto deepest_child = PlatformGetChild(PlatformChildCount() - 1);
   while (deepest_child->PlatformChildCount()) {
     deepest_child = deepest_child->PlatformGetChild(
         deepest_child->PlatformChildCount() - 1);
   }
 
   return deepest_child;
 }
 
-uint32 BrowserAccessibility::InternalChildCount() const {
+uint32_t BrowserAccessibility::InternalChildCount() const {
   if (!node_ || !manager_)
     return 0;
-  return static_cast<uint32>(node_->child_count());
+  return static_cast<uint32_t>(node_->child_count());
 }
 
 BrowserAccessibility* BrowserAccessibility::InternalGetChild(
-    uint32 child_index) const {
+    uint32_t child_index) const {
   if (!node_ || !manager_ || child_index >= InternalChildCount())
     return nullptr;
 
   const auto child_node = node_->ChildAtIndex(child_index);
   DCHECK(child_node);
   return manager_->GetFromAXNode(child_node);
 }
 
 BrowserAccessibility* BrowserAccessibility::GetParent() const {
   if (!node_ || !manager_)
     return NULL;
   ui::AXNode* parent = node_->parent();
   if (parent)
     return manager_->GetFromAXNode(parent);
 
   return manager_->GetParentNodeFromParentTree();
 }
 
 BrowserAccessibility* BrowserAccessibility::InternalGetParent() const {
   if (!node_ || !manager_)
     return nullptr;
   ui::AXNode* parent = node_->parent();
   if (parent)
     return manager_->GetFromAXNode(parent);
 
   return nullptr;
 }
 
-int32 BrowserAccessibility::GetIndexInParent() const {
+int32_t BrowserAccessibility::GetIndexInParent() const {
   return node_ ? node_->index_in_parent() : -1;
 }
 
-int32 BrowserAccessibility::GetId() const {
+int32_t BrowserAccessibility::GetId() const {
   return node_ ? node_->id() : -1;
 }
 
 const ui::AXNodeData& BrowserAccessibility::GetData() const {
   CR_DEFINE_STATIC_LOCAL(ui::AXNodeData, empty_data, ());
   if (node_)
     return node_->data();
   else
     return empty_data;
 }
 
 gfx::Rect BrowserAccessibility::GetLocation() const {
   return GetData().location;
 }
 
-int32 BrowserAccessibility::GetRole() const {
+int32_t BrowserAccessibility::GetRole() const {
   return GetData().role;
 }
 
-int32 BrowserAccessibility::GetState() const {
+int32_t BrowserAccessibility::GetState() const {
   return GetData().state;
 }
 
 const BrowserAccessibility::HtmlAttributes&
 BrowserAccessibility::GetHtmlAttributes() const {
   return GetData().html_attributes;
 }
 
 gfx::Rect BrowserAccessibility::GetLocalBoundsRect() const {
   gfx::Rect bounds = GetLocation();
@@ skipping 55 matching lines @@
 
     int overlap_start = std::max(start, child_start);
     int overlap_end = std::min(end, child_end);
 
     int local_start = overlap_start - child_start;
     int local_end = overlap_end - child_start;
 
     gfx::Rect child_rect = child->GetLocation();
     int text_direction = child->GetIntAttribute(
         ui::AX_ATTR_TEXT_DIRECTION);
-    const std::vector<int32>& character_offsets = child->GetIntListAttribute(
-        ui::AX_ATTR_CHARACTER_OFFSETS);
+    const std::vector<int32_t>& character_offsets =
+        child->GetIntListAttribute(ui::AX_ATTR_CHARACTER_OFFSETS);
     int start_pixel_offset =
         local_start > 0 ? character_offsets[local_start - 1] : 0;
     int end_pixel_offset =
         local_end > 0 ? character_offsets[local_end - 1] : 0;
 
     gfx::Rect child_overlap_rect;
     switch (text_direction) {
       case ui::AX_TEXT_DIRECTION_NONE:
       case ui::AX_TEXT_DIRECTION_LTR: {
         int left = child_rect.x() + start_pixel_offset;
@@ skipping 71 matching lines @@
       for (size_t i = 0; i < InternalChildCount(); ++i) {
         // The next child starts where the previous one ended.
         child_start = child_end;
         BrowserAccessibility* child = InternalGetChild(i);
         DCHECK_EQ(child->GetRole(), ui::AX_ROLE_INLINE_TEXT_BOX);
         const std::string& child_text = child->GetStringAttribute(
             ui::AX_ATTR_NAME);
         int child_len = static_cast<int>(child_text.size());
         child_end += child_len; // End is one past the last character.
 
-        const std::vector<int32>& word_starts = child->GetIntListAttribute(
-            ui::AX_ATTR_WORD_STARTS);
+        const std::vector<int32_t>& word_starts =
+            child->GetIntListAttribute(ui::AX_ATTR_WORD_STARTS);
         if (word_starts.empty()) {
           word_start = child_end;
           continue;
         }
 
         int local_start = start - child_start;
-        std::vector<int32>::const_iterator iter = std::upper_bound(
+        std::vector<int32_t>::const_iterator iter = std::upper_bound(
             word_starts.begin(), word_starts.end(), local_start);
         if (iter != word_starts.end()) {
           if (direction == ui::FORWARDS_DIRECTION) {
             word_start = child_start + *iter;
           } else if (direction == ui::BACKWARDS_DIRECTION) {
             if (iter == word_starts.begin()) {
               // Return the position of the last word in the previous child.
               word_start = prev_word_start;
             } else {
               word_start = child_start + *(iter - 1);
@@ skipping 182 matching lines @@
     ui::AXStringAttribute attribute,
     base::string16* value) const {
   return GetData().GetString16Attribute(attribute, value);
 }
 
 bool BrowserAccessibility::HasIntListAttribute(
     ui::AXIntListAttribute attribute) const {
   return GetData().HasIntListAttribute(attribute);
 }
 
-const std::vector<int32>& BrowserAccessibility::GetIntListAttribute(
+const std::vector<int32_t>& BrowserAccessibility::GetIntListAttribute(
     ui::AXIntListAttribute attribute) const {
   return GetData().GetIntListAttribute(attribute);
 }
 
 bool BrowserAccessibility::GetIntListAttribute(
     ui::AXIntListAttribute attribute,
-    std::vector<int32>* value) const {
+    std::vector<int32_t>* value) const {
   return GetData().GetIntListAttribute(attribute, value);
 }
 
 bool BrowserAccessibility::GetHtmlAttribute(
     const char* html_attr, std::string* value) const {
   return GetData().GetHtmlAttribute(html_attr, value);
 }
 
 bool BrowserAccessibility::GetHtmlAttribute(
     const char* html_attr, base::string16* value) const {
@@ skipping 36 matching lines @@
 }
 
 bool BrowserAccessibility::HasCaret() const {
   if (IsEditableText() && !HasState(ui::AX_STATE_RICHLY_EDITABLE) &&
       HasIntAttribute(ui::AX_ATTR_TEXT_SEL_START) &&
       HasIntAttribute(ui::AX_ATTR_TEXT_SEL_END)) {
     return true;
   }
 
   // The caret is always at the focus of the selection.
-  int32 focus_id = manager()->GetTreeData().sel_focus_object_id;
+  int32_t focus_id = manager()->GetTreeData().sel_focus_object_id;
   BrowserAccessibility* focus_object = manager()->GetFromID(focus_id);
   if (!focus_object)
     return false;
 
   if (!focus_object->IsDescendantOf(this))
     return false;
 
   return true;
 }
 
@@ skipping 165 matching lines @@
       }
       need_to_offset_web_area = true;
     }
     parent = parent->GetParent();
   }
 
   return bounds;
 }
 
 }  // namespace content