Rename AXObject to AXObjectImpl in modules/ and web/

third_party/WebKit/Source/web/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 25 matching lines @@
 #include "core/dom/Document.h"
 #include "core/dom/Node.h"
 #include "core/editing/markers/DocumentMarker.h"
 #include "core/exported/WebViewBase.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/VisualViewport.h"
 #include "core/frame/WebLocalFrameBase.h"
 #include "core/input/KeyboardEventManager.h"
 #include "core/page/Page.h"
 #include "core/style/ComputedStyle.h"
-#include "modules/accessibility/AXObject.h"
 #include "modules/accessibility/AXObjectCacheImpl.h"
+#include "modules/accessibility/AXObjectImpl.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 17 matching lines @@
                                     value);
   }
 
   void AddStringAttribute(AXStringAttribute attribute,
                           const String& value) override {
     attribute_map_.AddStringAttribute(
         static_cast<WebAXStringAttribute>(attribute), value);
   }
 
   void AddObjectAttribute(AXObjectAttribute attribute,
-                          AXObject& value) override {
+                          AXObjectImpl& value) override {
     attribute_map_.AddObjectAttribute(
         static_cast<WebAXObjectAttribute>(attribute), WebAXObject(&value));
   }
 
-  void AddObjectVectorAttribute(AXObjectVectorAttribute attribute,
-                                HeapVector<Member<AXObject>>& value) override {
+  void AddObjectVectorAttribute(
+      AXObjectVectorAttribute attribute,
+      HeapVector<Member<AXObjectImpl>>& value) override {
     WebVector<WebAXObject> result(value.size());
     for (size_t i = 0; i < value.size(); i++)
       result[i] = WebAXObject(value[i]);
     attribute_map_.AddObjectVectorAttribute(
         static_cast<WebAXObjectVectorAttribute>(attribute), result);
   }
 };
 
 #if DCHECK_IS_ON()
 // It's not safe to call some WebAXObject APIs if a layout is pending.
