Implement the inert attribute

third_party/WebKit/Source/modules/accessibility/InspectorTypeBuilderHelper.cpp

 // Copyright 2015 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 "modules/accessibility/InspectorTypeBuilderHelper.h"
 
 #include "core/dom/DOMNodeIds.h"
 #include "modules/accessibility/AXObjectCacheImpl.h"
 #include "modules/accessibility/AXObjectImpl.h"
 
 namespace blink {
 
 using namespace HTMLNames;
 using namespace protocol::Accessibility;
 
 std::unique_ptr<AXProperty> CreateProperty(const String& name,
                                            std::unique_ptr<AXValue> value) {
   return AXProperty::create().setName(name).setValue(std::move(value)).build();
 }
 
 String IgnoredReasonName(AXIgnoredReason reason) {
   switch (reason) {
     case kAXActiveModalDialog:
       return "activeModalDialog";
     case kAXAncestorDisallowsChild:
       return "ancestorDisallowsChild";
     case kAXAncestorIsLeafNode:
       return "ancestorIsLeafNode";
-    case kAXAriaHidden:
-      return "ariaHidden";
-    case kAXAriaHiddenRoot:
-      return "ariaHiddenRoot";
+    case kAXAriaHiddenElement:
+      return "ariaHiddenElement";
+    case kAXAriaHiddenSubtree:
+      return "ariaHiddenSubtree";
     case kAXEmptyAlt:
       return "emptyAlt";
     case kAXEmptyText:
       return "emptyText";
-    case kAXInert:
-      return "inert";
+    case kAXInertElement:
+      return "inertElement";
+    case kAXInertSubtree:
+      return "inertSubtree";
     case kAXInheritsPresentation:
       return "inheritsPresentation";
     case kAXLabelContainer:
       return "labelContainer";
     case kAXLabelFor:
       return "labelFor";
     case kAXNotRendered:
       return "notRendered";
     case kAXNotVisible:
       return "notVisible";
@@ skipping 41 matching lines @@
       .build();
 }
 
 std::unique_ptr<AXValue> CreateBooleanValue(bool value, const String& type) {
   return AXValue::create()
       .setType(type)
       .setValue(protocol::ValueConversions<bool>::toValue(value))
       .build();
 }
 
-std::unique_ptr<AXRelatedNode> RelatedNodeForAXObject(
+std::unique_ptr<AXRelatedNode> RelatedNodeForAXObjectImpl(
     const AXObjectImpl& ax_object,
     String* name = nullptr) {
   Node* node = ax_object.GetNode();
   if (!node)
     return nullptr;
   int backend_node_id = DOMNodeIds::IdForNode(node);
   if (!backend_node_id)
     return nullptr;
   std::unique_ptr<AXRelatedNode> related_node =
       AXRelatedNode::create().setBackendDOMNodeId(backend_node_id).build();
   if (!node->IsElementNode())
     return related_node;
 
   Element* element = ToElement(node);
   String idref = element->GetIdAttribute();
   if (!idref.IsEmpty())
     related_node->setIdref(idref);
 
   if (name)
     related_node->setText(*name);
   return related_node;
 }
 
 std::unique_ptr<AXValue> CreateRelatedNodeListValue(
     const AXObjectImpl& ax_object,
     String* name,
     const String& value_type) {
   std::unique_ptr<protocol::Array<AXRelatedNode>> related_nodes =
       protocol::Array<AXRelatedNode>::create();
-  related_nodes->addItem(RelatedNodeForAXObject(ax_object, name));
+  related_nodes->addItem(RelatedNodeForAXObjectImpl(ax_object, name));
   return AXValue::create()
       .setType(value_type)
       .setRelatedNodes(std::move(related_nodes))
       .build();
 }
 
 std::unique_ptr<AXValue> CreateRelatedNodeListValue(
     AXRelatedObjectVector& related_objects,
     const String& value_type) {
   std::unique_ptr<protocol::Array<AXRelatedNode>> frontend_related_nodes =
       protocol::Array<AXRelatedNode>::create();
   for (unsigned i = 0; i < related_objects.size(); i++) {
     std::unique_ptr<AXRelatedNode> frontend_related_node =
-        RelatedNodeForAXObject(*(related_objects[i]->object),
-                               &(related_objects[i]->text));
+        RelatedNodeForAXObjectImpl(*(related_objects[i]->object),
+                                   &(related_objects[i]->text));
     if (frontend_related_node)
       frontend_related_nodes->addItem(std::move(frontend_related_node));
   }
   return AXValue::create()
       .setType(value_type)
       .setRelatedNodes(std::move(frontend_related_nodes))
       .build();
 }
 
 std::unique_ptr<AXValue> CreateRelatedNodeListValue(
     AXObjectImpl::AXObjectVector& ax_objects,
     const String& value_type) {
   std::unique_ptr<protocol::Array<AXRelatedNode>> related_nodes =
       protocol::Array<AXRelatedNode>::create();
   for (unsigned i = 0; i < ax_objects.size(); i++) {
     std::unique_ptr<AXRelatedNode> related_node =
-        RelatedNodeForAXObject(*(ax_objects[i].Get()));
+        RelatedNodeForAXObjectImpl(*(ax_objects[i].Get()));
     if (related_node)
       related_nodes->addItem(std::move(related_node));
   }
   return AXValue::create()
       .setType(value_type)
       .setRelatedNodes(std::move(related_nodes))
       .build();
 }
 
 String ValueSourceType(AXNameFrom name_from) {
@@ skipping 65 matching lines @@
   if (name_source.superseded)
     value_source->setSuperseded(true);
   if (name_source.invalid)
     value_source->setInvalid(true);
   if (name_source.native_source != kAXTextFromNativeHTMLUninitialized)
     value_source->setNativeSource(NativeSourceType(name_source.native_source));
   return value_source;
 }
 
 }  // namespace blink