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

ui/accessibility/ax_position.h

 // Copyright 2016 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.
 
 #ifndef UI_ACCESSIBILITY_AX_POSITION_H_
 #define UI_ACCESSIBILITY_AX_POSITION_H_
 
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 260 matching lines @@
         copy->text_offset_ >= copy->MaxTextOffset()) {
       copy->child_index_ = copy->AnchorChildCount();
     } else {
       DCHECK_GE(copy->text_offset_, 0);
       copy->child_index_ = BEFORE_TEXT;
 
       int current_offset = 0;
       for (int i = 0; i < copy->AnchorChildCount(); ++i) {
         AXPositionInstance child = copy->CreateChildPositionAt(i);
         DCHECK(child);
+        int child_length = child->MaxTextOffsetInParent();
         if (copy->text_offset_ >= current_offset &&
-            copy->text_offset_ < (current_offset + child->MaxTextOffset())) {
+            copy->text_offset_ < (current_offset + child_length)) {
           copy->child_index_ = i;
           break;
         }
 
-        current_offset += child->MaxTextOffset();
+        current_offset += child_length;
       }
     }
 
     copy->kind_ = AXPositionKind::TREE_POSITION;
     return copy;
   }
 
   AXPositionInstance AsTextPosition() const {
     if (IsNullPosition() || IsTextPosition())
       return Clone();
 
     AXPositionInstance copy = Clone();
     DCHECK(copy);
     // Check if it is a "before text" position.
     if (copy->child_index_ == BEFORE_TEXT) {
       // "Before text" positions can only appear on leaf nodes.
       DCHECK(!copy->AnchorChildCount());
       // If the current text offset is valid, we don't touch it.
       if (copy->text_offset_ < 0 || copy->text_offset_ >= copy->MaxTextOffset())
         copy->text_offset_ = 0;
     } else if (copy->child_index_ == copy->AnchorChildCount()) {
       copy->text_offset_ = copy->MaxTextOffset();
     } else {
       DCHECK_GE(copy->child_index_, 0);
       DCHECK_LT(copy->child_index_, copy->AnchorChildCount());
       int new_offset = 0;
       for (int i = 0; i <= child_index_; ++i) {
         AXPositionInstance child = copy->CreateChildPositionAt(i);
         DCHECK(child);
+        int child_length = child->MaxTextOffsetInParent();
 
         // If the current text offset is valid, we don't touch it.
         // Otherwise, we reset it to the beginning of the current child node.
         if (i == child_index_ &&
             (copy->text_offset_ < new_offset ||
-             copy->text_offset_ > (new_offset + child->MaxTextOffset()) ||
+             copy->text_offset_ > (new_offset + child_length) ||
              // When the text offset is equal to the text's length but this is
              // not an "after text" position.
              (!copy->AtEndOfAnchor() &&
-              copy->text_offset_ == (new_offset + child->MaxTextOffset())))) {
+              copy->text_offset_ == (new_offset + child_length)))) {
           copy->text_offset_ = new_offset;
           break;
         }
 
-        new_offset += child->MaxTextOffset();
+        new_offset += child_length;
       }
     }
 
     copy->kind_ = AXPositionKind::TEXT_POSITION;
     return copy;
   }
 
   AXPositionInstance AsLeafTextPosition() const {
     if (IsNullPosition() || !AnchorChildCount())
       return AsTextPosition();
@@ skipping 693 matching lines @@
 
   // Abstract methods.
   virtual void AnchorChild(int child_index,
                            int* tree_id,
                            int32_t* child_id) const = 0;
   virtual int AnchorChildCount() const = 0;
   virtual int AnchorIndexInParent() const = 0;
   virtual void AnchorParent(int* tree_id, int32_t* parent_id) const = 0;
   virtual AXNodeType* GetNodeInTree(int tree_id, int32_t node_id) const = 0;
   // Returns the length of the text that is present inside the anchor node,
-  // including any text found in descendant nodes.
+  // including any text found in descendant text nodes.
   virtual int MaxTextOffset() const = 0;
+  // Returns the length of text that this anchor node takes up in its parent.
+  // On some platforms, embedded objects are represented in their parent with a
+  // single embedded object character.
+  virtual int MaxTextOffsetInParent() const { return MaxTextOffset(); }
   virtual bool IsInLineBreak() const = 0;
   virtual std::vector<int32_t> GetWordStartOffsets() const = 0;
   virtual std::vector<int32_t> GetWordEndOffsets() const = 0;
   virtual int32_t GetNextOnLineID(int32_t node_id) const = 0;
   virtual int32_t GetPreviousOnLineID(int32_t node_id) const = 0;
 
  private:
   AXPositionKind kind_;
   int tree_id_;
   int32_t anchor_id_;
@@ skipping 77 matching lines @@
 
 template <class AXPositionType, class AXNodeType>
 bool operator>=(const AXPosition<AXPositionType, AXNodeType>& first,
                 const AXPosition<AXPositionType, AXNodeType>& second) {
   return first == second || first > second;
 }
 
 }  // namespace ui
 
 #endif  // UI_ACCESSIBILITY_AX_POSITION_H_