@@ skipping 455 matching lines @@
   if (IsDetached())
     return WebString();
 
   return private_->LiveRegionStatus();
 }
 
 WebAXObject WebAXObject::LiveRegionRoot() const {
   if (IsDetached())
     return WebAXObject();
 
-  AXObject* live_region_root = private_->LiveRegionRoot();
+  AXObjectImpl* live_region_root = private_->LiveRegionRoot();
   if (live_region_root)
     return WebAXObject(live_region_root);
   return WebAXObject();
 }
 
 bool WebAXObject::ContainerLiveRegionAtomic() const {
   if (IsDetached())
     return false;
 
   return private_->ContainerLiveRegionAtomic();
@@ skipping 98 matching lines @@
 // that (0, 0) is the top left of the visual viewport. In other words, the
 // point has the VisualViewport scale applied, but not the VisualViewport
 // offset. crbug.com/459591.
 WebAXObject WebAXObject::HitTest(const WebPoint& point) const {
   if (IsDetached())
     return WebAXObject();
 
   IntPoint contents_point =
       private_->DocumentFrameView()->SoonToBeRemovedUnscaledViewportToContents(
           point);
-  AXObject* hit = private_->AccessibilityHitTest(contents_point);
+  AXObjectImpl* hit = private_->AccessibilityHitTest(contents_point);
 
   if (hit)
     return WebAXObject(hit);
 
   if (private_->GetBoundsInFrameCoordinates().Contains(contents_point))
     return *this;
 
   return WebAXObject();
 }
 
@@ skipping 58 matching lines @@
   if (CanDecrement()) {
     private_->Decrement();
     return true;
   }
   return false;
 }
 
 WebAXObject WebAXObject::InPageLinkTarget() const {
   if (IsDetached())
     return WebAXObject();
-  AXObject* target = private_->InPageLinkTarget();
+  AXObjectImpl* target = private_->InPageLinkTarget();
   if (!target)
     return WebAXObject();
   return WebAXObject(target);
 }
 
 WebAXOrientation WebAXObject::Orientation() const {
   if (IsDetached())
     return kWebAXOrientationUndefined;
 
   return static_cast<WebAXOrientation>(private_->Orientation());
 }
 
 bool WebAXObject::Press() const {
   if (IsDetached())
     return false;
 
   return private_->Press();
 }
 
 WebVector<WebAXObject> WebAXObject::RadioButtonsInGroup() const {
   if (IsDetached())
     return WebVector<WebAXObject>();
 
-  AXObject::AXObjectVector radio_buttons = private_->RadioButtonsInGroup();
+  AXObjectImpl::AXObjectVector radio_buttons = private_->RadioButtonsInGroup();
   WebVector<WebAXObject> web_radio_buttons(radio_buttons.size());
   for (size_t i = 0; i < radio_buttons.size(); ++i)
     web_radio_buttons[i] = WebAXObject(radio_buttons[i]);
   return web_radio_buttons;
 }
 
 WebAXRole WebAXObject::Role() const {
   if (IsDetached())
     return kWebAXRoleUnknown;
 
   return static_cast<WebAXRole>(private_->RoleValue());
 }
 
 void WebAXObject::Selection(WebAXObject& anchor_object,
                             int& anchor_offset,
                             WebAXTextAffinity& anchor_affinity,
                             WebAXObject& focus_object,
                             int& focus_offset,
                             WebAXTextAffinity& focus_affinity) const {
   if (IsDetached()) {
     anchor_object = WebAXObject();
     anchor_offset = -1;
     anchor_affinity = kWebAXTextAffinityDownstream;
     focus_object = WebAXObject();
     focus_offset = -1;
     focus_affinity = kWebAXTextAffinityDownstream;
     return;
   }
 
-  AXObject::AXRange ax_selection = private_->Selection();
+  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;
 }
 
 void WebAXObject::SetSelection(const WebAXObject& anchor_object,
                                int anchor_offset,
                                const WebAXObject& focus_object,
                                int focus_offset) const {
   if (IsDetached())
     return;
 
-  AXObject::AXRange ax_selection(anchor_object, anchor_offset,
-                                 TextAffinity::kUpstream, focus_object,
-                                 focus_offset, TextAffinity::kDownstream);
+  AXObjectImpl::AXRange ax_selection(anchor_object, anchor_offset,
+                                     TextAffinity::kUpstream, focus_object,
+                                     focus_offset, TextAffinity::kDownstream);
   private_->SetSelection(ax_selection);
   return;
 }
 
 unsigned WebAXObject::SelectionEnd() const {
   if (IsDetached())
     return 0;
 
-  AXObject::AXRange ax_selection = private_->SelectionUnderObject();
+  AXObjectImpl::AXRange ax_selection = private_->SelectionUnderObject();
   if (ax_selection.focus_offset < 0)
     return 0;
 
   return ax_selection.focus_offset;
 }
 
 unsigned WebAXObject::SelectionStart() const {
   if (IsDetached())
     return 0;
 
-  AXObject::AXRange ax_selection = private_->SelectionUnderObject();
+  AXObjectImpl::AXRange ax_selection = private_->SelectionUnderObject();
   if (ax_selection.anchor_offset < 0)
     return 0;
 
   return ax_selection.anchor_offset;
 }
 
 unsigned WebAXObject::SelectionEndLineNumber() const {
   if (IsDetached())
     return 0;
 
@@ skipping 21 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;
 
-  private_->SetSelection(AXObject::AXRange(selection_start, selection_end));
+  private_->SetSelection(AXObjectImpl::AXRange(selection_start, selection_end));
 }
 
 void WebAXObject::SetSequentialFocusNavigationStartingPoint() const {
   if (IsDetached())
     return;
 
   private_->SetSequentialFocusNavigationStartingPoint();
 }
 
 void WebAXObject::SetValue(WebString value) const {
@@ skipping 66 matching lines @@
 
   return private_->Url();
 }
 
 WebString WebAXObject::GetName(WebAXNameFrom& out_name_from,
                                WebVector<WebAXObject>& out_name_objects) const {
   if (IsDetached())
     return WebString();
 
   AXNameFrom name_from = kAXNameFromUninitialized;
-  HeapVector<Member<AXObject>> name_objects;
+  HeapVector<Member<AXObjectImpl>> name_objects;
   WebString result = private_->GetName(name_from, &name_objects);
   out_name_from = static_cast<WebAXNameFrom>(name_from);
 
   WebVector<WebAXObject> web_name_objects(name_objects.size());
   for (size_t i = 0; i < name_objects.size(); i++)
     web_name_objects[i] = WebAXObject(name_objects[i]);
   out_name_objects.Swap(web_name_objects);
 
   return result;
 }
 
 WebString WebAXObject::GetName() const {
   if (IsDetached())
     return WebString();
 
   AXNameFrom name_from;
-  HeapVector<Member<AXObject>> name_objects;
+  HeapVector<Member<AXObjectImpl>> name_objects;
   return private_->GetName(name_from, &name_objects);
 }
 
 WebString WebAXObject::Description(
     WebAXNameFrom name_from,
     WebAXDescriptionFrom& out_description_from,
     WebVector<WebAXObject>& out_description_objects) const {
   if (IsDetached())
     return WebString();
 
   AXDescriptionFrom description_from = kAXDescriptionFromUninitialized;
-  HeapVector<Member<AXObject>> description_objects;
+  HeapVector<Member<AXObjectImpl>> description_objects;
   String result = private_->Description(static_cast<AXNameFrom>(name_from),
                                         description_from, &description_objects);
   out_description_from = static_cast<WebAXDescriptionFrom>(description_from);
 
   WebVector<WebAXObject> web_description_objects(description_objects.size());
   for (size_t i = 0; i < description_objects.size(); i++)
     web_description_objects[i] = WebAXObject(description_objects[i]);
   out_description_objects.Swap(web_description_objects);
 
   return result;
@@ skipping 187 matching lines @@
 WebAXObject WebAXObject::CellForColumnAndRow(unsigned column,
                                              unsigned row) const {
   if (IsDetached())
     return WebAXObject();
 
   if (!private_->IsAXTable())
     return WebAXObject();
 
   AXTableCell* cell =
       ToAXTable(private_.Get())->CellForColumnAndRow(column, row);
-  return WebAXObject(static_cast<AXObject*>(cell));
+  return WebAXObject(static_cast<AXObjectImpl*>(cell));
 }
 
 WebAXObject WebAXObject::HeaderContainerObject() const {
   if (IsDetached())
     return WebAXObject();
 
   if (!private_->IsAXTable())
     return WebAXObject();
 
   return WebAXObject(ToAXTable(private_.Get())->HeaderContainer());
 }
 
 WebAXObject WebAXObject::RowAtIndex(unsigned row_index) const {
   if (IsDetached())
     return WebAXObject();
 
   if (!private_->IsAXTable())
     return WebAXObject();
 
-  const AXObject::AXObjectVector& rows = ToAXTable(private_.Get())->Rows();
+  const AXObjectImpl::AXObjectVector& rows = ToAXTable(private_.Get())->Rows();
   if (row_index < rows.size())
     return WebAXObject(rows[row_index]);
 
   return WebAXObject();
 }
 
 WebAXObject WebAXObject::ColumnAtIndex(unsigned column_index) const {
   if (IsDetached())
     return WebAXObject();
 
   if (!private_->IsAXTable())
     return WebAXObject();
 
-  const AXObject::AXObjectVector& columns =
+  const AXObjectImpl::AXObjectVector& columns =
       ToAXTable(private_.Get())->Columns();
   if (column_index < columns.size())
     return WebAXObject(columns[column_index]);
 
   return WebAXObject();
 }
 
 unsigned WebAXObject::RowIndex() const {
   if (IsDetached())
     return 0;
@@ skipping 15 matching lines @@
 }
 
 void WebAXObject::RowHeaders(
     WebVector<WebAXObject>& row_header_elements) const {
   if (IsDetached())
     return;
 
   if (!private_->IsAXTable())
     return;
 
-  AXObject::AXObjectVector headers;
+  AXObjectImpl::AXObjectVector headers;
   ToAXTable(private_.Get())->RowHeaders(headers);
 
   size_t header_count = headers.size();
   WebVector<WebAXObject> result(header_count);
 
   for (size_t i = 0; i < header_count; i++)
     result[i] = WebAXObject(headers[i]);
 
   row_header_elements.Swap(result);
 }
@@ skipping 19 matching lines @@
 }
 
 void WebAXObject::ColumnHeaders(
     WebVector<WebAXObject>& column_header_elements) const {
   if (IsDetached())
     return;
 
   if (!private_->IsAXTable())
     return;
 
-  AXObject::AXObjectVector headers;
+  AXObjectImpl::AXObjectVector headers;
   ToAXTable(private_.Get())->ColumnHeaders(headers);
 
   size_t header_count = headers.size();
   WebVector<WebAXObject> result(header_count);
 
   for (size_t i = 0; i < header_count; i++)
     result[i] = WebAXObject(headers[i]);
 
   column_header_elements.Swap(result);
 }
