Home | History | Annotate | Download | only in accessibility 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "content/browser/accessibility/browser_accessibility.h"
      6 
      7 #include "base/logging.h"
      8 #include "base/strings/string_number_conversions.h"
      9 #include "base/strings/string_util.h"
     10 #include "base/strings/utf_string_conversions.h"
     11 #include "content/browser/accessibility/browser_accessibility_manager.h"
     12 #include "content/common/accessibility_messages.h"
     13 
     14 namespace content {
     15 
     16 #if !defined(OS_MACOSX) && \
     17     !defined(OS_WIN) && \
     18     !defined(OS_ANDROID)
     19 // We have subclassess of BrowserAccessibility on Mac and Win. For any other
     20 // platform, instantiate the base class.
     21 // static
     22 BrowserAccessibility* BrowserAccessibility::Create() {
     23   return new BrowserAccessibility();
     24 }
     25 #endif
     26 
     27 BrowserAccessibility::BrowserAccessibility()
     28     : manager_(NULL),
     29       node_(NULL) {
     30 }
     31 
     32 BrowserAccessibility::~BrowserAccessibility() {
     33 }
     34 
     35 void BrowserAccessibility::Init(BrowserAccessibilityManager* manager,
     36     ui::AXNode* node) {
     37   manager_ = manager;
     38   node_ = node;
     39 }
     40 
     41 void BrowserAccessibility::OnDataChanged() {
     42   GetStringAttribute(ui::AX_ATTR_NAME, &name_);
     43   GetStringAttribute(ui::AX_ATTR_VALUE, &value_);
     44 }
     45 
     46 bool BrowserAccessibility::PlatformIsLeaf() const {
     47   if (InternalChildCount() == 0)
     48     return true;
     49 
     50   // All of these roles may have children that we use as internal
     51   // implementation details, but we want to expose them as leaves
     52   // to platform accessibility APIs.
     53   switch (GetRole()) {
     54     case ui::AX_ROLE_EDITABLE_TEXT:
     55     case ui::AX_ROLE_SLIDER:
     56     case ui::AX_ROLE_STATIC_TEXT:
     57     case ui::AX_ROLE_TEXT_AREA:
     58     case ui::AX_ROLE_TEXT_FIELD:
     59       return true;
     60     default:
     61       return false;
     62   }
     63 }
     64 
     65 uint32 BrowserAccessibility::PlatformChildCount() const {
     66   return PlatformIsLeaf() ? 0 : InternalChildCount();
     67 }
     68 
     69 bool BrowserAccessibility::IsNative() const {
     70   return false;
     71 }
     72 
     73 bool BrowserAccessibility::IsDescendantOf(
     74     BrowserAccessibility* ancestor) {
     75   if (this == ancestor) {
     76     return true;
     77   } else if (GetParent()) {
     78     return GetParent()->IsDescendantOf(ancestor);
     79   }
     80 
     81   return false;
     82 }
     83 
     84 BrowserAccessibility* BrowserAccessibility::PlatformGetChild(
     85     uint32 child_index) const {
     86   DCHECK(child_index < InternalChildCount());
     87   return InternalGetChild(child_index);
     88 }
     89 
     90 BrowserAccessibility* BrowserAccessibility::GetPreviousSibling() {
     91   if (GetParent() && GetIndexInParent() > 0)
     92     return GetParent()->InternalGetChild(GetIndexInParent() - 1);
     93 
     94   return NULL;
     95 }
     96 
     97 BrowserAccessibility* BrowserAccessibility::GetNextSibling() {
     98   if (GetParent() &&
     99       GetIndexInParent() >= 0 &&
    100       GetIndexInParent() < static_cast<int>(
    101           GetParent()->InternalChildCount() - 1)) {
    102     return GetParent()->InternalGetChild(GetIndexInParent() + 1);
    103   }
    104 
    105   return NULL;
    106 }
    107 
    108 uint32 BrowserAccessibility::InternalChildCount() const {
    109   if (!node_ || !manager_)
    110     return 0;
    111   return static_cast<uint32>(node_->child_count());
    112 }
    113 
    114 BrowserAccessibility* BrowserAccessibility::InternalGetChild(
    115     uint32 child_index) const {
    116   if (!node_ || !manager_)
    117     return NULL;
    118   return manager_->GetFromAXNode(node_->children()[child_index]);
    119 }
    120 
    121 BrowserAccessibility* BrowserAccessibility::GetParent() const {
    122   if (!node_ || !manager_)
    123     return NULL;
    124   ui::AXNode* parent = node_->parent();
    125   return parent ? manager_->GetFromAXNode(parent) : NULL;
    126 }
    127 
    128 int32 BrowserAccessibility::GetIndexInParent() const {
    129   return node_ ? node_->index_in_parent() : -1;
    130 }
    131 
    132 int32 BrowserAccessibility::GetId() const {
    133   return node_ ? node_->id() : -1;
    134 }
    135 
    136 const ui::AXNodeData& BrowserAccessibility::GetData() const {
    137   CR_DEFINE_STATIC_LOCAL(ui::AXNodeData, empty_data, ());
    138   if (node_)
    139     return node_->data();
    140   else
    141     return empty_data;
    142 }
    143 
    144 gfx::Rect BrowserAccessibility::GetLocation() const {
    145   return GetData().location;
    146 }
    147 
    148 int32 BrowserAccessibility::GetRole() const {
    149   return GetData().role;
    150 }
    151 
    152 int32 BrowserAccessibility::GetState() const {
    153   return GetData().state;
    154 }
    155 
    156 const std::vector<std::pair<std::string, std::string> >&
    157 BrowserAccessibility::GetHtmlAttributes() const {
    158   return GetData().html_attributes;
    159 }
    160 
    161 gfx::Rect BrowserAccessibility::GetLocalBoundsRect() const {
    162   gfx::Rect bounds = GetLocation();
    163 
    164   // Walk up the parent chain. Every time we encounter a Web Area, offset
    165   // based on the scroll bars and then offset based on the origin of that
    166   // nested web area.
    167   BrowserAccessibility* parent = GetParent();
    168   bool need_to_offset_web_area =
    169       (GetRole() == ui::AX_ROLE_WEB_AREA ||
    170        GetRole() == ui::AX_ROLE_ROOT_WEB_AREA);
    171   while (parent) {
    172     if (need_to_offset_web_area &&
    173         parent->GetLocation().width() > 0 &&
    174         parent->GetLocation().height() > 0) {
    175       bounds.Offset(parent->GetLocation().x(), parent->GetLocation().y());
    176       need_to_offset_web_area = false;
    177     }
    178 
    179     // On some platforms, we don't want to take the root scroll offsets
    180     // into account.
    181     if (parent->GetRole() == ui::AX_ROLE_ROOT_WEB_AREA &&
    182         !manager()->UseRootScrollOffsetsWhenComputingBounds()) {
    183       break;
    184     }
    185 
    186     if (parent->GetRole() == ui::AX_ROLE_WEB_AREA ||
    187         parent->GetRole() == ui::AX_ROLE_ROOT_WEB_AREA) {
    188       int sx = 0;
    189       int sy = 0;
    190       if (parent->GetIntAttribute(ui::AX_ATTR_SCROLL_X, &sx) &&
    191           parent->GetIntAttribute(ui::AX_ATTR_SCROLL_Y, &sy)) {
    192         bounds.Offset(-sx, -sy);
    193       }
    194       need_to_offset_web_area = true;
    195     }
    196     parent = parent->GetParent();
    197   }
    198 
    199   return bounds;
    200 }
    201 
    202 gfx::Rect BrowserAccessibility::GetGlobalBoundsRect() const {
    203   gfx::Rect bounds = GetLocalBoundsRect();
    204 
    205   // Adjust the bounds by the top left corner of the containing view's bounds
    206   // in screen coordinates.
    207   bounds.Offset(manager_->GetViewBounds().OffsetFromOrigin());
    208 
    209   return bounds;
    210 }
    211 
    212 gfx::Rect BrowserAccessibility::GetLocalBoundsForRange(int start, int len)
    213     const {
    214   if (GetRole() != ui::AX_ROLE_STATIC_TEXT) {
    215     // Apply recursively to all static text descendants. For example, if
    216     // you call it on a div with two text node children, it just calls
    217     // GetLocalBoundsForRange on each of the two children (adjusting
    218     // |start| for each one) and unions the resulting rects.
    219     gfx::Rect bounds;
    220     for (size_t i = 0; i < InternalChildCount(); ++i) {
    221       BrowserAccessibility* child = InternalGetChild(i);
    222       int child_len = child->GetStaticTextLenRecursive();
    223       if (start < child_len && start + len > 0) {
    224         gfx::Rect child_rect = child->GetLocalBoundsForRange(start, len);
    225         bounds.Union(child_rect);
    226       }
    227       start -= child_len;
    228     }
    229     return bounds;
    230   }
    231 
    232   int end = start + len;
    233   int child_start = 0;
    234   int child_end = 0;
    235 
    236   gfx::Rect bounds;
    237   for (size_t i = 0; i < InternalChildCount() && child_end < start + len; ++i) {
    238     BrowserAccessibility* child = InternalGetChild(i);
    239     DCHECK_EQ(child->GetRole(), ui::AX_ROLE_INLINE_TEXT_BOX);
    240     std::string child_text;
    241     child->GetStringAttribute(ui::AX_ATTR_VALUE, &child_text);
    242     int child_len = static_cast<int>(child_text.size());
    243     child_start = child_end;
    244     child_end += child_len;
    245 
    246     if (child_end < start)
    247       continue;
    248 
    249     int overlap_start = std::max(start, child_start);
    250     int overlap_end = std::min(end, child_end);
    251 
    252     int local_start = overlap_start - child_start;
    253     int local_end = overlap_end - child_start;
    254 
    255     gfx::Rect child_rect = child->GetLocation();
    256     int text_direction = child->GetIntAttribute(
    257         ui::AX_ATTR_TEXT_DIRECTION);
    258     const std::vector<int32>& character_offsets = child->GetIntListAttribute(
    259         ui::AX_ATTR_CHARACTER_OFFSETS);
    260     int start_pixel_offset =
    261         local_start > 0 ? character_offsets[local_start - 1] : 0;
    262     int end_pixel_offset =
    263         local_end > 0 ? character_offsets[local_end - 1] : 0;
    264 
    265     gfx::Rect child_overlap_rect;
    266     switch (text_direction) {
    267       case ui::AX_TEXT_DIRECTION_NONE:
    268       case ui::AX_TEXT_DIRECTION_LR: {
    269         int left = child_rect.x() + start_pixel_offset;
    270         int right = child_rect.x() + end_pixel_offset;
    271         child_overlap_rect = gfx::Rect(left, child_rect.y(),
    272                                        right - left, child_rect.height());
    273         break;
    274       }
    275       case ui::AX_TEXT_DIRECTION_RL: {
    276         int right = child_rect.right() - start_pixel_offset;
    277         int left = child_rect.right() - end_pixel_offset;
    278         child_overlap_rect = gfx::Rect(left, child_rect.y(),
    279                                        right - left, child_rect.height());
    280         break;
    281       }
    282       case ui::AX_TEXT_DIRECTION_TB: {
    283         int top = child_rect.y() + start_pixel_offset;
    284         int bottom = child_rect.y() + end_pixel_offset;
    285         child_overlap_rect = gfx::Rect(child_rect.x(), top,
    286                                        child_rect.width(), bottom - top);
    287         break;
    288       }
    289       case ui::AX_TEXT_DIRECTION_BT: {
    290         int bottom = child_rect.bottom() - start_pixel_offset;
    291         int top = child_rect.bottom() - end_pixel_offset;
    292         child_overlap_rect = gfx::Rect(child_rect.x(), top,
    293                                        child_rect.width(), bottom - top);
    294         break;
    295       }
    296       default:
    297         NOTREACHED();
    298     }
    299 
    300     if (bounds.width() == 0 && bounds.height() == 0)
    301       bounds = child_overlap_rect;
    302     else
    303       bounds.Union(child_overlap_rect);
    304   }
    305 
    306   return bounds;
    307 }
    308 
    309 gfx::Rect BrowserAccessibility::GetGlobalBoundsForRange(int start, int len)
    310     const {
    311   gfx::Rect bounds = GetLocalBoundsForRange(start, len);
    312 
    313   // Adjust the bounds by the top left corner of the containing view's bounds
    314   // in screen coordinates.
    315   bounds.Offset(manager_->GetViewBounds().OffsetFromOrigin());
    316 
    317   return bounds;
    318 }
    319 
    320 BrowserAccessibility* BrowserAccessibility::BrowserAccessibilityForPoint(
    321     const gfx::Point& point) {
    322   // The best result found that's a child of this object.
    323   BrowserAccessibility* child_result = NULL;
    324   // The best result that's an indirect descendant like grandchild, etc.
    325   BrowserAccessibility* descendant_result = NULL;
    326 
    327   // Walk the children recursively looking for the BrowserAccessibility that
    328   // most tightly encloses the specified point. Walk backwards so that in
    329   // the absence of any other information, we assume the object that occurs
    330   // later in the tree is on top of one that comes before it.
    331   for (int i = static_cast<int>(PlatformChildCount()) - 1; i >= 0; --i) {
    332     BrowserAccessibility* child = PlatformGetChild(i);
    333 
    334     // Skip table columns because cells are only contained in rows,
    335     // not columns.
    336     if (child->GetRole() == ui::AX_ROLE_COLUMN)
    337       continue;
    338 
    339     if (child->GetGlobalBoundsRect().Contains(point)) {
    340       BrowserAccessibility* result = child->BrowserAccessibilityForPoint(point);
    341       if (result == child && !child_result)
    342         child_result = result;
    343       if (result != child && !descendant_result)
    344         descendant_result = result;
    345     }
    346 
    347     if (child_result && descendant_result)
    348       break;
    349   }
    350 
    351   // Explanation of logic: it's possible that this point overlaps more than
    352   // one child of this object. If so, as a heuristic we prefer if the point
    353   // overlaps a descendant of one of the two children and not the other.
    354   // As an example, suppose you have two rows of buttons - the buttons don't
    355   // overlap, but the rows do. Without this heuristic, we'd greedily only
    356   // consider one of the containers.
    357   if (descendant_result)
    358     return descendant_result;
    359   if (child_result)
    360     return child_result;
    361 
    362   return this;
    363 }
    364 
    365 void BrowserAccessibility::Destroy() {
    366   // Allow the object to fire a TextRemoved notification.
    367   name_.clear();
    368   value_.clear();
    369 
    370   manager_->NotifyAccessibilityEvent(ui::AX_EVENT_HIDE, this);
    371   node_ = NULL;
    372   manager_ = NULL;
    373 
    374   NativeReleaseReference();
    375 }
    376 
    377 void BrowserAccessibility::NativeReleaseReference() {
    378   delete this;
    379 }
    380 
    381 bool BrowserAccessibility::HasBoolAttribute(
    382     ui::AXBoolAttribute attribute) const {
    383   const ui::AXNodeData& data = GetData();
    384   for (size_t i = 0; i < data.bool_attributes.size(); ++i) {
    385     if (data.bool_attributes[i].first == attribute)
    386       return true;
    387   }
    388 
    389   return false;
    390 }
    391 
    392 
    393 bool BrowserAccessibility::GetBoolAttribute(
    394     ui::AXBoolAttribute attribute) const {
    395   const ui::AXNodeData& data = GetData();
    396   for (size_t i = 0; i < data.bool_attributes.size(); ++i) {
    397     if (data.bool_attributes[i].first == attribute)
    398       return data.bool_attributes[i].second;
    399   }
    400 
    401   return false;
    402 }
    403 
    404 bool BrowserAccessibility::GetBoolAttribute(
    405     ui::AXBoolAttribute attribute, bool* value) const {
    406   const ui::AXNodeData& data = GetData();
    407   for (size_t i = 0; i < data.bool_attributes.size(); ++i) {
    408     if (data.bool_attributes[i].first == attribute) {
    409       *value = data.bool_attributes[i].second;
    410       return true;
    411     }
    412   }
    413 
    414   return false;
    415 }
    416 
    417 bool BrowserAccessibility::HasFloatAttribute(
    418     ui::AXFloatAttribute attribute) const {
    419   const ui::AXNodeData& data = GetData();
    420   for (size_t i = 0; i < data.float_attributes.size(); ++i) {
    421     if (data.float_attributes[i].first == attribute)
    422       return true;
    423   }
    424 
    425   return false;
    426 }
    427 
    428 float BrowserAccessibility::GetFloatAttribute(
    429     ui::AXFloatAttribute attribute) const {
    430   const ui::AXNodeData& data = GetData();
    431   for (size_t i = 0; i < data.float_attributes.size(); ++i) {
    432     if (data.float_attributes[i].first == attribute)
    433       return data.float_attributes[i].second;
    434   }
    435 
    436   return 0.0;
    437 }
    438 
    439 bool BrowserAccessibility::GetFloatAttribute(
    440     ui::AXFloatAttribute attribute, float* value) const {
    441   const ui::AXNodeData& data = GetData();
    442   for (size_t i = 0; i < data.float_attributes.size(); ++i) {
    443     if (data.float_attributes[i].first == attribute) {
    444       *value = data.float_attributes[i].second;
    445       return true;
    446     }
    447   }
    448 
    449   return false;
    450 }
    451 
    452 bool BrowserAccessibility::HasIntAttribute(
    453     ui::AXIntAttribute attribute) const {
    454   const ui::AXNodeData& data = GetData();
    455   for (size_t i = 0; i < data.int_attributes.size(); ++i) {
    456     if (data.int_attributes[i].first == attribute)
    457       return true;
    458   }
    459 
    460   return false;
    461 }
    462 
    463 int BrowserAccessibility::GetIntAttribute(ui::AXIntAttribute attribute) const {
    464   const ui::AXNodeData& data = GetData();
    465   for (size_t i = 0; i < data.int_attributes.size(); ++i) {
    466     if (data.int_attributes[i].first == attribute)
    467       return data.int_attributes[i].second;
    468   }
    469 
    470   return 0;
    471 }
    472 
    473 bool BrowserAccessibility::GetIntAttribute(
    474     ui::AXIntAttribute attribute, int* value) const {
    475   const ui::AXNodeData& data = GetData();
    476   for (size_t i = 0; i < data.int_attributes.size(); ++i) {
    477     if (data.int_attributes[i].first == attribute) {
    478       *value = data.int_attributes[i].second;
    479       return true;
    480     }
    481   }
    482 
    483   return false;
    484 }
    485 
    486 bool BrowserAccessibility::HasStringAttribute(
    487     ui::AXStringAttribute attribute) const {
    488   const ui::AXNodeData& data = GetData();
    489   for (size_t i = 0; i < data.string_attributes.size(); ++i) {
    490     if (data.string_attributes[i].first == attribute)
    491       return true;
    492   }
    493 
    494   return false;
    495 }
    496 
    497 const std::string& BrowserAccessibility::GetStringAttribute(
    498     ui::AXStringAttribute attribute) const {
    499   const ui::AXNodeData& data = GetData();
    500   CR_DEFINE_STATIC_LOCAL(std::string, empty_string, ());
    501   for (size_t i = 0; i < data.string_attributes.size(); ++i) {
    502     if (data.string_attributes[i].first == attribute)
    503       return data.string_attributes[i].second;
    504   }
    505 
    506   return empty_string;
    507 }
    508 
    509 bool BrowserAccessibility::GetStringAttribute(
    510     ui::AXStringAttribute attribute, std::string* value) const {
    511   const ui::AXNodeData& data = GetData();
    512   for (size_t i = 0; i < data.string_attributes.size(); ++i) {
    513     if (data.string_attributes[i].first == attribute) {
    514       *value = data.string_attributes[i].second;
    515       return true;
    516     }
    517   }
    518 
    519   return false;
    520 }
    521 
    522 base::string16 BrowserAccessibility::GetString16Attribute(
    523     ui::AXStringAttribute attribute) const {
    524   std::string value_utf8;
    525   if (!GetStringAttribute(attribute, &value_utf8))
    526     return base::string16();
    527   return base::UTF8ToUTF16(value_utf8);
    528 }
    529 
    530 bool BrowserAccessibility::GetString16Attribute(
    531     ui::AXStringAttribute attribute,
    532     base::string16* value) const {
    533   std::string value_utf8;
    534   if (!GetStringAttribute(attribute, &value_utf8))
    535     return false;
    536   *value = base::UTF8ToUTF16(value_utf8);
    537   return true;
    538 }
    539 
    540 void BrowserAccessibility::SetStringAttribute(
    541     ui::AXStringAttribute attribute, const std::string& value) {
    542   if (!node_)
    543     return;
    544   ui::AXNodeData data = GetData();
    545   for (size_t i = 0; i < data.string_attributes.size(); ++i) {
    546     if (data.string_attributes[i].first == attribute) {
    547       data.string_attributes[i].second = value;
    548       node_->SetData(data);
    549       return;
    550     }
    551   }
    552   if (!value.empty()) {
    553     data.string_attributes.push_back(std::make_pair(attribute, value));
    554     node_->SetData(data);
    555   }
    556 }
    557 
    558 bool BrowserAccessibility::HasIntListAttribute(
    559     ui::AXIntListAttribute attribute) const {
    560   const ui::AXNodeData& data = GetData();
    561   for (size_t i = 0; i < data.intlist_attributes.size(); ++i) {
    562     if (data.intlist_attributes[i].first == attribute)
    563       return true;
    564   }
    565 
    566   return false;
    567 }
    568 
    569 const std::vector<int32>& BrowserAccessibility::GetIntListAttribute(
    570     ui::AXIntListAttribute attribute) const {
    571   const ui::AXNodeData& data = GetData();
    572   CR_DEFINE_STATIC_LOCAL(std::vector<int32>, empty_vector, ());
    573   for (size_t i = 0; i < data.intlist_attributes.size(); ++i) {
    574     if (data.intlist_attributes[i].first == attribute)
    575       return data.intlist_attributes[i].second;
    576   }
    577 
    578   return empty_vector;
    579 }
    580 
    581 bool BrowserAccessibility::GetIntListAttribute(
    582     ui::AXIntListAttribute attribute,
    583     std::vector<int32>* value) const {
    584   const ui::AXNodeData& data = GetData();
    585   for (size_t i = 0; i < data.intlist_attributes.size(); ++i) {
    586     if (data.intlist_attributes[i].first == attribute) {
    587       *value = data.intlist_attributes[i].second;
    588       return true;
    589     }
    590   }
    591 
    592   return false;
    593 }
    594 
    595 bool BrowserAccessibility::GetHtmlAttribute(
    596     const char* html_attr, std::string* value) const {
    597   for (size_t i = 0; i < GetHtmlAttributes().size(); ++i) {
    598     const std::string& attr = GetHtmlAttributes()[i].first;
    599     if (LowerCaseEqualsASCII(attr, html_attr)) {
    600       *value = GetHtmlAttributes()[i].second;
    601       return true;
    602     }
    603   }
    604 
    605   return false;
    606 }
    607 
    608 bool BrowserAccessibility::GetHtmlAttribute(
    609     const char* html_attr, base::string16* value) const {
    610   std::string value_utf8;
    611   if (!GetHtmlAttribute(html_attr, &value_utf8))
    612     return false;
    613   *value = base::UTF8ToUTF16(value_utf8);
    614   return true;
    615 }
    616 
    617 bool BrowserAccessibility::GetAriaTristate(
    618     const char* html_attr,
    619     bool* is_defined,
    620     bool* is_mixed) const {
    621   *is_defined = false;
    622   *is_mixed = false;
    623 
    624   base::string16 value;
    625   if (!GetHtmlAttribute(html_attr, &value) ||
    626       value.empty() ||
    627       EqualsASCII(value, "undefined")) {
    628     return false;  // Not set (and *is_defined is also false)
    629   }
    630 
    631   *is_defined = true;
    632 
    633   if (EqualsASCII(value, "true"))
    634     return true;
    635 
    636   if (EqualsASCII(value, "mixed"))
    637     *is_mixed = true;
    638 
    639   return false;  // Not set
    640 }
    641 
    642 bool BrowserAccessibility::HasState(ui::AXState state_enum) const {
    643   return (GetState() >> state_enum) & 1;
    644 }
    645 
    646 bool BrowserAccessibility::IsEditableText() const {
    647   // These roles don't have readonly set, but they're not editable text.
    648   if (GetRole() == ui::AX_ROLE_SCROLL_AREA ||
    649       GetRole() == ui::AX_ROLE_COLUMN ||
    650       GetRole() == ui::AX_ROLE_TABLE_HEADER_CONTAINER) {
    651     return false;
    652   }
    653 
    654   // Note: WebAXStateReadonly being false means it's either a text control,
    655   // or contenteditable. We also check for editable text roles to cover
    656   // another element that has role=textbox set on it.
    657   return (!HasState(ui::AX_STATE_READ_ONLY) ||
    658           GetRole() == ui::AX_ROLE_TEXT_FIELD ||
    659           GetRole() == ui::AX_ROLE_TEXT_AREA);
    660 }
    661 
    662 std::string BrowserAccessibility::GetTextRecursive() const {
    663   if (!name_.empty()) {
    664     return name_;
    665   }
    666 
    667   std::string result;
    668   for (uint32 i = 0; i < PlatformChildCount(); ++i)
    669     result += PlatformGetChild(i)->GetTextRecursive();
    670   return result;
    671 }
    672 
    673 int BrowserAccessibility::GetStaticTextLenRecursive() const {
    674   if (GetRole() == ui::AX_ROLE_STATIC_TEXT)
    675     return static_cast<int>(GetStringAttribute(ui::AX_ATTR_VALUE).size());
    676 
    677   int len = 0;
    678   for (size_t i = 0; i < InternalChildCount(); ++i)
    679     len += InternalGetChild(i)->GetStaticTextLenRecursive();
    680   return len;
    681 }
    682 
    683 }  // namespace content
    684