Add sparse accessibility attribute interface to Blink

third_party/WebKit/Source/web/WebAXObject.cpp

 /*
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 44 matching lines @@
 #include "public/platform/WebURL.h"
 #include "public/web/WebDocument.h"
 #include "public/web/WebElement.h"
 #include "public/web/WebNode.h"
 #include "web/WebLocalFrameImpl.h"
 #include "web/WebViewImpl.h"
 #include "wtf/text/StringBuilder.h"
 
 namespace blink {
 
+class SparseAttributeMapAdapter : public AXSparseAttributeMap {

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

WebAX[...]Wrapper/Adapter?

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

This is now SparseAttributeClientAdapter

I'm not sure putting the WebAX prefix makes sense since it's just a helper class

[aboxhall, 2017/01/12 04:26:51]

I meant because it's adapting WebAXSparseAttributeClient (and similarly with
AXContentNodeData in BlinkAXTreeSource -> could be AXContentNodeDataAdapter
instead of SparseAttributeAdapter; also why is it a SparseAttributeAdapter there
but a SparseAttributeClientAdapter here?). I think the thing it's wrapping is
more interesting than the interface it implements given you can tell the latter
from context.

+ public:
+  SparseAttributeMapAdapter(WebAXSparseAttributeMap& attributeMap)
+      : m_attributeMap(attributeMap) {}
+  virtual ~SparseAttributeMapAdapter() {}
+
+ private:
+  WebAXSparseAttributeMap& m_attributeMap;
+
+  void addBoolAttribute(AXBoolAttribute attribute, bool value) override {
+    m_attributeMap.addBoolAttribute(static_cast<WebAXBoolAttribute>(attribute),
+                                    value);
+  }
+
+  void addStringAttribute(AXStringAttribute attribute,
+                          const String& value) override {
+    m_attributeMap.addStringAttribute(
+        static_cast<WebAXStringAttribute>(attribute), value);
+  }
+
+  void addObjectAttribute(AXObjectAttribute attribute,
+                          AXObject* value) override {
+    m_attributeMap.addObjectAttribute(
+        static_cast<WebAXObjectAttribute>(attribute), WebAXObject(value));
+  }
+
+  void addObjectVectorAttribute(AXObjectVectorAttribute attribute,
+                                HeapVector<Member<AXObject>>& value) override {
+    WebVector<WebAXObject> result(value.size());
+    for (size_t i = 0; i < value.size(); i++)
+      result[i] = WebAXObject(value[i]);
+    m_attributeMap.addObjectVectorAttribute(
+        static_cast<WebAXObjectVectorAttribute>(attribute), result);
+  }
+};
+
 #if DCHECK_IS_ON()
 // It's not safe to call some WebAXObject APIs if a layout is pending.
 // Clients should call updateLayoutAndCheckValidity first.
 static bool isLayoutClean(Document* document) {
   if (!document || !document->view())
     return false;
   return document->lifecycle().state() >= DocumentLifecycle::LayoutClean ||
          ((document->lifecycle().state() == DocumentLifecycle::StyleClean ||
            document->lifecycle().state() ==
                DocumentLifecycle::LayoutSubtreeChangeClean) &&
@@ skipping 118 matching lines @@
   return WebAXObject(m_private->children()[index]);
 }
 
 WebAXObject WebAXObject::parentObject() const {
   if (isDetached())
     return WebAXObject();
 
   return WebAXObject(m_private->parentObject());
 }
 
+void WebAXObject::getSparseAXAttributes(WebAXSparseAttributeMap& sink) const {
+  if (isDetached())
+    return;
+
+  SparseAttributeMapAdapter adapter(sink);
+  m_private->getSparseAXAttributes(adapter);
+}
+
 bool WebAXObject::canSetSelectedAttribute() const {
   if (isDetached())
     return false;
 
   return m_private->canSetSelectedAttribute();
 }
 
 bool WebAXObject::isAnchor() const {
   if (isDetached())
     return false;
@@ skipping 212 matching lines @@
   return m_private->colorValue();
 }
 
 WebAXObject WebAXObject::ariaActiveDescendant() const {
   if (isDetached())
     return WebAXObject();
 
   return WebAXObject(m_private->activeDescendant());
 }
 
-bool WebAXObject::ariaControls(WebVector<WebAXObject>& controlsElements) const {
-  if (isDetached())
-    return false;
-
-  AXObject::AXObjectVector controls;
-  m_private->ariaControlsElements(controls);
-
-  WebVector<WebAXObject> result(controls.size());
-  for (size_t i = 0; i < controls.size(); i++)
-    result[i] = WebAXObject(controls[i]);
-  controlsElements.swap(result);
-
-  return true;
-}
-
 bool WebAXObject::ariaHasPopup() const {
   if (isDetached())
     return false;
 
   return m_private->ariaHasPopup();
 }
 
-bool WebAXObject::ariaFlowTo(WebVector<WebAXObject>& flowToElements) const {
-  if (isDetached())
-    return false;
-
-  AXObject::AXObjectVector flowTo;
-  m_private->ariaFlowToElements(flowTo);
-
-  WebVector<WebAXObject> result(flowTo.size());
-  for (size_t i = 0; i < flowTo.size(); i++)
-    result[i] = WebAXObject(flowTo[i]);
-  flowToElements.swap(result);
-
-  return true;
-}
-
 bool WebAXObject::isEditable() const {
   if (isDetached())
     return false;
 
   return m_private->isEditable();
 }
 
 bool WebAXObject::isMultiline() const {
   if (isDetached())
     return false;
@@ skipping 1028 matching lines @@
 WebAXObject& WebAXObject::operator=(AXObject* object) {
   m_private = object;
   return *this;
 }
 
 WebAXObject::operator AXObject*() const {
   return m_private.get();
 }
 
 }  // namespace blink