Revert of Correctly compute parent of AXMenuListOption

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 "core/HTMLNames.h"
 #include "core/dom/AXObjectCache.h"
 #include "core/dom/DOMNodeIds.h"
 #include "core/dom/Element.h"
@@ skipping 452 matching lines @@
   std::unique_ptr<ScopedAXObjectCache> scopedCache =
       ScopedAXObjectCache::create(document);
   AXObjectCacheImpl* cache = toAXObjectCacheImpl(scopedCache->get());
 
   AXObject* inspectedAXObject = cache->getOrCreate(domNode);
   *nodes = protocol::Array<protocol::Accessibility::AXNode>::create();
   if (!inspectedAXObject || inspectedAXObject->accessibilityIsIgnored()) {
     (*nodes)->addItem(buildObjectForIgnoredNode(domNode, inspectedAXObject,
                                                 fetchRelatives.fromMaybe(true),
                                                 *nodes, *cache));
+    return Response::OK();
   } else {
     (*nodes)->addItem(
         buildProtocolAXObject(*inspectedAXObject, inspectedAXObject,
                               fetchRelatives.fromMaybe(true), *nodes, *cache));
   }
 
-  if (!inspectedAXObject || !inspectedAXObject->isAXLayoutObject())
+  if (!inspectedAXObject)
     return Response::OK();
 
   AXObject* parent = inspectedAXObject->parentObjectUnignored();
   if (!parent)
     return Response::OK();
 
   if (fetchRelatives.fromMaybe(true))
     addAncestors(*parent, inspectedAXObject, *nodes, *cache);
 
   return Response::OK();
@@ skipping 200 matching lines @@
   std::unique_ptr<protocol::Array<AXNodeId>> childIds =
       protocol::Array<AXNodeId>::create();
 
   if (&axObject != inspectedAXObject ||
       (inspectedAXObject && !inspectedAXObject->accessibilityIsIgnored())) {
     addChildren(axObject, inspectedAXObject, childIds, nodes, cache);
   }
   nodeObject.setChildIds(std::move(childIds));
 }
 
-void InspectorAccessibilityAgent::addChild(
-    std::unique_ptr<protocol::Array<AXNodeId>>& childIds,
-    AXObject& childAXObject,
-    AXObject* inspectedAXObject,
-    std::unique_ptr<protocol::Array<AXNode>>& nodes,
-    AXObjectCacheImpl& cache) const {
-  childIds->addItem(String::number(childAXObject.axObjectID()));
-  if (&childAXObject == inspectedAXObject)
-    return;
-  nodes->addItem(buildProtocolAXObject(childAXObject, inspectedAXObject, true,
-                                       nodes, cache));
-}
-
 void InspectorAccessibilityAgent::addChildren(
     AXObject& axObject,
     AXObject* inspectedAXObject,
     std::unique_ptr<protocol::Array<AXNodeId>>& childIds,
     std::unique_ptr<protocol::Array<AXNode>>& nodes,
     AXObjectCacheImpl& cache) const {
   if (inspectedAXObject && inspectedAXObject->accessibilityIsIgnored() &&
       &axObject == inspectedAXObject->parentObjectUnignored()) {
     childIds->addItem(String::number(inspectedAXObject->axObjectID()));
     return;
   }
 
   const AXObject::AXObjectVector& children = axObject.children();
   for (unsigned i = 0; i < children.size(); i++) {
     AXObject& childAXObject = *children[i].get();
     childIds->addItem(String::number(childAXObject.axObjectID()));
     if (&childAXObject == inspectedAXObject)
       continue;
-    if (&axObject != inspectedAXObject) {
-      if (!inspectedAXObject)
-        continue;
-      if (&axObject != inspectedAXObject->parentObjectUnignored())
-        continue;
+    if (&axObject != inspectedAXObject &&
+        (axObject.getNode() ||
+         axObject.parentObjectUnignored() != inspectedAXObject)) {
+      continue;
     }
 
-    // Only add children/siblings of inspected node to returned nodes.
+    // Only add children of inspected node (or un-inspectable children of
+    // inspected node) to returned nodes.
     std::unique_ptr<AXNode> childNode = buildProtocolAXObject(
         childAXObject, inspectedAXObject, true, nodes, cache);
     nodes->addItem(std::move(childNode));
   }
 }
 
 DEFINE_TRACE(InspectorAccessibilityAgent) {
   visitor->trace(m_page);
   visitor->trace(m_domAgent);
   InspectorBaseAgent::trace(visitor);
 }
 
 }  // namespace blink