Add sparse accessibility attribute interface to Blink

content/renderer/accessibility/blink_ax_tree_source.cc

 // Copyright 2014 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/renderer/accessibility/blink_ax_tree_source.h"
 
 #include <stddef.h>
 
 #include <set>
 
@@ skipping 37 matching lines @@
 using blink::WebNode;
 using blink::WebPlugin;
 using blink::WebPluginContainer;
 using blink::WebVector;
 using blink::WebView;
 
 namespace content {
 
 namespace {
 
+void AddIntListAttributeFromWebObjects(ui::AXIntListAttribute attr,
+                                       WebVector<WebAXObject> objects,

[dcheng, 2017/01/19 23:02:44]

Nit: pass by const ref

[dmazzoni, 2017/01/21 00:16:35]

Done.

+                                       AXContentNodeData* dst) {
+  std::vector<int32_t> ids;
+  for (size_t i = 0; i < objects.size(); i++)
+    ids.push_back(objects[i].axID());
+  if (!ids.empty())
+    dst->AddIntListAttribute(attr, ids);
+}
+
+class AXContentNodeDataSparseAttributeAdapter
+    : public blink::WebAXSparseAttributeClient {
+ public:
+  AXContentNodeDataSparseAttributeAdapter(AXContentNodeData* dst) : dst_(dst) {}
+  ~AXContentNodeDataSparseAttributeAdapter() override {}
+
+ private:
+  AXContentNodeData* dst_;
+
+  void addBoolAttribute(blink::WebAXBoolAttribute attribute,
+                        bool value) override {
+    NOTREACHED();
+  }
+
+  void addStringAttribute(blink::WebAXStringAttribute attribute,
+                          const blink::WebString& value) override {
+    NOTREACHED();
+  }
+
+  void addObjectAttribute(blink::WebAXObjectAttribute attribute,
+                          const blink::WebAXObject& value) override {
+    switch (attribute) {
+      case blink::WebAXObjectAttribute::AriaActiveDescendant:
+        dst_->AddIntAttribute(ui::AX_ATTR_ACTIVEDESCENDANT_ID, value.axID());
+        break;
+      default:
+        NOTREACHED();
+    }
+  }
+
+  void addObjectVectorAttribute(
+      blink::WebAXObjectVectorAttribute attribute,
+      const blink::WebVector<WebAXObject>& value) override {
+    switch (attribute) {
+      case blink::WebAXObjectVectorAttribute::AriaControls:
+        AddIntListAttributeFromWebObjects(ui::AX_ATTR_CONTROLS_IDS, value,
+                                          dst_);
+        break;
+      case blink::WebAXObjectVectorAttribute::AriaFlowTo:
+        AddIntListAttributeFromWebObjects(ui::AX_ATTR_FLOWTO_IDS, value, dst_);
+        break;
+      default:
+        NOTREACHED();
+    }
+  }
+};
+
 WebAXObject ParentObjectUnignored(WebAXObject child) {
   WebAXObject parent = child.parentObject();
   while (!parent.isDetached() && parent.accessibilityIsIgnored())
     parent = parent.parentObject();
   return parent;
 }
 
 // Returns true if |ancestor| is the first unignored parent of |child|,
 // which means that when walking up the parent chain from |child|,
 // |ancestor| is the *first* ancestor that isn't marked as
@@ skipping 34 matching lines @@
       return "slider";
     case ui::AX_ROLE_TIME:
       return "time";
     default:
       break;
   }
 
   return std::string();
 }
 
-void AddIntListAttributeFromWebObjects(ui::AXIntListAttribute attr,
-                                       WebVector<WebAXObject> objects,
-                                       AXContentNodeData* dst) {
-  std::vector<int32_t> ids;
-  for(size_t i = 0; i < objects.size(); i++)
-    ids.push_back(objects[i].axID());
-  if (ids.size() > 0)
-    dst->AddIntListAttribute(attr, ids);
-}
-
 }  // namespace
 
 ScopedFreezeBlinkAXTreeSource::ScopedFreezeBlinkAXTreeSource(
     BlinkAXTreeSource* tree_source)
     : tree_source_(tree_source) {
   tree_source_->Freeze();
 }
 
 ScopedFreezeBlinkAXTreeSource::~ScopedFreezeBlinkAXTreeSource() {
   tree_source_->Thaw();
@@ skipping 185 matching lines @@
   WebFloatRect bounds_in_container;
   SkMatrix44 container_transform;
   src.getRelativeBounds(
       offset_container, bounds_in_container, container_transform);
   dst->location = bounds_in_container;
   if (!container_transform.isIdentity())
     dst->transform = base::WrapUnique(new gfx::Transform(container_transform));
   if (!offset_container.isDetached())
     dst->offset_container_id = offset_container.axID();
 
+  AXContentNodeDataSparseAttributeAdapter sparse_attribute_adapter(dst);
+  src.getSparseAXAttributes(sparse_attribute_adapter);
+
   blink::WebAXNameFrom nameFrom;
   blink::WebVector<blink::WebAXObject> nameObjects;
   blink::WebString web_name = src.name(nameFrom, nameObjects);
   if (!web_name.isEmpty()) {
     dst->AddStringAttribute(ui::AX_ATTR_NAME, web_name.utf8());
     dst->AddIntAttribute(ui::AX_ATTR_NAME_FROM, AXNameFromFromBlink(nameFrom));
     AddIntListAttributeFromWebObjects(
         ui::AX_ATTR_LABELLEDBY_IDS, nameObjects, dst);
   }
 
@@ skipping 411 matching lines @@
     WebAXObject child = src.childAt(i);
     std::vector<int32_t> indirect_child_ids;
     if (!is_iframe && !child.isDetached() && !IsParentUnignoredOf(src, child))
       indirect_child_ids.push_back(child.axID());
     if (indirect_child_ids.size() > 0) {
       dst->AddIntListAttribute(
           ui::AX_ATTR_INDIRECT_CHILD_IDS, indirect_child_ids);
     }
   }
 
-  WebVector<WebAXObject> controls;
-  if (src.ariaControls(controls))
-    AddIntListAttributeFromWebObjects(ui::AX_ATTR_CONTROLS_IDS, controls, dst);
-
-  WebVector<WebAXObject> flowTo;
-  if (src.ariaFlowTo(flowTo))
-    AddIntListAttributeFromWebObjects(ui::AX_ATTR_FLOWTO_IDS, flowTo, dst);
-
   if (src.isScrollableContainer()) {
     const gfx::Point& scrollOffset = src.getScrollOffset();
     dst->AddIntAttribute(ui::AX_ATTR_SCROLL_X, scrollOffset.x());
     dst->AddIntAttribute(ui::AX_ATTR_SCROLL_Y, scrollOffset.y());
 
     const gfx::Point& minScrollOffset = src.minimumScrollOffset();
     dst->AddIntAttribute(ui::AX_ATTR_SCROLL_X_MIN, minScrollOffset.x());
     dst->AddIntAttribute(ui::AX_ATTR_SCROLL_Y_MIN, minScrollOffset.y());
 
     const gfx::Point& maxScrollOffset = src.maximumScrollOffset();
@@ skipping 20 matching lines @@
     return WebAXObject();
 
   WebDocument document = render_frame_->GetWebFrame()->document();
   if (!document.isNull())
     return document.accessibilityObject();
 
   return WebAXObject();
 }
 
 }  // namespace content