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

third_party/WebKit/Source/modules/exported/WebAXObject.cpp

 /*
  * Copyright (C) 2009 Google 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 30 matching lines @@
 #include "core/frame/VisualViewport.h"
 #include "core/frame/WebLocalFrameBase.h"
 #include "core/input/KeyboardEventManager.h"
 #include "core/layout/LayoutObject.h"
 #include "core/layout/api/LayoutAPIShim.h"
 #include "core/layout/api/LayoutViewItem.h"
 #include "core/page/Page.h"
 #include "core/style/ComputedStyle.h"
 #include "modules/accessibility/AXObjectCacheImpl.h"
 #include "modules/accessibility/AXObjectImpl.h"
+#include "modules/accessibility/AXRange.h"
 #include "modules/accessibility/AXTable.h"
 #include "modules/accessibility/AXTableCell.h"
 #include "modules/accessibility/AXTableColumn.h"
 #include "modules/accessibility/AXTableRow.h"
 #include "platform/wtf/text/StringBuilder.h"
 #include "public/platform/WebFloatRect.h"
 #include "public/platform/WebPoint.h"
 #include "public/platform/WebRect.h"
 #include "public/platform/WebString.h"
 #include "public/platform/WebURL.h"
@@ skipping 739 matching lines @@
   if (IsDetached()) {
     anchor_object = WebAXObject();
     anchor_offset = -1;
     anchor_affinity = kWebAXTextAffinityDownstream;
     focus_object = WebAXObject();
     focus_offset = -1;
     focus_affinity = kWebAXTextAffinityDownstream;
     return;
   }
 
+<<<<<<< HEAD:third_party/WebKit/Source/modules/exported/WebAXObject.cpp
   AXObjectImpl::AXRange ax_selection = private_->Selection();
   anchor_object = WebAXObject(ax_selection.anchor_object);
   anchor_offset = ax_selection.anchor_offset;
   anchor_affinity =
       static_cast<WebAXTextAffinity>(ax_selection.anchor_affinity);
   focus_object = WebAXObject(ax_selection.focus_object);
   focus_offset = ax_selection.focus_offset;
   focus_affinity = static_cast<WebAXTextAffinity>(ax_selection.focus_affinity);
   return;
+=======
+  AXRange ax_selection = private_->Selection();
+  // If selection is invalid, it will set object and offset endpoints to nullptr
+  // and -1 respectively.
+  anchor_object = WebAXObject(ax_selection.AnchorObject());
+  anchor_offset = ax_selection.AnchorOffset();
+  anchor_affinity = static_cast<WebAXTextAffinity>(ax_selection.Affinity());
+  focus_object = WebAXObject(ax_selection.FocusObject());
+  focus_offset = ax_selection.FocusOffset();
+  focus_affinity = static_cast<WebAXTextAffinity>(ax_selection.Affinity());
+>>>>>>> Simplified and cleaned up selection code in Blink > Accessibility.:third_party/WebKit/Source/web/WebAXObject.cpp
 }
 
 void WebAXObject::SetSelection(const WebAXObject& anchor_object,
                                int anchor_offset,
                                const WebAXObject& focus_object,
                                int focus_offset) const {
   if (IsDetached())
     return;
 
+<<<<<<< HEAD:third_party/WebKit/Source/modules/exported/WebAXObject.cpp
   AXObjectImpl::AXRange ax_selection(anchor_object, anchor_offset,
                                      TextAffinity::kUpstream, focus_object,
                                      focus_offset, TextAffinity::kDownstream);
   private_->SetSelection(ax_selection);
+=======
+  AXRange ax_selection(anchor_object, anchor_offset, focus_object, focus_offset,
+                       TextAffinity::kDownstream);
+  ax_selection.Select();
+>>>>>>> Simplified and cleaned up selection code in Blink > Accessibility.:third_party/WebKit/Source/web/WebAXObject.cpp
   return;
 }
 
 unsigned WebAXObject::SelectionEnd() const {
   if (IsDetached())
     return 0;
 
+<<<<<<< HEAD:third_party/WebKit/Source/modules/exported/WebAXObject.cpp
   AXObjectImpl::AXRange ax_selection = private_->SelectionUnderObject();
   if (ax_selection.focus_offset < 0)
+=======
+  AXRange ax_selection = private_->Selection();
+  if (ax_selection.FocusOffset() < 0)
+>>>>>>> Simplified and cleaned up selection code in Blink > Accessibility.:third_party/WebKit/Source/web/WebAXObject.cpp
     return 0;
 
-  return ax_selection.focus_offset;
+  return ax_selection.FocusOffset();
 }
 
 unsigned WebAXObject::SelectionStart() const {
   if (IsDetached())
     return 0;
 
+<<<<<<< HEAD:third_party/WebKit/Source/modules/exported/WebAXObject.cpp
   AXObjectImpl::AXRange ax_selection = private_->SelectionUnderObject();
   if (ax_selection.anchor_offset < 0)
+=======
+  AXRange ax_selection = private_->Selection();
+  if (ax_selection.AnchorOffset() < 0)
+>>>>>>> Simplified and cleaned up selection code in Blink > Accessibility.:third_party/WebKit/Source/web/WebAXObject.cpp
     return 0;
 
-  return ax_selection.anchor_offset;
+  return ax_selection.AnchorOffset();
 }
 
 unsigned WebAXObject::SelectionEndLineNumber() const {
   if (IsDetached())
     return 0;
 
   VisiblePosition position = private_->VisiblePositionForIndex(SelectionEnd());
   int line_number = private_->LineForPosition(position);
   if (line_number < 0)
     return 0;
@@ skipping 17 matching lines @@
 void WebAXObject::SetFocused(bool on) const {
   if (!IsDetached())
     private_->SetFocused(on);
 }
 
 void WebAXObject::SetSelectedTextRange(int selection_start,
                                        int selection_end) const {
   if (IsDetached())
     return;
 
+<<<<<<< HEAD:third_party/WebKit/Source/modules/exported/WebAXObject.cpp
   private_->SetSelection(AXObjectImpl::AXRange(selection_start, selection_end));
+=======
+  AXRange ax_selection(private_.Get(), selection_start, private_.Get(),
+                       selection_end);
+  if (ax_selection.IsValid())
+    ax_selection.Select();
+>>>>>>> Simplified and cleaned up selection code in Blink > Accessibility.:third_party/WebKit/Source/web/WebAXObject.cpp
 }
 
 void WebAXObject::SetSequentialFocusNavigationStartingPoint() const {
   if (IsDetached())
     return;
 
   private_->SetSequentialFocusNavigationStartingPoint();
 }
 
 void WebAXObject::SetValue(WebString value) const {
@@ skipping 508 matching lines @@
   return WebAXObject(private_.Get()->PreviousOnLine());
 }
 
 void WebAXObject::Markers(WebVector<WebAXMarkerType>& types,
                           WebVector<int>& starts,
                           WebVector<int>& ends) const {
   if (IsDetached())
     return;
 
   Vector<DocumentMarker::MarkerType> marker_types;
+<<<<<<< HEAD:third_party/WebKit/Source/modules/exported/WebAXObject.cpp
   Vector<AXObjectImpl::AXRange> marker_ranges;
+=======
+  Vector<AXRange> marker_ranges;
+>>>>>>> Simplified and cleaned up selection code in Blink > Accessibility.:third_party/WebKit/Source/web/WebAXObject.cpp
   private_->Markers(marker_types, marker_ranges);
   DCHECK_EQ(marker_types.size(), marker_ranges.size());
 
   WebVector<WebAXMarkerType> web_marker_types(marker_types.size());
   WebVector<int> start_offsets(marker_ranges.size());
   WebVector<int> end_offsets(marker_ranges.size());
   for (size_t i = 0; i < marker_types.size(); ++i) {
     web_marker_types[i] = static_cast<WebAXMarkerType>(marker_types[i]);
     DCHECK(marker_ranges[i].IsSimple());
-    start_offsets[i] = marker_ranges[i].anchor_offset;
-    end_offsets[i] = marker_ranges[i].focus_offset;
+    start_offsets[i] = marker_ranges[i].AnchorOffset();
+    end_offsets[i] = marker_ranges[i].FocusOffset();
   }
 
   types.Swap(web_marker_types);
   starts.Swap(start_offsets);
   ends.Swap(end_offsets);
 }
 
 void WebAXObject::CharacterOffsets(WebVector<int>& offsets) const {
   if (IsDetached())
     return;
 
   Vector<int> offsets_vector;
   private_->TextCharacterOffsets(offsets_vector);
 
   size_t vector_size = offsets_vector.size();
   WebVector<int> offsets_web_vector(vector_size);
   for (size_t i = 0; i < vector_size; i++)
     offsets_web_vector[i] = offsets_vector[i];
   offsets.Swap(offsets_web_vector);
 }
 
 void WebAXObject::GetWordBoundaries(WebVector<int>& starts,
                                     WebVector<int>& ends) const {
   if (IsDetached())
     return;
 
+<<<<<<< HEAD:third_party/WebKit/Source/modules/exported/WebAXObject.cpp
   Vector<AXObjectImpl::AXRange> word_boundaries;
+=======
+  Vector<AXRange> word_boundaries;
+>>>>>>> Simplified and cleaned up selection code in Blink > Accessibility.:third_party/WebKit/Source/web/WebAXObject.cpp
   private_->GetWordBoundaries(word_boundaries);
 
   WebVector<int> word_start_offsets(word_boundaries.size());
   WebVector<int> word_end_offsets(word_boundaries.size());
   for (size_t i = 0; i < word_boundaries.size(); ++i) {
     DCHECK(word_boundaries[i].IsSimple());
-    word_start_offsets[i] = word_boundaries[i].anchor_offset;
-    word_end_offsets[i] = word_boundaries[i].focus_offset;
+    word_start_offsets[i] = word_boundaries[i].AnchorOffset();
+    word_end_offsets[i] = word_boundaries[i].FocusOffset();
   }
 
   starts.Swap(word_start_offsets);
   ends.Swap(word_end_offsets);
 }
 
 bool WebAXObject::IsScrollableContainer() const {
   if (IsDetached())
     return false;
 
@@ skipping 111 matching lines @@
 
 // static
 WebAXObject WebAXObject::FromWebDocumentFocused(
     const WebDocument& web_document) {
   const Document* document = web_document.ConstUnwrap<Document>();
   AXObjectCacheImpl* cache = ToAXObjectCacheImpl(document->AxObjectCache());
   return cache ? WebAXObject(cache->FocusedObject()) : WebAXObject();
 }
 
 }  // namespace blink