Switch to standard integer types in content/browser/.

content/browser/accessibility/browser_accessibility_win.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_win.h"
 
 #include <UIAutomationClient.h>
 #include <UIAutomationCoreApi.h>
 
 #include <algorithm>
@@ skipping 305 matching lines @@
   BrowserAccessibilityWin* target = GetTargetFromChildID(start);
   if (!target)
     return E_INVALIDARG;
 
   if ((nav_dir == NAVDIR_LASTCHILD || nav_dir == NAVDIR_FIRSTCHILD) &&
       start.lVal != CHILDID_SELF) {
     // MSAA states that navigating to first/last child can only be from self.
     return E_INVALIDARG;
   }
 
-  uint32 child_count = target->PlatformChildCount();
+  uint32_t child_count = target->PlatformChildCount();
 
   BrowserAccessibility* result = NULL;
   switch (nav_dir) {
     case NAVDIR_DOWN:
     case NAVDIR_UP:
     case NAVDIR_LEFT:
     case NAVDIR_RIGHT:
       // These directions are not implemented, matching Mozilla and IE.
       return E_NOTIMPL;
     case NAVDIR_FIRSTCHILD:
@@ skipping 762 matching lines @@
       !GetIntAttribute(
           ui::AX_ATTR_TABLE_ROW_COUNT, &rows) ||
       columns <= 0 ||
       rows <= 0) {
     return S_FALSE;
   }
 
   if (row < 0 || row >= rows || column < 0 || column >= columns)
     return E_INVALIDARG;
 
-  const std::vector<int32>& cell_ids = GetIntListAttribute(
-      ui::AX_ATTR_CELL_IDS);
+  const std::vector<int32_t>& cell_ids =
+      GetIntListAttribute(ui::AX_ATTR_CELL_IDS);
   DCHECK_EQ(columns * rows, static_cast<int>(cell_ids.size()));
 
   int cell_id = cell_ids[row * columns + column];
   BrowserAccessibilityWin* cell = GetFromID(cell_id);
   if (cell) {
     *accessible = static_cast<IAccessible*>(cell->NewReference());
     return S_OK;
   }
 
   *accessible = NULL;
@@ skipping 27 matching lines @@
       !GetIntAttribute(
           ui::AX_ATTR_TABLE_ROW_COUNT, &rows) ||
       columns <= 0 ||
       rows <= 0) {
     return S_FALSE;
   }
 
   if (row < 0 || row >= rows || column < 0 || column >= columns)
     return E_INVALIDARG;
 
-  const std::vector<int32>& cell_ids = GetIntListAttribute(
-      ui::AX_ATTR_CELL_IDS);
-  const std::vector<int32>& unique_cell_ids = GetIntListAttribute(
-      ui::AX_ATTR_UNIQUE_CELL_IDS);
+  const std::vector<int32_t>& cell_ids =
+      GetIntListAttribute(ui::AX_ATTR_CELL_IDS);
+  const std::vector<int32_t>& unique_cell_ids =
+      GetIntListAttribute(ui::AX_ATTR_UNIQUE_CELL_IDS);
   DCHECK_EQ(columns * rows, static_cast<int>(cell_ids.size()));
   int cell_id = cell_ids[row * columns + column];
   for (size_t i = 0; i < unique_cell_ids.size(); ++i) {
     if (unique_cell_ids[i] == cell_id) {
       *cell_index = (long)i;
       return S_OK;
     }
   }
 
   return S_FALSE;
@@ skipping 13 matching lines @@
           ui::AX_ATTR_TABLE_COLUMN_COUNT, &columns) ||
       !GetIntAttribute(ui::AX_ATTR_TABLE_ROW_COUNT, &rows) ||
       columns <= 0 ||
       rows <= 0) {
     return S_FALSE;
   }
 
   if (column < 0 || column >= columns)
     return E_INVALIDARG;
 
