Switched to using |AXPosition| for calculating word and line boundaries on Windows.

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 113 matching lines @@
         if (child_index_ == BEFORE_TEXT) {
           str_child_index = "before_text";
         } else if (child_index_ == INVALID_INDEX) {
           str_child_index = "invalid";
         } else {
           str_child_index = base::IntToString(child_index_);
         }
         str = "TreePosition tree_id=" + base::IntToString(tree_id_) +
               " anchor_id=" + base::IntToString(anchor_id_) + " child_index=" +
               str_child_index;
+        break;
       }
       case AXPositionKind::TEXT_POSITION: {
         std::string str_text_offset;
         if (text_offset_ == INVALID_OFFSET) {
           str_text_offset = "invalid";
         } else {
           str_text_offset = base::IntToString(text_offset_);
         }
         str = "TextPosition tree_id=" + base::IntToString(tree_id_) +
               " anchor_id=" + base::IntToString(anchor_id_) + " text_offset=" +
               str_text_offset + " affinity=" +
               ui::ToString(static_cast<AXTextAffinity>(affinity_));
+        break;
       }
     }
 
     if (!IsTextPosition() || text_offset_ > MaxTextOffset())
       return str;
 
     std::string text = base::UTF16ToUTF8(GetInnerText());
     DCHECK_GE(text_offset_, 0);
     DCHECK_LE(text_offset_, static_cast<int>(text.length()));
     std::string annotated_text;
@@ skipping 62 matching lines @@
         return false;
       case AXPositionKind::TREE_POSITION:
         return child_index_ == AnchorChildCount();
       case AXPositionKind::TEXT_POSITION:
         return text_offset_ == MaxTextOffset();
     }
 
     return false;
   }
 
