Remove old accessibility enums, finish renaming public interface.

Source/testing/runner/AccessibilityUIElementChromium.cpp

 /*
  * Copyright (C) 2010 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 17 matching lines @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "AccessibilityUIElementChromium.h"
 
 #include "TestCommon.h"
 #include "public/platform/WebCString.h"
 #include "public/platform/WebPoint.h"
 #include "public/platform/WebRect.h"
 #include "public/platform/WebString.h"
-#include "public/web/WebAccessibilityObject.h"
+#include "public/web/WebAXObject.h"
 
 using namespace WebKit;
 using namespace std;
 
 namespace WebTestRunner {
 
 namespace {
 
 // Map role value to string, matching Safari/Mac platform implementation to
 // avoid rebaselining layout tests.
@@ skipping 219 matching lines @@
         return result.append("ValueIndicator");
     case WebAXRoleWebArea:
         return result.append("WebArea");
     case WebAXRoleWindow:
         return result.append("Window");
     default:
         return result.append("Unknown");
     }
 }
 
-string getDescription(const WebAccessibilityObject& object)
+string getDescription(const WebAXObject& object)
 {
     string description = object.accessibilityDescription().utf8();
     return description.insert(0, "AXDescription: ");
 }
 
-string getHelpText(const WebAccessibilityObject& object)
+string getHelpText(const WebAXObject& object)
 {
     string helpText = object.helpText().utf8();
     return helpText.insert(0, "AXHelp: ");
 }
 
-string getStringValue(const WebAccessibilityObject& object)
+string getStringValue(const WebAXObject& object)
 {
     string value;
-    if (object.roleValue() == WebAccessibilityRoleColorWell) {
+    if (object.role() == WebAXRoleColorWell) {
         int r, g, b;
         char buffer[100];
         object.colorValue(r, g, b);
         snprintf(buffer, sizeof(buffer), "rgb %7.5f %7.5f %7.5f 1", r / 255., g / 255., b / 255.);
         value = buffer;
     } else
         value = object.stringValue().utf8();
     return value.insert(0, "AXValue: ");
 }
 
-string getRole(const WebAccessibilityObject& object)
+string getRole(const WebAXObject& object)
 {
     string roleString = roleToString(object.role());
 
     // Special-case canvas with fallback content because Chromium wants to
     // treat this as essentially a separate role that it can map differently depending
     // on the platform.
-    if (object.roleValue() == WebAccessibilityRoleCanvas && object.canvasHasFallbackContent())
+    if (object.role() == WebAXRoleCanvas && object.canvasHasFallbackContent())
         roleString += "WithFallbackContent";
 
     return roleString;
 }
 
-string getTitle(const WebAccessibilityObject& object)
+string getTitle(const WebAXObject& object)
 {
     string title = object.title().utf8();
     return title.insert(0, "AXTitle: ");
 }
 
-string getOrientation(const WebAccessibilityObject& object)
+string getOrientation(const WebAXObject& object)
 {
     if (object.isVertical())
         return "AXOrientation: AXVerticalOrientation";
 
     return "AXOrientation: AXHorizontalOrientation";
 }
 
-string getValueDescription(const WebAccessibilityObject& object)
+string getValueDescription(const WebAXObject& object)
 {
     string valueDescription = object.valueDescription().utf8();
     return valueDescription.insert(0, "AXValueDescription: ");
 }
 
-string getAttributes(const WebAccessibilityObject& object)
+string getAttributes(const WebAXObject& object)
 {
     // FIXME: Concatenate all attributes of the AccessibilityObject.
     string attributes(getTitle(object));
     attributes.append("\n");
     attributes.append(getRole(object));
     attributes.append("\n");
     attributes.append(getDescription(object));
     return attributes;
 }
 
 
 // Collects attributes into a string, delimited by dashes. Used by all methods
 // that output lists of attributes: attributesOfLinkedUIElementsCallback,
 // AttributesOfChildrenCallback, etc.
 class AttributesCollector {
 public:
-    void collectAttributes(const WebAccessibilityObject& object)
+    void collectAttributes(const WebAXObject& object)
     {
         m_attributes.append("\n------------\n");
         m_attributes.append(getAttributes(object));
     }
 
     string attributes() const { return m_attributes; }
 
 private:
     string m_attributes;
 };
 
 }
 
-AccessibilityUIElement::AccessibilityUIElement(const WebAccessibilityObject& object, Factory* factory)
+AccessibilityUIElement::AccessibilityUIElement(const WebAXObject& object, Factory* factory)
     : m_accessibilityObject(object)
     , m_factory(factory)
 {
 
     WEBKIT_ASSERT(factory);
 
     //
     // Properties
     //
 
@@ skipping 81 matching lines @@
     bindMethod("scrollToGlobalPoint", &AccessibilityUIElement::scrollToGlobalPointCallback);
 
     bindFallbackMethod(&AccessibilityUIElement::fallbackCallback);
 }
 
 AccessibilityUIElement* AccessibilityUIElement::getChildAtIndex(unsigned index)
 {
     return m_factory->getOrCreate(accessibilityObject().childAt(index));
 }
 
-bool AccessibilityUIElement::isEqual(const WebKit::WebAccessibilityObject& other)
+bool AccessibilityUIElement::isEqual(const WebKit::WebAXObject& other)
 {
     return accessibilityObject().equals(other);
 }
 
 void AccessibilityUIElement::notificationReceived(const char* notificationName)
 {
     size_t callbackCount = m_notificationCallbacks.size();
     for (size_t i = 0; i < callbackCount; i++) {
         CppVariant notificationNameArgument;
         notificationNameArgument.set(notificationName);
@@ skipping 48 matching lines @@
 
 void AccessibilityUIElement::heightGetterCallback(CppVariant* result)
 {
     result->set(accessibilityObject().boundingBoxRect().height);
 }
 
 void AccessibilityUIElement::intValueGetterCallback(CppVariant* result)
 {
     if (accessibilityObject().supportsRangeValue())
         result->set(accessibilityObject().valueForRange());
-    else if (accessibilityObject().roleValue() == WebAccessibilityRoleHeading)
+    else if (accessibilityObject().role() == WebAXRoleHeading)
         result->set(accessibilityObject().headingLevel());
     else
         result->set(atoi(accessibilityObject().stringValue().utf8().data()));
 }
 
 void AccessibilityUIElement::minValueGetterCallback(CppVariant* result)
 {
     result->set(accessibilityObject().minValueForRange());
 }
 
@@ skipping 226 matching lines @@
 void AccessibilityUIElement::elementAtPointCallback(const CppArgumentList& arguments, CppVariant* result)
 {
     result->setNull();
 
     if (arguments.size() != 2 || !arguments[0].isNumber() || !arguments[1].isNumber())
         return;
 
     int x = arguments[0].toInt32();
     int y = arguments[1].toInt32();
     WebPoint point(x, y);
-    WebAccessibilityObject obj = accessibilityObject().hitTest(point);
+    WebAXObject obj = accessibilityObject().hitTest(point);
     if (obj.isNull())
         return;
 
     result->set(*(m_factory->getOrCreate(obj)->getAsCppVariant()));
 }
 
 void AccessibilityUIElement::attributesOfColumnHeadersCallback(const CppArgumentList&, CppVariant* result)
 {
     result->setNull();
 }
@@ skipping 18 matching lines @@
     result->setNull();
 }
 
 void AccessibilityUIElement::attributesOfHeaderCallback(const CppArgumentList&, CppVariant* result)
 {
     result->setNull();
 }
 
 void AccessibilityUIElement::tableHeaderCallback(const CppArgumentList&, CppVariant* result)
 {
-    WebAccessibilityObject obj = accessibilityObject().headerContainerObject();
+    WebAXObject obj = accessibilityObject().headerContainerObject();
     if (obj.isNull()) {
         result->setNull();
         return;
     }
 
     result->set(*(m_factory->getOrCreate(obj)->getAsCppVariant()));
 }
 
 void AccessibilityUIElement::indexInTableCallback(const CppArgumentList&, CppVariant* result)
 {
@@ skipping 19 matching lines @@
     result->set(std::string(buffer));
 }
 
 void AccessibilityUIElement::cellForColumnAndRowCallback(const CppArgumentList& arguments, CppVariant* result)
 {
     if (arguments.size() != 2 || !arguments[0].isNumber() || !arguments[1].isNumber())
         return;
 
     int column = arguments[0].toInt32();
     int row = arguments[1].toInt32();
-    WebAccessibilityObject obj = accessibilityObject().cellForColumnAndRow(column, row);
+    WebAXObject obj = accessibilityObject().cellForColumnAndRow(column, row);
     if (obj.isNull()) {
         result->setNull();
         return;
     }
 
     result->set(*(m_factory->getOrCreate(obj)->getAsCppVariant()));
 }
 
 void AccessibilityUIElement::titleUIElementCallback(const CppArgumentList&, CppVariant* result)
 {
-    WebAccessibilityObject obj = accessibilityObject().titleUIElement();
+    WebAXObject obj = accessibilityObject().titleUIElement();
     if (obj.isNull()) {
         result->setNull();
         return;
     }
 
     result->set(*(m_factory->getOrCreate(obj)->getAsCppVariant()));
 }
 
 void AccessibilityUIElement::setSelectedTextRangeCallback(const CppArgumentList&arguments, CppVariant* result)
 {
@@ skipping 147 matching lines @@
     accessibilityObject().scrollToGlobalPoint(WebPoint(x, y));
     result->setNull();
 }
 
 void AccessibilityUIElement::fallbackCallback(const CppArgumentList &, CppVariant* result)
 {
     // FIXME: Implement this.
     result->setNull();
 }
 
-RootAccessibilityUIElement::RootAccessibilityUIElement(const WebAccessibilityObject &object, Factory *factory)
+RootAccessibilityUIElement::RootAccessibilityUIElement(const WebAXObject &object, Factory *factory)
     : AccessibilityUIElement(object, factory) { }
 
 AccessibilityUIElement* RootAccessibilityUIElement::getChildAtIndex(unsigned index)
 {
     if (index)
         return 0;
 
     return factory()->getOrCreate(accessibilityObject());
 }
 
 
 AccessibilityUIElementList ::~AccessibilityUIElementList()
 {
     clear();
 }
 
 void AccessibilityUIElementList::clear()
 {
     for (ElementList::iterator i = m_elements.begin(); i != m_elements.end(); ++i)
         delete (*i);
     m_elements.clear();
 }
 
-AccessibilityUIElement* AccessibilityUIElementList::getOrCreate(const WebAccessibilityObject& object)
+AccessibilityUIElement* AccessibilityUIElementList::getOrCreate(const WebAXObject& object)
 {
     if (object.isNull())
         return 0;
 
     size_t elementCount = m_elements.size();
     for (size_t i = 0; i < elementCount; i++) {
         if (m_elements[i]->isEqual(object))
             return m_elements[i];
     }
 
     AccessibilityUIElement* element = new AccessibilityUIElement(object, this);
     m_elements.push_back(element);
     return element;
 }
 
-AccessibilityUIElement* AccessibilityUIElementList::createRoot(const WebAccessibilityObject& object)
+AccessibilityUIElement* AccessibilityUIElementList::createRoot(const WebAXObject& object)
 {
     AccessibilityUIElement* element = new RootAccessibilityUIElement(object, this);
     m_elements.push_back(element);
     return element;
 }
 
 }