-  const std::vector<int32>& cell_ids = GetIntListAttribute(
-      ui::AX_ATTR_CELL_IDS);
+  const std::vector<int32_t>& cell_ids =
+      GetIntListAttribute(ui::AX_ATTR_CELL_IDS);
   for (int i = 0; i < rows; ++i) {
     int cell_id = cell_ids[i * columns + column];
     BrowserAccessibilityWin* cell = static_cast<BrowserAccessibilityWin*>(
         manager()->GetFromID(cell_id));
     if (cell && cell->GetRole() == ui::AX_ROLE_COLUMN_HEADER) {
       base::string16 cell_name = cell->GetString16Attribute(
           ui::AX_ATTR_NAME);
       if (cell_name.size() > 0) {
         *description = SysAllocString(cell_name.c_str());
         return S_OK;
@@ skipping 25 matching lines @@
           ui::AX_ATTR_TABLE_COLUMN_COUNT, &columns) ||
       !GetIntAttribute(ui::AX_ATTR_TABLE_ROW_COUNT, &rows) ||
       columns <= 0 ||
       rows <= 0) {
     return S_FALSE;
   }
 
   if (row < 0 || row >= rows || column < 0 || column >= columns)
     return E_INVALIDARG;
 
-  const std::vector<int32>& cell_ids = GetIntListAttribute(
-      ui::AX_ATTR_CELL_IDS);
+  const std::vector<int32_t>& cell_ids =
+      GetIntListAttribute(ui::AX_ATTR_CELL_IDS);
   int cell_id = cell_ids[row * columns + column];
   BrowserAccessibilityWin* cell = static_cast<BrowserAccessibilityWin*>(
       manager()->GetFromID(cell_id));
   int colspan;
   if (cell &&
       cell->GetIntAttribute(
           ui::AX_ATTR_TABLE_CELL_COLUMN_SPAN, &colspan) &&
       colspan >= 1) {
     *n_columns_spanned = colspan;
     return S_OK;
@@ skipping 10 matching lines @@
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_columnIndex(long cell_index,
                                                       long* column_index) {
   if (!instance_active())
     return E_FAIL;
 
   if (!column_index)
     return E_INVALIDARG;
 
-  const std::vector<int32>& unique_cell_ids = GetIntListAttribute(
-      ui::AX_ATTR_UNIQUE_CELL_IDS);
+  const std::vector<int32_t>& unique_cell_ids =
+      GetIntListAttribute(ui::AX_ATTR_UNIQUE_CELL_IDS);
   int cell_id_count = static_cast<int>(unique_cell_ids.size());
   if (cell_index < 0)
     return E_INVALIDARG;
   if (cell_index >= cell_id_count)
     return S_FALSE;
 
   int cell_id = unique_cell_ids[cell_index];
   BrowserAccessibilityWin* cell =
       manager()->GetFromID(cell_id)->ToBrowserAccessibilityWin();
   int col_index;
@@ skipping 88 matching lines @@
           ui::AX_ATTR_TABLE_COLUMN_COUNT, &columns) ||
       !GetIntAttribute(ui::AX_ATTR_TABLE_ROW_COUNT, &rows) ||
       columns <= 0 ||
       rows <= 0) {
     return S_FALSE;
   }
 
   if (row < 0 || row >= rows)
     return E_INVALIDARG;
 
-  const std::vector<int32>& cell_ids = GetIntListAttribute(
-      ui::AX_ATTR_CELL_IDS);
+  const std::vector<int32_t>& cell_ids =
+      GetIntListAttribute(ui::AX_ATTR_CELL_IDS);
   for (int i = 0; i < columns; ++i) {
     int cell_id = cell_ids[row * columns + i];
     BrowserAccessibilityWin* cell =
         manager()->GetFromID(cell_id)->ToBrowserAccessibilityWin();
     if (cell && cell->GetRole() == ui::AX_ROLE_ROW_HEADER) {
       base::string16 cell_name = cell->GetString16Attribute(
           ui::AX_ATTR_NAME);
       if (cell_name.size() > 0) {
         *description = SysAllocString(cell_name.c_str());
         return S_OK;
@@ skipping 24 matching lines @@
           ui::AX_ATTR_TABLE_COLUMN_COUNT, &columns) ||
       !GetIntAttribute(ui::AX_ATTR_TABLE_ROW_COUNT, &rows) ||
       columns <= 0 ||
       rows <= 0) {
     return S_FALSE;
   }
 
   if (row < 0 || row >= rows || column < 0 || column >= columns)
     return E_INVALIDARG;
 
-  const std::vector<int32>& cell_ids = GetIntListAttribute(
-      ui::AX_ATTR_CELL_IDS);
+  const std::vector<int32_t>& cell_ids =
+      GetIntListAttribute(ui::AX_ATTR_CELL_IDS);
   int cell_id = cell_ids[row * columns + column];
   BrowserAccessibilityWin* cell =
       manager()->GetFromID(cell_id)->ToBrowserAccessibilityWin();
   int rowspan;
   if (cell &&
       cell->GetIntAttribute(
           ui::AX_ATTR_TABLE_CELL_ROW_SPAN, &rowspan) &&
       rowspan >= 1) {
     *n_rows_spanned = rowspan;
     return S_OK;
@@ skipping 10 matching lines @@
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_rowIndex(long cell_index,
                                                    long* row_index) {
   if (!instance_active())
     return E_FAIL;
 
   if (!row_index)
     return E_INVALIDARG;
 
-  const std::vector<int32>& unique_cell_ids = GetIntListAttribute(
-      ui::AX_ATTR_UNIQUE_CELL_IDS);
+  const std::vector<int32_t>& unique_cell_ids =
+      GetIntListAttribute(ui::AX_ATTR_UNIQUE_CELL_IDS);
   int cell_id_count = static_cast<int>(unique_cell_ids.size());
   if (cell_index < 0)
     return E_INVALIDARG;
   if (cell_index >= cell_id_count)
     return S_FALSE;
 
   int cell_id = unique_cell_ids[cell_index];
   BrowserAccessibilityWin* cell =
       manager()->GetFromID(cell_id)->ToBrowserAccessibilityWin();
   int cell_row_index;
@@ skipping 107 matching lines @@
     long* column,
     long* row_extents,
     long* column_extents,
     boolean* is_selected) {
   if (!instance_active())
     return E_FAIL;
 
   if (!row || !column || !row_extents || !column_extents || !is_selected)
     return E_INVALIDARG;
 
-  const std::vector<int32>& unique_cell_ids = GetIntListAttribute(
-      ui::AX_ATTR_UNIQUE_CELL_IDS);
+  const std::vector<int32_t>& unique_cell_ids =
+      GetIntListAttribute(ui::AX_ATTR_UNIQUE_CELL_IDS);
   int cell_id_count = static_cast<int>(unique_cell_ids.size());
   if (index < 0)
     return E_INVALIDARG;
   if (index >= cell_id_count)
     return S_FALSE;
 
   int cell_id = unique_cell_ids[index];
   BrowserAccessibilityWin* cell =
       manager()->GetFromID(cell_id)->ToBrowserAccessibilityWin();
   int rowspan;
@@ skipping 141 matching lines @@
   int rows;
   if (!table->GetIntAttribute(
           ui::AX_ATTR_TABLE_COLUMN_COUNT, &columns) ||
       !table->GetIntAttribute(
           ui::AX_ATTR_TABLE_ROW_COUNT, &rows)) {
     return S_FALSE;
   }
   if (columns <= 0 || rows <= 0 || column < 0 || column >= columns)
     return S_FALSE;
 
-  const std::vector<int32>& cell_ids = table->GetIntListAttribute(
-      ui::AX_ATTR_CELL_IDS);
+  const std::vector<int32_t>& cell_ids =
+      table->GetIntListAttribute(ui::AX_ATTR_CELL_IDS);
 
   for (int i = 0; i < rows; ++i) {
     int cell_id = cell_ids[i * columns + column];
     BrowserAccessibilityWin* cell =
         manager()->GetFromID(cell_id)->ToBrowserAccessibilityWin();
     if (cell && cell->GetRole() == ui::AX_ROLE_COLUMN_HEADER)
       (*n_column_header_cells)++;
   }
 
   *cell_accessibles = static_cast<IUnknown**>(CoTaskMemAlloc(
@@ skipping 76 matching lines @@
   int rows;
   if (!table->GetIntAttribute(
           ui::AX_ATTR_TABLE_COLUMN_COUNT, &columns) ||
       !table->GetIntAttribute(
           ui::AX_ATTR_TABLE_ROW_COUNT, &rows)) {
     return S_FALSE;
   }
   if (columns <= 0 || rows <= 0 || row < 0 || row >= rows)
     return S_FALSE;
 
-  const std::vector<int32>& cell_ids = table->GetIntListAttribute(
-      ui::AX_ATTR_CELL_IDS);
+  const std::vector<int32_t>& cell_ids =
+      table->GetIntListAttribute(ui::AX_ATTR_CELL_IDS);
 
   for (int i = 0; i < columns; ++i) {
     int cell_id = cell_ids[row * columns + i];
     BrowserAccessibility* cell = manager()->GetFromID(cell_id);
     if (cell && cell->GetRole() == ui::AX_ROLE_ROW_HEADER)
       (*n_row_header_cells)++;
   }
 
   *cell_accessibles = static_cast<IUnknown**>(CoTaskMemAlloc(
       (*n_row_header_cells) * sizeof(cell_accessibles[0])));
@@ skipping 532 matching lines @@
     IAccessibleHyperlink** hyperlink) {
   if (!instance_active())
     return E_FAIL;
 
   if (!hyperlink ||
       index < 0 ||
       index >= static_cast<long>(hyperlinks().size())) {
     return E_INVALIDARG;
   }
 
-  int32 id = hyperlinks()[index];
+  int32_t id = hyperlinks()[index];
   BrowserAccessibilityWin* child =
       manager()->GetFromID(id)->ToBrowserAccessibilityWin();
   if (child) {
     *hyperlink = static_cast<IAccessibleHyperlink*>(child->NewReference());
     return S_OK;
   }
 
   return E_FAIL;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_hyperlinkIndex(
     long char_index,
     long* hyperlink_index) {
   if (!instance_active())
     return E_FAIL;
 
   if (!hyperlink_index)
     return E_INVALIDARG;
 
   if (char_index < 0 ||
       char_index >= static_cast<long>(hypertext().size())) {
     return E_INVALIDARG;
   }
 
-  std::map<int32, int32>::iterator it =
+  std::map<int32_t, int32_t>::iterator it =
       hyperlink_offset_to_index().find(char_index);
   if (it == hyperlink_offset_to_index().end()) {
     *hyperlink_index = -1;
     return S_FALSE;
   }
 
   *hyperlink_index = it->second;
   return S_OK;
 }
 
@@ skipping 51 matching lines @@
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_startIndex(long* index) {
   if (!instance_active() || !IsHyperlink())
     return E_FAIL;
 
   if (!index)
     return E_INVALIDARG;
 
-  int32 hypertext_offset = 0;
+  int32_t hypertext_offset = 0;
   const auto parent = GetParent();
   if (parent) {
     hypertext_offset =
         parent->ToBrowserAccessibilityWin()->GetHypertextOffsetFromChild(*this);
   }
   *index = static_cast<LONG>(hypertext_offset);
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_endIndex(long* index) {
@@ skipping 691 matching lines @@
 //
 
 // static
 HRESULT WINAPI BrowserAccessibilityWin::InternalQueryInterface(
     void* this_ptr,
     const _ATL_INTMAP_ENTRY* entries,
     REFIID iid,
     void** object) {
   BrowserAccessibilityWin* accessibility =
       reinterpret_cast<BrowserAccessibilityWin*>(this_ptr);
-  int32 ia_role = accessibility->ia_role();
+  int32_t ia_role = accessibility->ia_role();
   if (iid == IID_IAccessibleImage) {
     if (ia_role != ROLE_SYSTEM_GRAPHIC) {
       *object = NULL;
       return E_NOINTERFACE;
     }
   } else if (iid == IID_IAccessibleTable || iid == IID_IAccessibleTable2) {
     if (ia_role != ROLE_SYSTEM_TABLE) {
       *object = NULL;
       return E_NOINTERFACE;
     }
@@ skipping 79 matching lines @@
                      "container-atomic");
   BoolAttributeToIA2(ui::AX_ATTR_CONTAINER_LIVE_BUSY,
                      "container-busy");
 
   // Expose table cell index.
   if (IsCellOrTableHeaderRole()) {
     BrowserAccessibility* table = GetParent();
     while (table && table->GetRole() != ui::AX_ROLE_TABLE)
       table = table->GetParent();
     if (table) {
-      const std::vector<int32>& unique_cell_ids = table->GetIntListAttribute(
-          ui::AX_ATTR_UNIQUE_CELL_IDS);
+      const std::vector<int32_t>& unique_cell_ids =
+          table->GetIntListAttribute(ui::AX_ATTR_UNIQUE_CELL_IDS);
       for (size_t i = 0; i < unique_cell_ids.size(); ++i) {
         if (unique_cell_ids[i] == GetId()) {
           win_attributes_->ia2_attributes.push_back(
               base::string16(L"table-cell-index:") + base::IntToString16(i));
         }
       }
     }
   }
 
   // Expose invalid state for form controls and elements with aria-invalid.
@@ skipping 28 matching lines @@
             win_attributes_->ia2_attributes.push_back(L"invalid:true");
           }
         }
         break;
       default:
         NOTREACHED();
     }
   }
 
   // Expose row or column header sort direction.
-  int32 sort_direction;
+  int32_t sort_direction;
   if ((ia_role() == ROLE_SYSTEM_COLUMNHEADER ||
       ia_role() == ROLE_SYSTEM_ROWHEADER) &&
       GetIntAttribute(ui::AX_ATTR_SORT_DIRECTION, &sort_direction)) {
     switch (sort_direction) {
       case ui::AX_SORT_DIRECTION_UNSORTED:
         win_attributes_->ia2_attributes.push_back(L"sort:none");
         break;
       case ui::AX_SORT_DIRECTION_ASCENDING:
         win_attributes_->ia2_attributes.push_back(L"sort:ascending");
         break;
@@ skipping 63 matching lines @@
   // the character index of each embedded object character to the id of the
   // child object it points to.
   for (unsigned int i = 0; i < PlatformChildCount(); ++i) {
     BrowserAccessibilityWin* child =
         PlatformGetChild(i)->ToBrowserAccessibilityWin();
     DCHECK(child);
     // Similar to Firefox, we don't expose text-only objects in IA2 hypertext.
     if (child->IsTextOnlyObject()) {
       win_attributes_->hypertext += child->name();
     } else {
-      int32 char_offset = hypertext().size();
-      int32 child_id = child->GetId();
-      int32 index = hyperlinks().size();
+      int32_t char_offset = hypertext().size();
+      int32_t child_id = child->GetId();
+      int32_t index = hyperlinks().size();
       win_attributes_->hyperlink_offset_to_index[char_offset] = index;
       win_attributes_->hyperlinks.push_back(child_id);
       win_attributes_->hypertext += kEmbeddedCharacter;
     }
   }
 }
 
 void BrowserAccessibilityWin::UpdateStep3FireEvents(bool is_subtree_creation) {
   BrowserAccessibilityManagerWin* manager =
       this->manager()->ToBrowserAccessibilityManagerWin();
@@ skipping 196 matching lines @@
     const char* ia2_attr) {
   int value;
   if (GetIntAttribute(attribute, &value)) {
     win_attributes_->ia2_attributes.push_back(
         base::ASCIIToUTF16(ia2_attr) + L":" +
         base::IntToString16(value));
   }
 }
 
 bool BrowserAccessibilityWin::IsHyperlink() const {
-  int32 hyperlink_index = -1;
+  int32_t hyperlink_index = -1;
   const auto parent = GetParent();
   if (parent) {
     hyperlink_index =
         parent->ToBrowserAccessibilityWin()->GetHyperlinkIndexFromChild(*this);
   }
 
   if (hyperlink_index >= 0)
     return true;
   return false;
 }
 
-int32 BrowserAccessibilityWin::GetHyperlinkIndexFromChild(
+int32_t BrowserAccessibilityWin::GetHyperlinkIndexFromChild(
     const BrowserAccessibilityWin& child) const {
   if (hyperlinks().empty())
     return -1;
 
   auto iterator = std::find(
       hyperlinks().begin(), hyperlinks().end(), child.GetId());
   if (iterator == hyperlinks().end())
     return -1;
 
-  return static_cast<int32>(iterator - hyperlinks().begin());
+  return static_cast<int32_t>(iterator - hyperlinks().begin());
 }
 
-int32 BrowserAccessibilityWin::GetHypertextOffsetFromHyperlinkIndex(
-    int32 hyperlink_index) const {
+int32_t BrowserAccessibilityWin::GetHypertextOffsetFromHyperlinkIndex(
+    int32_t hyperlink_index) const {
   for (auto& offset_index : hyperlink_offset_to_index()) {
     if (offset_index.second == hyperlink_index)
       return offset_index.first;
   }
 
   return -1;
 }
 
-int32 BrowserAccessibilityWin::GetHypertextOffsetFromChild(
+int32_t BrowserAccessibilityWin::GetHypertextOffsetFromChild(
     const BrowserAccessibilityWin& child) const {
   DCHECK(child.GetParent() == this);
 
   // Handle the case when we are dealing with a direct text-only child.
   // (Note that this object might be a platform leaf, e.g. an ARIA searchbox,
   // and so InternalChild... functions need to be used. Also, direct text-only
   // children should not be present at tree roots and so no cross-tree traversal
   // is necessary.)
   if (child.IsTextOnlyObject()) {
-    int32 hypertextOffset = 0;
-    int32 index_in_parent = child.GetIndexInParent();
+    int32_t hypertextOffset = 0;
+    int32_t index_in_parent = child.GetIndexInParent();
     DCHECK_GE(index_in_parent, 0);
-    DCHECK_LT(index_in_parent, static_cast<int32>(InternalChildCount()));
-    for (uint32 i = 0; i < static_cast<uint32>(index_in_parent); ++i) {
+    DCHECK_LT(index_in_parent, static_cast<int32_t>(InternalChildCount()));
+    for (uint32_t i = 0; i < static_cast<uint32_t>(index_in_parent); ++i) {
       const BrowserAccessibilityWin* sibling =
           InternalGetChild(i)->ToBrowserAccessibilityWin();
       DCHECK(sibling);
       if (sibling->IsTextOnlyObject())
         hypertextOffset += sibling->hypertext().length();
       else
         ++hypertextOffset;
     }
     return hypertextOffset;
   }
 
-  int32 hyperlink_index = GetHyperlinkIndexFromChild(child);
+  int32_t hyperlink_index = GetHyperlinkIndexFromChild(child);
   if (hyperlink_index < 0)
     return -1;
 
   return GetHypertextOffsetFromHyperlinkIndex(hyperlink_index);
 }
 
-int32 BrowserAccessibilityWin::GetHypertextOffsetFromDescendant(
+int32_t BrowserAccessibilityWin::GetHypertextOffsetFromDescendant(
     const BrowserAccessibilityWin& descendant) const {
   auto parent_object = descendant.GetParent()->ToBrowserAccessibilityWin();
   auto current_object = const_cast<BrowserAccessibilityWin*>(&descendant);
   while (parent_object && parent_object != this) {
     current_object = parent_object;
     parent_object = current_object->GetParent()->ToBrowserAccessibilityWin();
   }
   if (!parent_object)
     return -1;
 
@@ skipping 13 matching lines @@
   // Either 0 or text_length should be returned depending on the direction that
   // one needs to travel to find the endpoint.
 
   // Case 1.
   //
   // IsDescendantOf includes the case when endpoint_object == this.
   if (IsDescendantOf(&endpoint_object))
     return endpoint_offset;
 
   const BrowserAccessibility* common_parent = this;
-  int32 index_in_common_parent = GetIndexInParent();
+  int32_t index_in_common_parent = GetIndexInParent();
   while (common_parent && !endpoint_object.IsDescendantOf(common_parent)) {
     index_in_common_parent = common_parent->GetIndexInParent();
     common_parent = common_parent->GetParent();
   }
   if (!common_parent)
     return -1;
 
   DCHECK_GE(index_in_common_parent, 0);
   DCHECK(!(common_parent->IsTextOnlyObject()));
 
   // Case 2.
   //
   // We already checked in case 1 if our endpoint is inside this object.
   // We can safely assume that it is a descendant or in a completely different
   // part of the tree.
   if (common_parent == this) {
-    int32 hypertext_offset = GetHypertextOffsetFromDescendant(endpoint_object);
+    int32_t hypertext_offset =
+        GetHypertextOffsetFromDescendant(endpoint_object);
     if (endpoint_object.GetParent() == this &&
         endpoint_object.IsTextOnlyObject()) {
       hypertext_offset += endpoint_offset;
     }
 
     return hypertext_offset;
   }
 
   // Case 3.
   //
   // We can safely assume that the endpoint is in another part of the tree or
   // at common parent, and that this object is a descendant of common parent.
-  int32 endpoint_index_in_common_parent = -1;
-  for (uint32 i = 0; i < common_parent->InternalChildCount(); ++i) {
+  int32_t endpoint_index_in_common_parent = -1;
+  for (uint32_t i = 0; i < common_parent->InternalChildCount(); ++i) {
     const BrowserAccessibility* child = common_parent->InternalGetChild(i);
     DCHECK(child);
     if (endpoint_object.IsDescendantOf(child)) {
       endpoint_index_in_common_parent = child->GetIndexInParent();
       break;
     }
   }
   DCHECK_GE(endpoint_index_in_common_parent, 0);
 
   if (endpoint_index_in_common_parent < index_in_common_parent)
     return 0;
   if (endpoint_index_in_common_parent > index_in_common_parent)
     return hypertext().length();
 
   NOTREACHED();
   return -1;
 }
 
 int BrowserAccessibilityWin::GetSelectionAnchor() const {
-  int32 anchor_id = manager()->GetTreeData().sel_anchor_object_id;
+  int32_t anchor_id = manager()->GetTreeData().sel_anchor_object_id;
   const auto anchor_object =
       manager()->GetFromID(anchor_id)->ToBrowserAccessibilityWin();
   if (!anchor_object)
     return -1;
 
   int anchor_offset = manager()->GetTreeData().sel_anchor_offset;
   return GetHypertextOffsetFromEndpoint(*anchor_object, anchor_offset);
 }
 
 int BrowserAccessibilityWin::GetSelectionFocus() const {
-  int32 focus_id = manager()->GetTreeData().sel_focus_object_id;
+  int32_t focus_id = manager()->GetTreeData().sel_focus_object_id;
   const auto focus_object =
       manager()->GetFromID(focus_id)->ToBrowserAccessibilityWin();
   if (!focus_object)
     return -1;
 
   int focus_offset = manager()->GetTreeData().sel_focus_offset;
   return GetHypertextOffsetFromEndpoint(*focus_object, focus_offset);
 }
 
 void BrowserAccessibilityWin::GetSelectionOffsets(
@@ skipping 77 matching lines @@
   // characters directly.
   base::char16 old_ch = old_win_attributes_->hypertext[old_char_index];
   base::char16 new_ch = win_attributes_->hypertext[new_char_index];
   if (old_ch != new_ch)
     return false;
   if (old_ch == new_ch && new_ch != kEmbeddedCharacter)
     return true;
 
   // If it's an embedded character, they're only identical if the child id
   // the hyperlink points to is the same.
-  std::map<int32, int32>& old_offset_to_index =
+  std::map<int32_t, int32_t>& old_offset_to_index =
       old_win_attributes_->hyperlink_offset_to_index;
-  std::vector<int32>& old_hyperlinks = old_win_attributes_->hyperlinks;
-  int32 old_hyperlinks_count = static_cast<int32>(old_hyperlinks.size());
-  std::map<int32, int32>::iterator iter;
+  std::vector<int32_t>& old_hyperlinks = old_win_attributes_->hyperlinks;
+  int32_t old_hyperlinks_count = static_cast<int32_t>(old_hyperlinks.size());
+  std::map<int32_t, int32_t>::iterator iter;
   iter = old_offset_to_index.find(old_char_index);
   int old_index = (iter != old_offset_to_index.end()) ? iter->second : -1;
   int old_child_id = (old_index >= 0 && old_index < old_hyperlinks_count) ?
       old_hyperlinks[old_index] : -1;
 
-  std::map<int32, int32>& new_offset_to_index =
+  std::map<int32_t, int32_t>& new_offset_to_index =
       win_attributes_->hyperlink_offset_to_index;
-  std::vector<int32>& new_hyperlinks = win_attributes_->hyperlinks;
-  int32 new_hyperlinks_count = static_cast<int32>(new_hyperlinks.size());
+  std::vector<int32_t>& new_hyperlinks = win_attributes_->hyperlinks;
+  int32_t new_hyperlinks_count = static_cast<int32_t>(new_hyperlinks.size());
   iter = new_offset_to_index.find(new_char_index);
   int new_index = (iter != new_offset_to_index.end()) ? iter->second : -1;
   int new_child_id = (new_index >= 0 && new_index < new_hyperlinks_count) ?
       new_hyperlinks[new_index] : -1;
 
   return old_child_id == new_child_id;
 }
 
 void BrowserAccessibilityWin::ComputeHypertextRemovedAndInserted(
     int* start, int* old_len, int* new_len) {
@@ skipping 60 matching lines @@
 LONG BrowserAccessibilityWin::FindBoundary(
     const base::string16& text,
     IA2TextBoundaryType ia2_boundary,
     LONG start_offset,
     ui::TextBoundaryDirection direction) {
   HandleSpecialTextOffset(text, &start_offset);
   if (ia2_boundary == IA2_TEXT_BOUNDARY_WORD && IsSimpleTextControl())
     return GetWordStartBoundary(static_cast<int>(start_offset), direction);
 
   ui::TextBoundaryType boundary = IA2TextBoundaryToTextBoundary(ia2_boundary);
-  const std::vector<int32>& line_breaks = GetIntListAttribute(
-      ui::AX_ATTR_LINE_BREAKS);
+  const std::vector<int32_t>& line_breaks =
+      GetIntListAttribute(ui::AX_ATTR_LINE_BREAKS);
   return ui::FindAccessibleTextBoundary(
       text, line_breaks, boundary, start_offset, direction);
 }
 
-BrowserAccessibilityWin* BrowserAccessibilityWin::GetFromID(int32 id) {
+BrowserAccessibilityWin* BrowserAccessibilityWin::GetFromID(int32_t id) {
   return manager()->GetFromID(id)->ToBrowserAccessibilityWin();
 }
 
 bool BrowserAccessibilityWin::IsListBoxOptionOrMenuListOption() {
   if (!GetParent())
     return false;
 
-  int32 role = GetRole();
-  int32 parent_role = GetParent()->GetRole();
+  int32_t role = GetRole();
+  int32_t parent_role = GetParent()->GetRole();
 
   if (role == ui::AX_ROLE_LIST_BOX_OPTION &&
       parent_role == ui::AX_ROLE_LIST_BOX) {
     return true;
   }
 
   if (role == ui::AX_ROLE_MENU_LIST_OPTION &&
       parent_role == ui::AX_ROLE_MENU_LIST_POPUP) {
     return true;
   }
@@ skipping 63 matching lines @@
     win_attributes_->ia2_attributes.push_back(L"text-input-type:" + type);
   }
 }
 
 void BrowserAccessibilityWin::AddRelations(
     ui::AXIntListAttribute src_attr,
     const base::string16& iaccessiblerelation_type) {
   if (!HasIntListAttribute(src_attr))
     return;
 
-  const std::vector<int32>& ids = GetIntListAttribute(src_attr);
+  const std::vector<int32_t>& ids = GetIntListAttribute(src_attr);
   for (size_t i = 0; i < ids.size(); ++i) {
     CComObject<BrowserAccessibilityRelation>* relation;
     HRESULT hr = CComObject<BrowserAccessibilityRelation>::CreateInstance(
         &relation);
     DCHECK(SUCCEEDED(hr));
     relation->AddRef();
     relation->Initialize(this, iaccessiblerelation_type);
     relation->AddTarget(ids[i]);
     relations_.push_back(relation);
   }
 }
 
 void BrowserAccessibilityWin::InitRoleAndState() {
-  int32 ia_role = 0;
-  int32 ia_state = 0;
+  int32_t ia_role = 0;
+  int32_t ia_state = 0;
   base::string16 role_name;
-  int32 ia2_role = 0;
-  int32 ia2_state = IA2_STATE_OPAQUE;
+  int32_t ia2_role = 0;
+  int32_t ia2_state = IA2_STATE_OPAQUE;
 
   if (HasState(ui::AX_STATE_BUSY))
     ia_state |= STATE_SYSTEM_BUSY;
   if (HasState(ui::AX_STATE_CHECKED))
     ia_state |= STATE_SYSTEM_CHECKED;
   if (HasState(ui::AX_STATE_COLLAPSED))
     ia_state |= STATE_SYSTEM_COLLAPSED;
   if (HasState(ui::AX_STATE_EXPANDED))
     ia_state |= STATE_SYSTEM_EXPANDED;
   if (HasState(ui::AX_STATE_FOCUSABLE))
@@ skipping 528 matching lines @@
     ia2_role = ia_role;
 
   win_attributes_->ia_role = ia_role;
   win_attributes_->ia_state = ia_state;
   win_attributes_->role_name = role_name;
   win_attributes_->ia2_role = ia2_role;
   win_attributes_->ia2_state = ia2_state;
 }
 
 }  // namespace content