The children of non-editable combo boxes, search boxes and text fields should not be hidden

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 681 matching lines @@
 //
 
 STDMETHODIMP BrowserAccessibilityWin::role(LONG* role) {
   if (!instance_active())
     return E_FAIL;
 
   if (!role)
     return E_INVALIDARG;
 
   *role = ia2_role();
-
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_attributes(BSTR* attributes) {
   if (!attributes)
     return E_INVALIDARG;
   *attributes = nullptr;
 
   if (!instance_active())
     return E_FAIL;
@@ skipping 2606 matching lines @@
 
   return CComObjectRootBase::InternalQueryInterface(
       this_ptr, entries, iid, object);
 }
 
 void BrowserAccessibilityWin::ComputeStylesIfNeeded() {
   if (!offset_to_text_attributes().empty())
     return;
 
   std::map<int, std::vector<base::string16>> attributes_map;
-  if (PlatformIsLeaf()) {
+  if (PlatformIsLeaf() || IsSimpleTextControl()) {
     attributes_map[0] = ComputeTextAttributes();
     std::map<int, std::vector<base::string16>> spelling_attributes =
         GetSpellingAttributes();
     for (auto& spelling_attribute : spelling_attributes) {
       auto attributes_iterator = attributes_map.find(spelling_attribute.first);
       if (attributes_iterator == attributes_map.end()) {
         attributes_map[spelling_attribute.first] =
             std::move(spelling_attribute.second);
       } else {
         std::vector<base::string16>& existing_attributes =
             attributes_iterator->second;
+
+        // There might be a spelling attribute already in the list of text
+        // attributes, originating from "aria-invalid".
         auto existing_spelling_attribute =
             std::find(existing_attributes.begin(), existing_attributes.end(),
                       L"invalid:false");
         if (existing_spelling_attribute != existing_attributes.end())
           existing_attributes.erase(existing_spelling_attribute);
+
         existing_attributes.insert(existing_attributes.end(),
                                    spelling_attribute.second.begin(),
                                    spelling_attribute.second.end());
       }
     }
     win_attributes_->offset_to_text_attributes.swap(attributes_map);
     return;
   }
 
   int start_offset = 0;
@@ skipping 196 matching lines @@
   // If this is a web area for a presentational iframe, give it a role of
   // something other than DOCUMENT so that the fact that it's a separate doc
   // is not exposed to AT.
   if (IsWebAreaForPresentationalIframe()) {
     win_attributes_->ia_role = ROLE_SYSTEM_GROUPING;
     win_attributes_->ia2_role = ROLE_SYSTEM_GROUPING;
   }
 }
 
 void BrowserAccessibilityWin::UpdateStep2ComputeHypertext() {
-  if (!PlatformChildCount()) {
-    if (IsSimpleTextControl()) {
-      win_attributes_->hypertext = value();
-    } else if (IsRichTextControl()) {
-      // We don't want to expose any associated label in IA2 Hypertext.
-      return;
-    } else {
-      win_attributes_->hypertext = name();
-    }
-
+  if (IsSimpleTextControl()) {
+    win_attributes_->hypertext = value();
     return;
   }
 
+  if (!PlatformChildCount()) {
+    if (IsRichTextControl()) {
+      // We don't want to expose any associated label in IA2 Hypertext.
+      return;
+    }
+    win_attributes_->hypertext = name();
+    return;
+  }
+
   // Construct the hypertext for this node, which contains the concatenation
   // of all of the static text and widespace of this node's children and an
   // embedded object character for all the other children. Build up a map from
   // 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) {
     const auto child = ToBrowserAccessibilityWin(PlatformGetChild(i));
     DCHECK(child);
     // Similar to Firefox, we don't expose text-only objects in IA2 hypertext.
     if (child->IsTextOnlyObject()) {
@@ skipping 297 matching lines @@
 }
 
 BrowserAccessibilityWin* BrowserAccessibilityWin::NewReference() {
   AddRef();
   return this;
 }
 
 std::map<int, std::vector<base::string16>>
 BrowserAccessibilityWin::GetSpellingAttributes() const {
   std::map<int, std::vector<base::string16>> spelling_attributes;
-
-  // It doesn't make sense to expose spelling error information on anything
-  // other than a leaf object, because non-leaf objects do not expose text
-  // directly.
-  if (!PlatformIsLeaf())
-    return spelling_attributes;
-
   if (IsTextOnlyObject()) {
     const std::vector<int32_t>& marker_types =
         GetIntListAttribute(ui::AX_ATTR_MARKER_TYPES);
     const std::vector<int>& marker_starts =
         GetIntListAttribute(ui::AX_ATTR_MARKER_STARTS);
     const std::vector<int>& marker_ends =
         GetIntListAttribute(ui::AX_ATTR_MARKER_ENDS);
     for (size_t i = 0; i < marker_types.size(); ++i) {
       if (!(static_cast<ui::AXMarkerType>(marker_types[i]) &
             ui::AX_MARKER_TYPE_SPELLING))
         continue;
       int start_offset = marker_starts[i];
       int end_offset = marker_ends[i];
       std::vector<base::string16> start_attributes;
       start_attributes.push_back(L"invalid:spelling");
       std::vector<base::string16> end_attributes;
       end_attributes.push_back(L"invalid:false");
       spelling_attributes[start_offset] = start_attributes;
       spelling_attributes[end_offset] = end_attributes;
     }
   }
-
   if (IsSimpleTextControl()) {
     int start_offset = 0;
     for (const BrowserAccessibility* static_text =
              BrowserAccessibilityManager::NextTextOnlyObject(
                  InternalGetChild(0));
          static_text; static_text = static_text->GetNextSibling()) {
       auto text_win = ToBrowserAccessibilityWin(static_text);
       if (text_win) {
         std::map<int, std::vector<base::string16>> text_spelling_attributes =
             text_win->GetSpellingAttributes();
         for (auto& attribute : text_spelling_attributes) {
           spelling_attributes[start_offset + attribute.first] =
               std::move(attribute.second);
         }
         start_offset += static_cast<int>(text_win->GetText().length());
       }
     }
   }
-
   return spelling_attributes;
 }
 
 BrowserAccessibilityWin* BrowserAccessibilityWin::GetTargetFromChildID(
     const VARIANT& var_id) {
   if (var_id.vt != VT_I4)
     return nullptr;
 
   LONG child_id = var_id.lVal;
   if (child_id == CHILDID_SELF)
@@ skipping 1254 matching lines @@
   return static_cast<BrowserAccessibilityWin*>(obj);
 }
 
 const BrowserAccessibilityWin*
 ToBrowserAccessibilityWin(const BrowserAccessibility* obj) {
   DCHECK(!obj || obj->IsNative());
   return static_cast<const BrowserAccessibilityWin*>(obj);
 }
 
 }  // namespace content