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,
+                                       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 SparseAttributeMap : public blink::WebAXSparseAttributeMap {

[aboxhall, 2017/01/10 05:59:59]

The name "SparseAttributeMap" is confusing me a bit, since none of these (other
than the test implementation) seem to be actual data stores but instead
selectively copy data through to some other place. In particular, they are write
only, where "Map" implies that you might be able to get the data out again.

[dmazzoni, 2017/01/12 03:36:24]

Done.

+ public:
+  SparseAttributeMap(AXContentNodeData* dst) : dst_(dst) {}
+  ~SparseAttributeMap() override {}
+
+ private:
+  AXContentNodeData* dst_;
+
+  void addBoolAttribute(blink::WebAXBoolAttribute attribute,
+                        bool value) override {
+    switch (attribute) {
+      case blink::WebAXBoolAttribute::AriaModal:
+        // TODO(dmazzoni): implement aria-modal. http://crbug.com/644766
+        break;
+      default:
+        NOTREACHED();
+    }
+  }
+
+  void addStringAttribute(blink::WebAXStringAttribute attribute,
+                          const blink::WebString& value) override {
+    switch (attribute) {
+      case blink::WebAXStringAttribute::AriaKeyShortcuts:
+        // TODO(dmazzoni): implement aria-keyshortcuts. http://crbug.com/644766
+        break;
+      case blink::WebAXStringAttribute::AriaRoleDescription:
+        // TODO(dmazzoni): implement aria-roledescription.
+        // http://crbug.com/644766
+        break;
+      default:
+        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;
+      case blink::WebAXObjectAttribute::AriaErrorMessage:
+        // TODO

[aboxhall, 2017/01/10 05:59:59]

Any chance we could add these values in the follow-up change instead? There's so
much going on in this change already.

[dmazzoni, 2017/01/12 03:36:24]

Sure. I'll pull the new attributes into a middle change in-between this one and
the
one that was going to follow.

+        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::AriaDetails:
+        // TODO
+        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();
 
+  SparseAttributeMap sparse_map(dst);
+  src.getSparseAXAttributes(sparse_map);
+
   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