Rename AXObject to AXObjectImpl in modules/ and web/

third_party/WebKit/Source/modules/accessibility/InspectorTypeBuilderHelper.cpp

 // Copyright 2015 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.
 
 #include "modules/accessibility/InspectorTypeBuilderHelper.h"
 
 #include "core/dom/DOMNodeIds.h"
-#include "modules/accessibility/AXObject.h"
 #include "modules/accessibility/AXObjectCacheImpl.h"
+#include "modules/accessibility/AXObjectImpl.h"
 
 namespace blink {
 
 using namespace HTMLNames;
 using namespace protocol::Accessibility;
 
 std::unique_ptr<AXProperty> CreateProperty(const String& name,
                                            std::unique_ptr<AXValue> value) {
   return AXProperty::create().setName(name).setValue(std::move(value)).build();
 }
@@ skipping 70 matching lines @@
       .build();
 }
 
 std::unique_ptr<AXValue> CreateBooleanValue(bool value, const String& type) {
   return AXValue::create()
       .setType(type)
       .setValue(protocol::ValueConversions<bool>::toValue(value))
       .build();
 }
 
-std::unique_ptr<AXRelatedNode> RelatedNodeForAXObject(const AXObject& ax_object,
-                                                      String* name = nullptr) {
+std::unique_ptr<AXRelatedNode> RelatedNodeForAXObject(
+    const AXObjectImpl& ax_object,
+    String* name = nullptr) {
   Node* node = ax_object.GetNode();
   if (!node)
     return nullptr;
   int backend_node_id = DOMNodeIds::IdForNode(node);
   if (!backend_node_id)
     return nullptr;
   std::unique_ptr<AXRelatedNode> related_node =
       AXRelatedNode::create().setBackendDOMNodeId(backend_node_id).build();
   if (!node->IsElementNode())
     return related_node;
 
   Element* element = ToElement(node);
   String idref = element->GetIdAttribute();
   if (!idref.IsEmpty())
     related_node->setIdref(idref);
 
   if (name)
     related_node->setText(*name);
   return related_node;
 }
 
-std::unique_ptr<AXValue> CreateRelatedNodeListValue(const AXObject& ax_object,
-                                                    String* name,
-                                                    const String& value_type) {
+std::unique_ptr<AXValue> CreateRelatedNodeListValue(
+    const AXObjectImpl& ax_object,
+    String* name,
+    const String& value_type) {
   std::unique_ptr<protocol::Array<AXRelatedNode>> related_nodes =
       protocol::Array<AXRelatedNode>::create();
   related_nodes->addItem(RelatedNodeForAXObject(ax_object, name));
   return AXValue::create()
       .setType(value_type)
       .setRelatedNodes(std::move(related_nodes))
       .build();
 }
 
 std::unique_ptr<AXValue> CreateRelatedNodeListValue(
     AXRelatedObjectVector& related_objects,
     const String& value_type) {
   std::unique_ptr<protocol::Array<AXRelatedNode>> frontend_related_nodes =
       protocol::Array<AXRelatedNode>::create();
   for (unsigned i = 0; i < related_objects.size(); i++) {
     std::unique_ptr<AXRelatedNode> frontend_related_node =
         RelatedNodeForAXObject(*(related_objects[i]->object),
                                &(related_objects[i]->text));
     if (frontend_related_node)
       frontend_related_nodes->addItem(std::move(frontend_related_node));
   }
   return AXValue::create()
       .setType(value_type)
       .setRelatedNodes(std::move(frontend_related_nodes))
       .build();
 }
 
 std::unique_ptr<AXValue> CreateRelatedNodeListValue(
-    AXObject::AXObjectVector& ax_objects,
+    AXObjectImpl::AXObjectVector& ax_objects,
     const String& value_type) {
   std::unique_ptr<protocol::Array<AXRelatedNode>> related_nodes =
       protocol::Array<AXRelatedNode>::create();
   for (unsigned i = 0; i < ax_objects.size(); i++) {
     std::unique_ptr<AXRelatedNode> related_node =
         RelatedNodeForAXObject(*(ax_objects[i].Get()));
     if (related_node)
       related_nodes->addItem(std::move(related_node));
   }
   return AXValue::create()
@@ skipping 71 matching lines @@
   if (name_source.superseded)
     value_source->setSuperseded(true);
   if (name_source.invalid)
     value_source->setInvalid(true);
   if (name_source.native_source != kAXTextFromNativeHTMLUninitialized)
     value_source->setNativeSource(NativeSourceType(name_source.native_source));
   return value_source;
 }
 
 }  // namespace blink