WIP: Modified AXPosition to work with objects with both embedded object characters and text.

third_party/WebKit/Source/modules/accessibility/AXObjectImpl.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 16 matching lines @@
  */
 
 #include "modules/accessibility/AXObjectImpl.h"
 
 #include "SkMatrix44.h"
 #include "core/InputTypeNames.h"
 #include "core/css/resolver/StyleResolver.h"
 #include "core/dom/AccessibleNode.h"
 #include "core/dom/UserGestureIndicator.h"
 #include "core/editing/EditingUtilities.h"
+#include "core/editing/FrameSelection.h"
 #include "core/editing/VisibleUnits.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/LocalFrameView.h"
 #include "core/frame/Settings.h"
 #include "core/html/HTMLDialogElement.h"
 #include "core/html/HTMLFrameOwnerElement.h"
 #include "core/html/HTMLInputElement.h"
 #include "core/html/parser/HTMLParserIdioms.h"
 #include "core/layout/LayoutBoxModelObject.h"
+#include "core/layout/line/AbstractInlineTextBox.h"
+#include "core/layout/line/InlineBox.h"
+#include "core/layout/line/InlineTextBox.h"
+#include "modules/accessibility/AXInlineTextBox.h"
 #include "modules/accessibility/AXObjectCacheImpl.h"
 #include "platform/text/PlatformLocale.h"
 #include "platform/wtf/HashSet.h"
 #include "platform/wtf/StdLibExtras.h"
 #include "platform/wtf/text/WTFString.h"
 
 using blink::WebLocalizedString;
 
 namespace blink {
 
@@ skipping 1371 matching lines @@
   return false;
 }
 
 const AtomicString& AXObjectImpl::GetAttribute(
     const QualifiedName& attribute) const {
   if (Element* element = GetElement())
     return element->FastGetAttribute(attribute);
   return g_null_atom;
 }
 
+AXRange AXObject::Selection() const {
+  Document* document = GetDocument();
+  if (!document)
+    return AXRange();
+  LocalFrame* frame = document->GetFrame();
+  if (!frame)
+    return AXRange();
+
+  const VisibleSelectionInFlatTree& visible_selection =
+      frame->Selection().ComputeVisibleSelectionInFlatTree();
+  if (visible_selection.IsNone())
+    return AXRange();
+
+  AXObject* anchor_object = nullptr;
+  int anchor_offset;
+  ComputeAXObjectAndOffset(visible_selection.VisibleStart(), &anchor_object,
+                           &anchor_offset);
+  AXObject* focus_object = nullptr;
+  int focus_offset;
+  ComputeAXObjectAndOffset(visible_selection.VisibleStart(), &focus_object,
+                           &focus_offset);
+
+  if (!anchor_object || !focus_object)
+    return AXRange();
+  return AXRange(anchor_object, anchor_offset, focus_object, focus_offset,
+                 visible_selection.Affinity());
+}
+
+void AXObject::ComputeAXObjectAndOffset(
+    const VisiblePositionInFlatTree& position,
+    AXObject** ax_object,
+    int* offset) const {
+  *ax_object = nullptr;
+  *offset = 0;
+  if (position.IsNull())
+    return;
+
+  InlineBoxPosition box_position =
+      ComputeInlineBoxPosition(position.DeepEquivalent(), position.Affinity());
+  InlineBox* inline_box = box_position.inline_box;
+  if (inline_box && inline_box->IsInlineTextBox()) {
+    InlineTextBox* inline_text_box = ToInlineTextBox(inline_box);
+    RefPtr<AbstractInlineTextBox> abstract_inline_text_box =
+        AbstractInlineTextBox::GetOrCreate(inline_text_box->GetLineLayoutItem(),
+                                           inline_text_box);
+    *ax_object = AxObjectCache().GetOrCreate(abstract_inline_text_box);
+  } else {
+    Node* anchor_node = position.DeepEquivalent().AnchorNode();
+    DCHECK(anchor_node);
+    switch (position.DeepEquivalent().AnchorType()) {
+      case PositionAnchorType::kOffsetInAnchor:
+      case PositionAnchorType::kBeforeAnchor:
+      case PositionAnchorType::kAfterAnchor:
+        break;
+
+      case PositionAnchorType::kBeforeChildren:
+        if (EditingInFlatTreeStrategy::FirstChild(*anchor_node))
+          anchor_node = EditingInFlatTreeStrategy::FirstChild(*anchor_node);
+        break;
+      case PositionAnchorType::kAfterChildren:
+        if (EditingInFlatTreeStrategy::LastChild(*anchor_node))
+          anchor_node = EditingInFlatTreeStrategy::LastChild(*anchor_node);
+        break;
+    }
+    LayoutObject* layout_object = anchor_node->GetLayoutObject();
+    if (layout_object) {
+      *ax_object = AxObjectCache().GetOrCreate(layout_object);
+    } else {
+      *ax_object = AxObjectCache().GetOrCreate(anchor_node);
+    }
+  }
+  *offset = box_position.offset_in_box;
+}
+
 //
 // Scrollable containers.
 //
 
 bool AXObjectImpl::IsScrollableContainer() const {
   return !!GetScrollableAreaIfScrollable();
 }
 
 IntPoint AXObjectImpl::GetScrollOffset() const {
   ScrollableArea* area = GetScrollableAreaIfScrollable();
@@ skipping 646 matching lines @@
 }
 
 DEFINE_TRACE(AXObjectImpl) {
   visitor->Trace(children_);
   visitor->Trace(parent_);
   visitor->Trace(cached_live_region_root_);
   visitor->Trace(ax_object_cache_);
 }
 
 }  // namespace blink