Implement the inert attribute

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

 // 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 "modules/accessibility/InspectorAccessibilityAgent.h"
 
 #include <memory>
 #include "core/HTMLNames.h"
 #include "core/dom/AXObjectCache.h"
 #include "core/dom/DOMNodeIds.h"
@@ skipping 457 matching lines @@
   AXObjectCacheImpl* cache = ToAXObjectCacheImpl(scoped_cache->Get());
 
   AXObjectImpl* inspected_ax_object = cache->GetOrCreate(dom_node);
   *nodes = protocol::Array<protocol::Accessibility::AXNode>::create();
   if (!inspected_ax_object || inspected_ax_object->AccessibilityIsIgnored()) {
     (*nodes)->addItem(BuildObjectForIgnoredNode(dom_node, inspected_ax_object,
                                                 fetch_relatives.fromMaybe(true),
                                                 *nodes, *cache));
     return Response::OK();
   } else {
-    (*nodes)->addItem(
-        BuildProtocolAXObject(*inspected_ax_object, inspected_ax_object,
-                              fetch_relatives.fromMaybe(true), *nodes, *cache));
+    (*nodes)->addItem(BuildProtocolAXObjectImpl(
+        *inspected_ax_object, inspected_ax_object,
+        fetch_relatives.fromMaybe(true), *nodes, *cache));
   }
 
   if (!inspected_ax_object)
     return Response::OK();
 
   AXObjectImpl* parent = inspected_ax_object->ParentObjectUnignored();
   if (!parent)
     return Response::OK();
 
   if (fetch_relatives.fromMaybe(true))
     AddAncestors(*parent, inspected_ax_object, *nodes, *cache);
 
   return Response::OK();
 }
 
 void InspectorAccessibilityAgent::AddAncestors(
     AXObjectImpl& first_ancestor,
     AXObjectImpl* inspected_ax_object,
     std::unique_ptr<protocol::Array<AXNode>>& nodes,
     AXObjectCacheImpl& cache) const {
   AXObjectImpl* ancestor = &first_ancestor;
   while (ancestor) {
-    nodes->addItem(BuildProtocolAXObject(*ancestor, inspected_ax_object, true,
-                                         nodes, cache));
+    nodes->addItem(BuildProtocolAXObjectImpl(*ancestor, inspected_ax_object,
+                                             true, nodes, cache));
     ancestor = ancestor->ParentObjectUnignored();
   }
 }
 
 std::unique_ptr<AXNode> InspectorAccessibilityAgent::BuildObjectForIgnoredNode(
     Node* dom_node,
     AXObjectImpl* ax_object,
     bool fetch_relatives,
     std::unique_ptr<protocol::Array<AXNode>>& nodes,
     AXObjectCacheImpl& cache) const {
@@ skipping 55 matching lines @@
   if (!parent_ax_object)
     return;
 
   if (parent_ax_object->AccessibilityIsIgnored())
     parent_ax_object = parent_ax_object->ParentObjectUnignored();
   if (!parent_ax_object)
     return;
 
   // Populate parent and ancestors.
   std::unique_ptr<AXNode> parent_node_object =
-      BuildProtocolAXObject(*parent_ax_object, nullptr, true, nodes, cache);
+      BuildProtocolAXObjectImpl(*parent_ax_object, nullptr, true, nodes, cache);
   std::unique_ptr<protocol::Array<AXNodeId>> child_ids =
       protocol::Array<AXNodeId>::create();
   child_ids->addItem(String::Number(kIDForInspectedNodeWithNoAXNode));
   parent_node_object->setChildIds(std::move(child_ids));
   nodes->addItem(std::move(parent_node_object));
 
   AXObjectImpl* grandparent_ax_object =
       parent_ax_object->ParentObjectUnignored();
   if (grandparent_ax_object)
     AddAncestors(*grandparent_ax_object, nullptr, nodes, cache);
 }
 
-std::unique_ptr<AXNode> InspectorAccessibilityAgent::BuildProtocolAXObject(
+std::unique_ptr<AXNode> InspectorAccessibilityAgent::BuildProtocolAXObjectImpl(
     AXObjectImpl& ax_object,
     AXObjectImpl* inspected_ax_object,
     bool fetch_relatives,
     std::unique_ptr<protocol::Array<AXNode>>& nodes,
     AXObjectCacheImpl& cache) const {
   AccessibilityRole role = ax_object.RoleValue();
   std::unique_ptr<AXNode> node_object =
       AXNode::create()
           .setNodeId(String::Number(ax_object.AxObjectID()))
           .setIgnored(false)
@@ skipping 113 matching lines @@
     child_ids->addItem(String::Number(inspected_ax_object->AxObjectID()));
     return;
   }
 
   const AXObjectImpl::AXObjectVector& children = ax_object.Children();
   for (unsigned i = 0; i < children.size(); i++) {
     AXObjectImpl& child_ax_object = *children[i].Get();
     child_ids->addItem(String::Number(child_ax_object.AxObjectID()));
     if (&child_ax_object == inspected_ax_object)
       continue;
-    if (&ax_object != inspected_ax_object &&
-        (ax_object.GetNode() ||
-         ax_object.ParentObjectUnignored() != inspected_ax_object)) {
-      continue;
+    if (&ax_object != inspected_ax_object) {
+      if (!inspected_ax_object)
+        continue;
+      if (&ax_object != inspected_ax_object->ParentObjectUnignored())
+        continue;
     }
 
     // Only add children of inspected node (or un-inspectable children of
     // inspected node) to returned nodes.
-    std::unique_ptr<AXNode> child_node = BuildProtocolAXObject(
+    std::unique_ptr<AXNode> child_node = BuildProtocolAXObjectImpl(
         child_ax_object, inspected_ax_object, true, nodes, cache);
     nodes->addItem(std::move(child_node));
   }
 }
 
 DEFINE_TRACE(InspectorAccessibilityAgent) {
   visitor->Trace(page_);
   visitor->Trace(dom_agent_);
   InspectorBaseAgent::Trace(visitor);
 }
 
 }  // namespace blink