+  bool AtStartOfWord() const {
+    AXPositionInstance text_position = AsLeafTextPosition();
+    switch (text_position->kind_) {
+      case AXPositionKind::NULL_POSITION:
+        return false;
+      case AXPositionKind::TREE_POSITION:
+        NOTREACHED();
+        return false;
+      case AXPositionKind::TEXT_POSITION: {
+        const std::vector<int32_t> word_starts =
+            text_position->GetWordStartOffsets();
+        auto iterator =
+            std::find(word_starts.begin(), word_starts.end(),
+                      static_cast<int32_t>(text_position->text_offset_));
+        return iterator != word_starts.end();
+      }
+    }
+    return false;
+  }
+
+  bool AtEndOfWord() const {
+    AXPositionInstance text_position = AsLeafTextPosition();
+    switch (text_position->kind_) {
+      case AXPositionKind::NULL_POSITION:
+        return false;
+      case AXPositionKind::TREE_POSITION:
+        NOTREACHED();
+        return false;
+      case AXPositionKind::TEXT_POSITION: {
+        const std::vector<int32_t> word_ends =
+            text_position->GetWordEndOffsets();
+        auto iterator =
+            std::find(word_ends.begin(), word_ends.end(),
+                      static_cast<int32_t>(text_position->text_offset_));
+        return iterator != word_ends.end();
+      }
+    }
+    return false;
+  }
+
+  bool AtStartOfLine() const {
+    AXPositionInstance text_position = AsLeafTextPosition();
+    switch (text_position->kind_) {
+      case AXPositionKind::NULL_POSITION:
+        return false;
+      case AXPositionKind::TREE_POSITION:
+        NOTREACHED();
+        return false;
+      case AXPositionKind::TEXT_POSITION:
+        return !text_position->IsInLineBreak() &&
+               GetPreviousOnLineID(text_position->anchor_id_) ==
+                   INVALID_ANCHOR_ID &&
+               text_position->AtStartOfAnchor();
+    }
+    return false;
+  }
+
+  bool AtEndOfLine() const {
+    AXPositionInstance text_position = AsLeafTextPosition();
+    switch (text_position->kind_) {
+      case AXPositionKind::NULL_POSITION:
+        return false;
+      case AXPositionKind::TREE_POSITION:
+        NOTREACHED();
+        return false;
+      case AXPositionKind::TEXT_POSITION:
+        return !text_position->IsInLineBreak() &&
+               GetNextOnLineID(text_position->anchor_id_) ==
+                   INVALID_ANCHOR_ID &&
+               text_position->AtEndOfAnchor();
+    }
+    return false;
+  }
+
   // This method returns a position instead of a node because this allows us to
   // return the corresponding text offset or child index in the ancestor that
   // relates to the current position.
   // Also, this method uses position instead of tree logic to traverse the tree,
   // because positions can handle moving across multiple trees, while trees
   // cannot.
   AXPositionInstance LowestCommonAncestor(
       const AXPosition<AXPositionType, AXNodeType>& second) const {
     if (IsNullPosition() || second.IsNullPosition())
       return CreateNullPosition();
@@ skipping 204 matching lines @@
   AXPositionInstance CreateParentPosition() const {
     if (IsNullPosition())
       return CreateNullPosition();
 
     int tree_id = INVALID_TREE_ID;
     int32_t parent_id = INVALID_ANCHOR_ID;
     AnchorParent(&tree_id, &parent_id);
     if (tree_id == INVALID_TREE_ID || parent_id == INVALID_ANCHOR_ID)
       return CreateNullPosition();
 
-    DCHECK_NE(tree_id, INVALID_TREE_ID);
-    DCHECK_NE(parent_id, INVALID_ANCHOR_ID);
     switch (kind_) {
       case AXPositionKind::NULL_POSITION:
         NOTREACHED();
         return CreateNullPosition();
       case AXPositionKind::TREE_POSITION:
         return CreateTreePosition(tree_id, parent_id, AnchorIndexInParent());
-      case AXPositionKind::TEXT_POSITION:
-        // Make sure that our affinity is propagated to our parent because by
-        // design our parent includes all our text.
-        return CreateTextPosition(tree_id, parent_id,
-                                  AnchorTextOffsetInParent() + text_offset_,
-                                  affinity_);
+      case AXPositionKind::TEXT_POSITION: {
+        // If our parent contains all our text, we need to maintain the affinity
+        // and the text offset. Otherwise, we return a position that is either
+        // before or after the child and we don't maintain the affinity when the
+        // position is after the child.
+        int parent_offset = AnchorTextOffsetInParent();
+        AXTextAffinity parent_affinity = affinity_;
+        if (MaxTextOffset() == MaxTextOffsetInParent()) {
+          parent_offset += text_offset_;
+        } else if (text_offset_ > 0) {
+          parent_offset += MaxTextOffsetInParent();
+          parent_affinity = AX_TEXT_AFFINITY_DOWNSTREAM;
+        }
+        return CreateTextPosition(tree_id, parent_id, parent_offset,
+                                  parent_affinity);
+      }
     }
 
     return CreateNullPosition();
   }
 
   // Creates a position using the next text-only node as its anchor.
   // Assumes that text-only nodes are leaf nodes.
   AXPositionInstance CreateNextTextAnchorPosition() const {
     AXPositionInstance next_leaf(CreateNextAnchorPosition());
     while (!next_leaf->IsNullPosition() && next_leaf->AnchorChildCount()) {
@@ skipping 65 matching lines @@
       text_position = text_position->AsTreePosition();
     return text_position;
   }
 
   AXPositionInstance CreateNextWordStartPosition() const {
     bool was_tree_position = IsTreePosition();
     AXPositionInstance text_position = AsLeafTextPosition();
     if (text_position->IsNullPosition())
       return text_position;
 
-    // Ignore any nodes with no text or no word boundaries.
-    while (!text_position->IsNullPosition() &&
-           (!text_position->MaxTextOffset() ||
-            text_position->GetWordStartOffsets().empty())) {
-      text_position = text_position->CreateNextTextAnchorPosition();
-    }
-
-    if (text_position->IsNullPosition())
-      return text_position;
-
     const std::vector<int32_t> word_starts =
         text_position->GetWordStartOffsets();
     auto iterator =
         std::upper_bound(word_starts.begin(), word_starts.end(),
                          static_cast<int32_t>(text_position->text_offset_));
     if (iterator == word_starts.end()) {
+      // Ignore any nodes with no text or no word boundaries.
       do {
         text_position = text_position->CreateNextTextAnchorPosition();
       } while (!text_position->IsNullPosition() &&
                (!text_position->MaxTextOffset() ||
                 text_position->GetWordStartOffsets().empty()));
       if (text_position->IsNullPosition())
         return text_position;
 
-      // In case there are some non-word characters in front of the first word
-      // in this text node.
       const std::vector<int32_t> word_starts =
           text_position->GetWordStartOffsets();
+      DCHECK(!word_starts.empty());
       text_position->text_offset_ = static_cast<int>(word_starts[0]);
     } else {
       text_position->text_offset_ = static_cast<int>(*iterator);
       text_position->affinity_ = AX_TEXT_AFFINITY_DOWNSTREAM;
     }
 
     // If the word boundary is in the same subtree, return a position rooted at
     // the current position.
     // This is necessary because we don't want to return any position that might
     // be in the shadow DOM if the original position was not.
     AXPositionInstance common_ancestor =
         text_position->LowestCommonAncestor(*this);
     if (GetAnchor() == common_ancestor->GetAnchor())
-      return common_ancestor;
+      text_position = std::move(common_ancestor);
 
     if (was_tree_position)
       text_position = text_position->AsTreePosition();
     return text_position;
   }
 
   AXPositionInstance CreatePreviousWordStartPosition() const {
     bool was_tree_position = IsTreePosition();
     AXPositionInstance text_position = AsLeafTextPosition();
-    if (text_position->IsNullPosition())
-      return text_position;
 
     if (text_position->AtStartOfAnchor()) {
       text_position = text_position->CreatePreviousTextAnchorPosition();
       text_position = text_position->CreatePositionAtEndOfAnchor();
     }
-
-    // Ignore any nodes with no text or no word boundaries.
-    while (!text_position->IsNullPosition() &&
-           (!text_position->MaxTextOffset() ||
-            text_position->GetWordStartOffsets().empty())) {
-      text_position = text_position->CreatePreviousTextAnchorPosition();
-      text_position = text_position->CreatePositionAtEndOfAnchor();
-    }
-
     if (text_position->IsNullPosition())
       return text_position;
 
     const std::vector<int32_t> word_starts =
         text_position->GetWordStartOffsets();
     auto iterator =
         std::lower_bound(word_starts.begin(), word_starts.end(),
                          static_cast<int32_t>(text_position->text_offset_));
-    if (iterator == word_starts.begin()) {
-      // There must be some non-word characters in front of the first word in
-      // this text node.
+    if (word_starts.empty() || iterator == word_starts.begin()) {
+      // Ignore any nodes with no text or no word boundaries.
       do {
         text_position = text_position->CreatePreviousTextAnchorPosition();
       } while (!text_position->IsNullPosition() &&
                (!text_position->MaxTextOffset() ||
                 text_position->GetWordStartOffsets().empty()));
       if (text_position->IsNullPosition())
         return text_position;
 
       const std::vector<int32_t> word_starts =
           text_position->GetWordStartOffsets();
+      DCHECK(!word_starts.empty());
       text_position->text_offset_ = static_cast<int>(*(word_starts.end() - 1));
     } else {
       text_position->text_offset_ = static_cast<int>(*(--iterator));
       text_position->affinity_ = AX_TEXT_AFFINITY_DOWNSTREAM;
     }
 
     // If the word boundary is in the same subtree, return a position rooted at
     // the current position.
     // This is necessary because we don't want to return any position that might
     // be in the shadow DOM if the original position was not.
     AXPositionInstance common_ancestor =
         text_position->LowestCommonAncestor(*this);
     if (GetAnchor() == common_ancestor->GetAnchor())
-      return common_ancestor;
+      text_position = std::move(common_ancestor);
 
     if (was_tree_position)
       text_position = text_position->AsTreePosition();
     return text_position;
   }
 
   // Word end positions are one past the last character of the word.
   AXPositionInstance CreateNextWordEndPosition() const {
     bool was_tree_position = IsTreePosition();
     AXPositionInstance text_position = AsLeafTextPosition();
+
+    if (text_position->AtEndOfAnchor())
+      text_position = text_position->CreateNextTextAnchorPosition();
     if (text_position->IsNullPosition())
       return text_position;
 
-    if (text_position->AtEndOfAnchor())
-      text_position = text_position->CreateNextTextAnchorPosition();
-
-    // Ignore any nodes with no text or no word boundaries.
-    while (!text_position->IsNullPosition() &&
-           (!text_position->MaxTextOffset() ||
-            text_position->GetWordEndOffsets().empty())) {
-      text_position = text_position->CreateNextTextAnchorPosition();
-    }
-
-    if (text_position->IsNullPosition())
-      return text_position;
-
-    const std::vector<int> word_ends = text_position->GetWordEndOffsets();
-    auto iterator = std::upper_bound(word_ends.begin(), word_ends.end(),
-                                     text_position->text_offset_);
+    const std::vector<int32_t> word_ends = text_position->GetWordEndOffsets();
+    auto iterator =
+        std::upper_bound(word_ends.begin(), word_ends.end(),
+                         static_cast<int32_t>(text_position->text_offset_));
     if (iterator == word_ends.end()) {
-      // We should be in the last word of this text node.
+      // Ignore any nodes with no text or no word boundaries.
       do {
         text_position = text_position->CreateNextTextAnchorPosition();
       } while (!text_position->IsNullPosition() &&
                (!text_position->MaxTextOffset() ||
                 text_position->GetWordEndOffsets().empty()));
       if (text_position->IsNullPosition())
         return text_position;
 
-      const std::vector<int> word_ends = text_position->GetWordEndOffsets();
-      text_position->text_offset_ = word_ends[0];
+      const std::vector<int32_t> word_ends = text_position->GetWordEndOffsets();
+      DCHECK(!word_ends.empty());
+      text_position->text_offset_ = static_cast<int>(word_ends[0]);
     } else {
-      text_position->text_offset_ = *iterator;
+      text_position->text_offset_ = static_cast<int>(*iterator);
       text_position->affinity_ = AX_TEXT_AFFINITY_DOWNSTREAM;
     }
 
     // If the word boundary is in the same subtree, return a position rooted at
     // the current position.
     // This is necessary because we don't want to return any position that might
     // be in the shadow DOM if the original position was not.
     AXPositionInstance common_ancestor =
         text_position->LowestCommonAncestor(*this);
     if (GetAnchor() == common_ancestor->GetAnchor())
-      return common_ancestor;
+      text_position = std::move(common_ancestor);
 
     if (was_tree_position)
       text_position = text_position->AsTreePosition();
     return text_position;
   }
 
   // Word end positions are one past the last character of the word.
   AXPositionInstance CreatePreviousWordEndPosition() const {
     bool was_tree_position = IsTreePosition();
     AXPositionInstance text_position = AsLeafTextPosition();
-    if (text_position->IsNullPosition())
-      return text_position;
 
     if (text_position->AtStartOfAnchor()) {
       text_position = text_position->CreatePreviousTextAnchorPosition();
       text_position = text_position->CreatePositionAtEndOfAnchor();
     }
-
-    // Ignore any nodes with no text or no word boundaries.
-    while (!text_position->IsNullPosition() &&
-           (!text_position->MaxTextOffset() ||
-            text_position->GetWordStartOffsets().empty())) {
-      text_position = text_position->CreatePreviousTextAnchorPosition();
-    }
-
     if (text_position->IsNullPosition())
       return text_position;
 
     const std::vector<int32_t> word_ends = text_position->GetWordEndOffsets();
     auto iterator =
         std::lower_bound(word_ends.begin(), word_ends.end(),
                          static_cast<int32_t>(text_position->text_offset_));
-    if (iterator == word_ends.begin()) {
-      // We must be anywhere up to and including the end of the first word in
-      // this node.
+    if (word_ends.empty() || iterator == word_ends.begin()) {
+      // Ignore any nodes with no text or no word boundaries.
       do {
         text_position = text_position->CreatePreviousTextAnchorPosition();
       } while (!text_position->IsNullPosition() &&
                (!text_position->MaxTextOffset() ||
                 text_position->GetWordStartOffsets().empty()));
       if (text_position->IsNullPosition())
         return text_position;
 
       const std::vector<int32_t> word_ends = text_position->GetWordEndOffsets();
+      DCHECK(!word_ends.empty());
       text_position->text_offset_ = static_cast<int>(*(word_ends.end() - 1));
     } else {
       text_position->text_offset_ = static_cast<int>(*(--iterator));
       text_position->affinity_ = AX_TEXT_AFFINITY_DOWNSTREAM;
     }
 
     // If the word boundary is in the same subtree, return a position rooted at
     // the current position.
     // This is necessary because we don't want to return any position that might
     // be in the shadow DOM if the original position was not.
     AXPositionInstance common_ancestor =
         text_position->LowestCommonAncestor(*this);
     if (GetAnchor() == common_ancestor->GetAnchor())
-      return common_ancestor;
+      text_position = std::move(common_ancestor);
 
     if (was_tree_position)
       text_position = text_position->AsTreePosition();
     return text_position;
   }
 
   AXPositionInstance CreateNextLineStartPosition() const {
     bool was_tree_position = IsTreePosition();
     AXPositionInstance text_position = AsLeafTextPosition();
     if (text_position->IsNullPosition())
       return text_position;
 
     // Find the next line break.
     int32_t next_on_line_id = text_position->anchor_id_;
     while (GetNextOnLineID(next_on_line_id) != INVALID_ANCHOR_ID)
       next_on_line_id = GetNextOnLineID(next_on_line_id);
     text_position =
         CreateTextPosition(tree_id_, next_on_line_id, 0 /* text_offset */,
                            AX_TEXT_AFFINITY_DOWNSTREAM);
     text_position =
         text_position->AsLeafTextPosition()->CreateNextTextAnchorPosition();
+    while (text_position->IsInLineBreak()) {
+      text_position = text_position->CreateNextTextAnchorPosition();
+    }

[dmazzoni, 2017/04/10 22:39:49]

nit: no brackets needed here?

     if (text_position->IsNullPosition())
       return text_position;
 
     // If the line boundary is in the same subtree, return a position rooted at
     // the current position.
     // This is necessary because we don't want to return any position that might
     // be in the shadow DOM if the original position was not.
     AXPositionInstance common_ancestor =
         text_position->LowestCommonAncestor(*this);
     if (GetAnchor() == common_ancestor->GetAnchor())
-      return common_ancestor;
+      text_position = std::move(common_ancestor);
 
     if (was_tree_position)
       text_position = text_position->AsTreePosition();
     return text_position;
   }
 
   AXPositionInstance CreatePreviousLineStartPosition() const {
     bool was_tree_position = IsTreePosition();
     AXPositionInstance text_position = AsLeafTextPosition();
-    if (text_position->AtStartOfAnchor())
+    if (text_position->IsInLineBreak() || text_position->AtStartOfAnchor())
       text_position = text_position->CreatePreviousTextAnchorPosition();
     if (text_position->IsNullPosition())
       return text_position;
 
     int32_t previous_on_line_id = text_position->anchor_id_;
     while (GetPreviousOnLineID(previous_on_line_id) != INVALID_ANCHOR_ID)
       previous_on_line_id = GetPreviousOnLineID(previous_on_line_id);
     text_position =
         CreateTextPosition(tree_id_, previous_on_line_id, 0 /* text_offset */,
                            AX_TEXT_AFFINITY_DOWNSTREAM);
     text_position = text_position->AsLeafTextPosition();
     if (text_position->IsNullPosition())
       return text_position;
 
     // If the line boundary is in the same subtree, return a position rooted at
     // the current position.
     // This is necessary because we don't want to return any position that might
     // be in the shadow DOM if the original position was not.
     AXPositionInstance common_ancestor =
         text_position->LowestCommonAncestor(*this);
     if (GetAnchor() == common_ancestor->GetAnchor())
-      return common_ancestor;
+      text_position = std::move(common_ancestor);
 
     if (was_tree_position)
       text_position = text_position->AsTreePosition();
     return text_position;
   }
 
   // Line end positions are one past the last character of the line, excluding
   // any newline characters.
   AXPositionInstance CreateNextLineEndPosition() const {
     bool was_tree_position = IsTreePosition();
@@ skipping 20 matching lines @@
       return text_position;
     text_position = text_position->CreatePositionAtEndOfAnchor();
 
     // If the line boundary is in the same subtree, return a position rooted at
     // the current position.
     // This is necessary because we don't want to return any position that might
     // be in the shadow DOM if the original position was not.
     AXPositionInstance common_ancestor =
         text_position->LowestCommonAncestor(*this);
     if (GetAnchor() == common_ancestor->GetAnchor())
-      return common_ancestor;
+      text_position = std::move(common_ancestor);
 
     if (was_tree_position)
       text_position = text_position->AsTreePosition();
     return text_position;
   }
 
   // Line end positions are one past the last character of the line, excluding
   // any newline characters.
   AXPositionInstance CreatePreviousLineEndPosition() const {
     bool was_tree_position = IsTreePosition();
@@ skipping 16 matching lines @@
       return text_position;
     text_position = text_position->CreatePositionAtEndOfAnchor();
 
     // If the line boundary is in the same subtree, return a position rooted at
     // the current position.
     // This is necessary because we don't want to return any position that might
     // be in the shadow DOM if the original position was not.
     AXPositionInstance common_ancestor =
         text_position->LowestCommonAncestor(*this);
     if (GetAnchor() == common_ancestor->GetAnchor())
-      return common_ancestor;
+      text_position = std::move(common_ancestor);
 
     if (was_tree_position)
       text_position = text_position->AsTreePosition();
     return text_position;
   }
 
   // TODO(nektar): Add sentence and paragraph navigation methods.
 
   // Abstract methods.
 
@@ skipping 224 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_