Implement the inert attribute

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

 /*
  * Copyright (C) 2008, 2009, 2011 Apple 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:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 11 matching lines @@
  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "modules/accessibility/AXObject.h"
 
 #include "SkMatrix44.h"
+#include "base/debug/stack_trace.h"
 #include "core/InputTypeNames.h"
 #include "core/css/resolver/StyleResolver.h"
 #include "core/dom/AccessibleNode.h"
 #include "core/dom/DocumentUserGestureToken.h"
 #include "core/editing/EditingUtilities.h"
 #include "core/editing/VisibleUnits.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/html/HTMLDialogElement.h"
@@ skipping 484 matching lines @@
     case kSpinButtonRole:
     case kTabRole:
     case kTextFieldRole:
     case kToggleButtonRole:
       return true;
     default:
       return false;
   }
 }
 
-bool AXObject::AccessibilityIsIgnored() const {
+bool AXObject::AccessibilityIsIgnored() {
+  Document* document = GetDocument();
+  if (!document) {
+    LOG(INFO) << "no document";
+  }
+  while (document) {
+    document->UpdateDistribution();
+    if (!document->ownerDocument() && document->LocalOwner())
+      document = document->LocalOwner()->ownerDocument();
+    else
+      document = nullptr;  // Only walk up the chain for <object>
+  }
+
   UpdateCachedAttributeValuesIfNeeded();
   return cached_is_ignored_;
 }
 
 void AXObject::UpdateCachedAttributeValuesIfNeeded() const {
   if (IsDetached())
     return;
 
   AXObjectCacheImpl& cache = AxObjectCache();
 
@@ skipping 61 matching lines @@
   if (GetNode()) {
     if (GetNode()->IsInert()) {
       if (ignored_reasons) {
         HTMLDialogElement* dialog = GetActiveDialogElement(GetNode());
         if (dialog) {
           AXObject* dialog_object = AxObjectCache().GetOrCreate(dialog);
           if (dialog_object)
             ignored_reasons->push_back(
                 IgnoredReason(kAXActiveModalDialog, dialog_object));
           else
-            ignored_reasons->push_back(IgnoredReason(kAXInert));
+            ignored_reasons->push_back(IgnoredReason(kAXInertElement));
         } else {
-          // TODO(aboxhall): handle inert attribute if it eventuates
-          ignored_reasons->push_back(IgnoredReason(kAXInert));
+          const AXObject* inert_root_el = InertRoot();
+          if (inert_root_el == this) {
+            ignored_reasons->push_back(IgnoredReason(kAXInertElement));
+          } else {
+            ignored_reasons->push_back(
+                IgnoredReason(kAXInertSubtree, inert_root_el));
+          }
         }
       }
       return true;
     }
   } else {
     AXObject* parent = ParentObject();
     if (parent && parent->IsInertOrAriaHidden()) {
       if (ignored_reasons)
         parent->ComputeIsInertOrAriaHidden(ignored_reasons);
       return true;
     }
   }
 
   const AXObject* hidden_root = AriaHiddenRoot();
   if (hidden_root) {
     if (ignored_reasons) {
-      if (hidden_root == this)
-        ignored_reasons->push_back(IgnoredReason(kAXAriaHidden));
-      else
+      if (hidden_root == this) {
+        ignored_reasons->push_back(IgnoredReason(kAXAriaHiddenElement));
+      } else {
         ignored_reasons->push_back(
-            IgnoredReason(kAXAriaHiddenRoot, hidden_root));
+            IgnoredReason(kAXAriaHiddenSubtree, hidden_root));
+      }
     }
     return true;
   }
 
   return false;
 }
 
 bool AXObject::IsDescendantOfLeafNode() const {
   UpdateCachedAttributeValuesIfNeeded();
   return cached_is_descendant_of_leaf_node_;
@@ skipping 12 matching lines @@
 
 const AXObject* AXObject::AriaHiddenRoot() const {
   for (const AXObject* object = this; object; object = object->ParentObject()) {
     if (EqualIgnoringASCIICase(object->GetAttribute(aria_hiddenAttr), "true"))
       return object;
   }
 
   return 0;
 }
 
+const AXObject* AXObject::InertRoot() const {
+  const AXObject* object = this;
+  if (!RuntimeEnabledFeatures::inertAttributeEnabled())
+    return 0;
+
+  while (object && !object->IsAXNodeObject())
+    object = object->ParentObject();
+  Node* node = object->GetNode();
+  Element* element = node->IsElementNode()
+                         ? ToElement(node)
+                         : FlatTreeTraversal::ParentElement(*node);
+  while (element) {
+    if (element->hasAttribute(inertAttr))
+      return AxObjectCache().GetOrCreate(element);
+    element = FlatTreeTraversal::ParentElement(*element);
+  }
+
+  return 0;
+}
+
 bool AXObject::IsDescendantOfDisabledNode() const {
   UpdateCachedAttributeValuesIfNeeded();
   return cached_is_descendant_of_disabled_node_;
 }
 
 const AXObject* AXObject::DisabledAncestor() const {
   const AtomicString& disabled = GetAttribute(aria_disabledAttr);
   if (EqualIgnoringASCIICase(disabled, "true"))
     return this;
   if (EqualIgnoringASCIICase(disabled, "false"))
@@ skipping 533 matching lines @@
 Document* AXObject::GetDocument() const {
   FrameView* frame_view = DocumentFrameView();
   if (!frame_view)
     return 0;
 
   return frame_view->GetFrame().GetDocument();
 }
 
 FrameView* AXObject::DocumentFrameView() const {
   const AXObject* object = this;
-  while (object && !object->IsAXLayoutObject())
+  LOG(INFO) << "DocumentFrameView for " << RoleName(RoleValue()).Utf8().data();
+  base::debug::StackTrace trace;
+  trace.Print();
+
+  while (object && !object->IsAXLayoutObject()) {
     object = object->ParentObject();
+    LOG(INFO) << "parent: " << (object ? RoleName(object->RoleValue()).Utf8().data() : "null");
+  }
 
-  if (!object)
+  if (!object) {
+    LOG(INFO) << "No candidate layout object in parent hierarchy";
     return 0;
+  }
 
   return object->DocumentFrameView();
 }
 
 String AXObject::Language() const {
   const AtomicString& lang = GetAttribute(langAttr);
   if (!lang.IsEmpty())
     return lang;
 
   AXObject* parent = ParentObject();
@@ skipping 618 matching lines @@
   return internal_role_name_vector->at(role);
 }
 
 DEFINE_TRACE(AXObject) {
   visitor->Trace(children_);
   visitor->Trace(parent_);
   visitor->Trace(cached_live_region_root_);
   visitor->Trace(ax_object_cache_);
 }
 
+
 }  // namespace blink