@@ skipping 74 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;
-  Vector<AXObject::AXRange> marker_ranges;
+  Vector<AXObjectImpl::AXRange> marker_ranges;
   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;
@@ skipping 17 matching lines @@
   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;
 
-  Vector<AXObject::AXRange> word_boundaries;
+  Vector<AXObjectImpl::AXRange> word_boundaries;
   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;
   }
 
@@ skipping 39 matching lines @@
 void WebAXObject::GetRelativeBounds(WebAXObject& offset_container,
                                     WebFloatRect& bounds_in_container,
                                     SkMatrix44& container_transform) const {
   if (IsDetached())
     return;
 
 #if DCHECK_IS_ON()
   DCHECK(IsLayoutClean(private_->GetDocument()));
 #endif
 
-  AXObject* container = nullptr;
+  AXObjectImpl* container = nullptr;
   FloatRect bounds;
   private_->GetRelativeBounds(&container, bounds, container_transform);
   offset_container = WebAXObject(container);
   bounds_in_container = WebFloatRect(bounds);
 }
 
 void WebAXObject::ScrollToMakeVisible() const {
   if (!IsDetached())
     private_->ScrollToMakeVisible();
 }
 
 void WebAXObject::ScrollToMakeVisibleWithSubFocus(
     const WebRect& subfocus) const {
   if (!IsDetached())
     private_->ScrollToMakeVisibleWithSubFocus(subfocus);
 }
 
 void WebAXObject::ScrollToGlobalPoint(const WebPoint& point) const {
   if (!IsDetached())
     private_->ScrollToGlobalPoint(point);
 }
 
-WebAXObject::WebAXObject(AXObject* object) : private_(object) {}
+WebAXObject::WebAXObject(AXObjectImpl* object) : private_(object) {}
 
-WebAXObject& WebAXObject::operator=(AXObject* object) {
+WebAXObject& WebAXObject::operator=(AXObjectImpl* object) {
   private_ = object;
   return *this;
 }
 
-WebAXObject::operator AXObject*() const {
+WebAXObject::operator AXObjectImpl*() const {
   return private_.Get();
 }
 
 }  // namespace blink