Migrate accessibility/ to using nullptr instead of 0
authormmaxfield@apple.com <mmaxfield@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 23 Jul 2014 14:57:15 +0000 (14:57 +0000)
committermmaxfield@apple.com <mmaxfield@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 23 Jul 2014 14:57:15 +0000 (14:57 +0000)
https://bugs.webkit.org/show_bug.cgi?id=135185

Reviewed by Simon Fraser.

No new tests because there is no behavior change.

* accessibility/AXObjectCache.cpp:
(WebCore::AXObjectCache::focusedImageMapUIElement):
(WebCore::AXObjectCache::focusedUIElementForPage):
(WebCore::AXObjectCache::get):
(WebCore::AXObjectCache::getOrCreate):
(WebCore::AXObjectCache::rootObject):
(WebCore::AXObjectCache::rootObjectForFrame):
* accessibility/AXObjectCache.h:
(WebCore::AXObjectCache::focusedUIElementForPage):
(WebCore::AXObjectCache::get):
(WebCore::AXObjectCache::getOrCreate):
(WebCore::AXObjectCache::rootObject):
(WebCore::AXObjectCache::rootObjectForFrame):
(WebCore::AXObjectCache::rootAXEditableElement):
* accessibility/AccessibilityARIAGridRow.cpp:
(WebCore::AccessibilityARIAGridRow::disclosedByRow):
* accessibility/AccessibilityImageMapLink.cpp:
(WebCore::AccessibilityImageMapLink::AccessibilityImageMapLink):
(WebCore::AccessibilityImageMapLink::parentObject):
* accessibility/AccessibilityListBox.cpp:
(WebCore::AccessibilityListBox::listBoxOptionAccessibilityObject):
(WebCore::AccessibilityListBox::elementAccessibilityHitTest):
* accessibility/AccessibilityListBoxOption.cpp:
(WebCore::AccessibilityListBoxOption::AccessibilityListBoxOption):
(WebCore::AccessibilityListBoxOption::parentObject):
(WebCore::AccessibilityListBoxOption::listBoxOptionParentNode):
* accessibility/AccessibilityMenuListPopup.cpp:
(WebCore::AccessibilityMenuListPopup::menuListOptionAccessibilityObject):
* accessibility/AccessibilityMockObject.cpp:
(WebCore::AccessibilityMockObject::AccessibilityMockObject):
* accessibility/AccessibilityMockObject.h:
* accessibility/AccessibilityNodeObject.cpp:
(WebCore::AccessibilityNodeObject::detach):
(WebCore::AccessibilityNodeObject::firstChild):
(WebCore::AccessibilityNodeObject::lastChild):
(WebCore::AccessibilityNodeObject::previousSibling):
(WebCore::AccessibilityNodeObject::nextSibling):
(WebCore::AccessibilityNodeObject::parentObject):
(WebCore::AccessibilityNodeObject::document):
(WebCore::AccessibilityNodeObject::anchorElement):
(WebCore::nativeActionElement):
(WebCore::AccessibilityNodeObject::actionElement):
(WebCore::AccessibilityNodeObject::mouseButtonListener):
(WebCore::AccessibilityNodeObject::labelForElement):
(WebCore::AccessibilityNodeObject::menuItemElementForMenu):
(WebCore::AccessibilityNodeObject::menuButtonForMenu):
* accessibility/AccessibilityObject.cpp:
(WebCore::AccessibilityObject::AccessibilityObject):
(WebCore::AccessibilityObject::detach):
(WebCore::AccessibilityObject::firstAccessibleObjectFromNode):
(WebCore::AccessibilityObject::findMatchingObjects):
(WebCore::renderListItemContainerForNode):
(WebCore::AccessibilityObject::accessibilityObjectForPosition):
(WebCore::AccessibilityObject::document):
(WebCore::AccessibilityObject::page):
(WebCore::AccessibilityObject::documentFrameView):
(WebCore::AccessibilityObject::anchorElementForNode):
(WebCore::AccessibilityObject::headingElementForNode):
(WebCore::AccessibilityObject::firstAnonymousBlockChild):
(WebCore::AccessibilityObject::element):
(WebCore::AccessibilityObject::focusedUIElement):
(WebCore::AccessibilityObject::scrollToMakeVisibleWithSubFocus):
* accessibility/AccessibilityObject.h:
(WebCore::AccessibilityObject::node):
(WebCore::AccessibilityObject::renderer):
(WebCore::AccessibilityObject::selectedRadioButton):
(WebCore::AccessibilityObject::selectedTabItem):
(WebCore::AccessibilityObject::accessibilityHitTest):
(WebCore::AccessibilityObject::firstChild):
(WebCore::AccessibilityObject::lastChild):
(WebCore::AccessibilityObject::previousSibling):
(WebCore::AccessibilityObject::nextSibling):
(WebCore::AccessibilityObject::parentObjectIfExists):
(WebCore::AccessibilityObject::observableObject):
(WebCore::AccessibilityObject::titleUIElement):
(WebCore::AccessibilityObject::correspondingLabelForControlElement):
(WebCore::AccessibilityObject::correspondingControlForLabelElement):
(WebCore::AccessibilityObject::scrollBar):
(WebCore::AccessibilityObject::anchorElement):
(WebCore::AccessibilityObject::actionElement):
(WebCore::AccessibilityObject::widget):
(WebCore::AccessibilityObject::widgetForAttachmentView):
(WebCore::AccessibilityObject::activeDescendant):
(WebCore::AccessibilityObject::mathRadicandObject):
(WebCore::AccessibilityObject::mathRootIndexObject):
(WebCore::AccessibilityObject::mathUnderObject):
(WebCore::AccessibilityObject::mathOverObject):
(WebCore::AccessibilityObject::mathNumeratorObject):
(WebCore::AccessibilityObject::mathDenominatorObject):
(WebCore::AccessibilityObject::mathBaseObject):
(WebCore::AccessibilityObject::mathSubscriptObject):
(WebCore::AccessibilityObject::mathSuperscriptObject):
(WebCore::AccessibilityObject::getScrollableAreaIfScrollable):
* accessibility/AccessibilityProgressIndicator.cpp:
(WebCore::AccessibilityProgressIndicator::progressElement):
(WebCore::AccessibilityProgressIndicator::meterElement):
* accessibility/AccessibilityRenderObject.cpp:
(WebCore::AccessibilityRenderObject::detach):
(WebCore::AccessibilityRenderObject::renderBoxModelObject):
(WebCore::AccessibilityRenderObject::firstChild):
(WebCore::AccessibilityRenderObject::lastChild):
(WebCore::startOfContinuations):
(WebCore::childBeforeConsideringContinuations):
(WebCore::AccessibilityRenderObject::previousSibling):
(WebCore::AccessibilityRenderObject::nextSibling):
(WebCore::nextContinuation):
(WebCore::AccessibilityRenderObject::renderParentObject):
(WebCore::AccessibilityRenderObject::parentObject):
(WebCore::AccessibilityRenderObject::anchorElement):
(WebCore::AccessibilityRenderObject::textUnderElement):
(WebCore::AccessibilityRenderObject::node):
(WebCore::AccessibilityRenderObject::labelElementContainer):
(WebCore::AccessibilityRenderObject::internalLinkElement):
(WebCore::AccessibilityRenderObject::titleUIElement):
(WebCore::AccessibilityRenderObject::setFocused):
(WebCore::AccessibilityRenderObject::topRenderer):
(WebCore::AccessibilityRenderObject::document):
(WebCore::AccessibilityRenderObject::widget):
(WebCore::AccessibilityRenderObject::accessibilityParentForImageMap):
(WebCore::AccessibilityRenderObject::documentFrameView):
(WebCore::AccessibilityRenderObject::widgetForAttachmentView):
(WebCore::AccessibilityRenderObject::rootEditableElementForPosition):
(WebCore::AccessibilityRenderObject::visiblePositionForPoint):
(WebCore::AccessibilityRenderObject::accessibilityImageMapHitTest):
(WebCore::AccessibilityRenderObject::remoteSVGElementHitTest):
(WebCore::AccessibilityRenderObject::accessibilityHitTest):
(WebCore::AccessibilityRenderObject::correspondingControlForLabelElement):
(WebCore::AccessibilityRenderObject::correspondingLabelForControlElement):
(WebCore::AccessibilityRenderObject::observableObject):
(WebCore::AccessibilityRenderObject::inheritsPresentationalRole):
(WebCore::AccessibilityRenderObject::detachRemoteSVGRoot):
(WebCore::AccessibilityRenderObject::addHiddenChildren):
(WebCore::AccessibilityRenderObject::setAccessibleName):
(WebCore::AccessibilityRenderObject::getScrollableAreaIfScrollable):
(WebCore::AccessibilityRenderObject::mathRadicandObject):
(WebCore::AccessibilityRenderObject::mathRootIndexObject):
(WebCore::AccessibilityRenderObject::mathNumeratorObject):
(WebCore::AccessibilityRenderObject::mathDenominatorObject):
(WebCore::AccessibilityRenderObject::mathUnderObject):
(WebCore::AccessibilityRenderObject::mathOverObject):
(WebCore::AccessibilityRenderObject::mathBaseObject):
(WebCore::AccessibilityRenderObject::mathSubscriptObject):
(WebCore::AccessibilityRenderObject::mathSuperscriptObject):
* accessibility/AccessibilitySVGRoot.cpp:
(WebCore::AccessibilitySVGRoot::AccessibilitySVGRoot):
* accessibility/AccessibilityScrollView.cpp:
(WebCore::AccessibilityScrollView::detach):
(WebCore::AccessibilityScrollView::scrollBar):
(WebCore::AccessibilityScrollView::updateScrollbars):
(WebCore::AccessibilityScrollView::addChildScrollbar):
(WebCore::AccessibilityScrollView::clearChildren):
(WebCore::AccessibilityScrollView::webAreaObject):
(WebCore::AccessibilityScrollView::accessibilityHitTest):
(WebCore::AccessibilityScrollView::documentFrameView):
(WebCore::AccessibilityScrollView::parentObject):
(WebCore::AccessibilityScrollView::parentObjectIfExists):
* accessibility/AccessibilityScrollbar.cpp:
(WebCore::AccessibilityScrollbar::document):
* accessibility/AccessibilitySpinButton.cpp:
(WebCore::AccessibilitySpinButton::AccessibilitySpinButton):
* accessibility/AccessibilityTable.cpp:
(WebCore::AccessibilityTable::AccessibilityTable):
(WebCore::AccessibilityTable::clearChildren):
(WebCore::AccessibilityTable::cellForColumnAndRow):
* accessibility/AccessibilityTableCell.cpp:
(WebCore::AccessibilityTableCell::parentTable):
(WebCore::AccessibilityTableCell::titleUIElement):
* accessibility/AccessibilityTableColumn.cpp:
(WebCore::AccessibilityTableColumn::headerObject):
(WebCore::AccessibilityTableColumn::headerObjectForSection):
* accessibility/AccessibilityTableRow.cpp:
(WebCore::AccessibilityTableRow::parentTable):
(WebCore::AccessibilityTableRow::headerObject):
* accessibility/ios/AXObjectCacheIOS.mm:
(WebCore::AXObjectCache::detachWrapper):
* accessibility/ios/WebAccessibilityObjectWrapperIOS.mm:
(-[WebAccessibilityObjectWrapper detach]):
(-[WebAccessibilityObjectWrapper tableCellParent]):
(-[WebAccessibilityObjectWrapper tableParent]):
(-[WebAccessibilityObjectWrapper convertPointToScreenSpace:]):
(-[WebAccessibilityObjectWrapper convertRectToScreenSpace:]):
(rendererForView):
(-[WebAccessibilityObjectWrapper _convertToDOMRange:]):
* accessibility/mac/AXObjectCacheMac.mm:
(WebCore::AXObjectCache::detachWrapper):
* accessibility/mac/AccessibilityObjectMac.mm:
(WebCore::AccessibilityObject::detachFromParent):
(WebCore::AccessibilityObject::accessibilityIgnoreAttachment):
* accessibility/mac/WebAccessibilityObjectWrapperBase.mm:
(-[WebAccessibilityObjectWrapperBase detach]):
* accessibility/mac/WebAccessibilityObjectWrapperMac.mm:
(CreateCGColorIfDifferent):
(-[WebAccessibilityObjectWrapper convertPointToScreenSpace:]):
(rendererForView):
(-[WebAccessibilityObjectWrapper accessibilityAttributeValue:forParameter:]):
* accessibility/win/AccessibilityObjectWrapperWin.h:
(WebCore::AccessibilityObjectWrapper::AccessibilityObjectWrapper):

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@171477 268f45cc-cd09-0410-ab3c-d52691b4dbfc

30 files changed:
Source/WebCore/ChangeLog
Source/WebCore/accessibility/AXObjectCache.cpp
Source/WebCore/accessibility/AXObjectCache.h
Source/WebCore/accessibility/AccessibilityARIAGridRow.cpp
Source/WebCore/accessibility/AccessibilityImageMapLink.cpp
Source/WebCore/accessibility/AccessibilityListBox.cpp
Source/WebCore/accessibility/AccessibilityListBoxOption.cpp
Source/WebCore/accessibility/AccessibilityMenuListPopup.cpp
Source/WebCore/accessibility/AccessibilityMockObject.cpp
Source/WebCore/accessibility/AccessibilityMockObject.h
Source/WebCore/accessibility/AccessibilityNodeObject.cpp
Source/WebCore/accessibility/AccessibilityObject.cpp
Source/WebCore/accessibility/AccessibilityObject.h
Source/WebCore/accessibility/AccessibilityProgressIndicator.cpp
Source/WebCore/accessibility/AccessibilityRenderObject.cpp
Source/WebCore/accessibility/AccessibilitySVGRoot.cpp
Source/WebCore/accessibility/AccessibilityScrollView.cpp
Source/WebCore/accessibility/AccessibilityScrollbar.cpp
Source/WebCore/accessibility/AccessibilitySpinButton.cpp
Source/WebCore/accessibility/AccessibilityTable.cpp
Source/WebCore/accessibility/AccessibilityTableCell.cpp
Source/WebCore/accessibility/AccessibilityTableColumn.cpp
Source/WebCore/accessibility/AccessibilityTableRow.cpp
Source/WebCore/accessibility/ios/AXObjectCacheIOS.mm
Source/WebCore/accessibility/ios/WebAccessibilityObjectWrapperIOS.mm
Source/WebCore/accessibility/mac/AXObjectCacheMac.mm
Source/WebCore/accessibility/mac/AccessibilityObjectMac.mm
Source/WebCore/accessibility/mac/WebAccessibilityObjectWrapperBase.mm
Source/WebCore/accessibility/mac/WebAccessibilityObjectWrapperMac.mm
Source/WebCore/accessibility/win/AccessibilityObjectWrapperWin.h

index 6b0f521..f1d2fe6 100644 (file)
@@ -1,3 +1,210 @@
+2014-07-23  Myles C. Maxfield  <mmaxfield@apple.com>
+
+        Migrate accessibility/ to using nullptr instead of 0
+        https://bugs.webkit.org/show_bug.cgi?id=135185
+
+        Reviewed by Simon Fraser.
+
+        No new tests because there is no behavior change.
+
+        * accessibility/AXObjectCache.cpp:
+        (WebCore::AXObjectCache::focusedImageMapUIElement):
+        (WebCore::AXObjectCache::focusedUIElementForPage):
+        (WebCore::AXObjectCache::get):
+        (WebCore::AXObjectCache::getOrCreate):
+        (WebCore::AXObjectCache::rootObject):
+        (WebCore::AXObjectCache::rootObjectForFrame):
+        * accessibility/AXObjectCache.h:
+        (WebCore::AXObjectCache::focusedUIElementForPage):
+        (WebCore::AXObjectCache::get):
+        (WebCore::AXObjectCache::getOrCreate):
+        (WebCore::AXObjectCache::rootObject):
+        (WebCore::AXObjectCache::rootObjectForFrame):
+        (WebCore::AXObjectCache::rootAXEditableElement):
+        * accessibility/AccessibilityARIAGridRow.cpp:
+        (WebCore::AccessibilityARIAGridRow::disclosedByRow):
+        * accessibility/AccessibilityImageMapLink.cpp:
+        (WebCore::AccessibilityImageMapLink::AccessibilityImageMapLink):
+        (WebCore::AccessibilityImageMapLink::parentObject):
+        * accessibility/AccessibilityListBox.cpp:
+        (WebCore::AccessibilityListBox::listBoxOptionAccessibilityObject):
+        (WebCore::AccessibilityListBox::elementAccessibilityHitTest):
+        * accessibility/AccessibilityListBoxOption.cpp:
+        (WebCore::AccessibilityListBoxOption::AccessibilityListBoxOption):
+        (WebCore::AccessibilityListBoxOption::parentObject):
+        (WebCore::AccessibilityListBoxOption::listBoxOptionParentNode):
+        * accessibility/AccessibilityMenuListPopup.cpp:
+        (WebCore::AccessibilityMenuListPopup::menuListOptionAccessibilityObject):
+        * accessibility/AccessibilityMockObject.cpp:
+        (WebCore::AccessibilityMockObject::AccessibilityMockObject):
+        * accessibility/AccessibilityMockObject.h:
+        * accessibility/AccessibilityNodeObject.cpp:
+        (WebCore::AccessibilityNodeObject::detach):
+        (WebCore::AccessibilityNodeObject::firstChild):
+        (WebCore::AccessibilityNodeObject::lastChild):
+        (WebCore::AccessibilityNodeObject::previousSibling):
+        (WebCore::AccessibilityNodeObject::nextSibling):
+        (WebCore::AccessibilityNodeObject::parentObject):
+        (WebCore::AccessibilityNodeObject::document):
+        (WebCore::AccessibilityNodeObject::anchorElement):
+        (WebCore::nativeActionElement):
+        (WebCore::AccessibilityNodeObject::actionElement):
+        (WebCore::AccessibilityNodeObject::mouseButtonListener):
+        (WebCore::AccessibilityNodeObject::labelForElement):
+        (WebCore::AccessibilityNodeObject::menuItemElementForMenu):
+        (WebCore::AccessibilityNodeObject::menuButtonForMenu):
+        * accessibility/AccessibilityObject.cpp:
+        (WebCore::AccessibilityObject::AccessibilityObject):
+        (WebCore::AccessibilityObject::detach):
+        (WebCore::AccessibilityObject::firstAccessibleObjectFromNode):
+        (WebCore::AccessibilityObject::findMatchingObjects):
+        (WebCore::renderListItemContainerForNode):
+        (WebCore::AccessibilityObject::accessibilityObjectForPosition):
+        (WebCore::AccessibilityObject::document):
+        (WebCore::AccessibilityObject::page):
+        (WebCore::AccessibilityObject::documentFrameView):
+        (WebCore::AccessibilityObject::anchorElementForNode):
+        (WebCore::AccessibilityObject::headingElementForNode):
+        (WebCore::AccessibilityObject::firstAnonymousBlockChild):
+        (WebCore::AccessibilityObject::element):
+        (WebCore::AccessibilityObject::focusedUIElement):
+        (WebCore::AccessibilityObject::scrollToMakeVisibleWithSubFocus):
+        * accessibility/AccessibilityObject.h:
+        (WebCore::AccessibilityObject::node):
+        (WebCore::AccessibilityObject::renderer):
+        (WebCore::AccessibilityObject::selectedRadioButton):
+        (WebCore::AccessibilityObject::selectedTabItem):
+        (WebCore::AccessibilityObject::accessibilityHitTest):
+        (WebCore::AccessibilityObject::firstChild):
+        (WebCore::AccessibilityObject::lastChild):
+        (WebCore::AccessibilityObject::previousSibling):
+        (WebCore::AccessibilityObject::nextSibling):
+        (WebCore::AccessibilityObject::parentObjectIfExists):
+        (WebCore::AccessibilityObject::observableObject):
+        (WebCore::AccessibilityObject::titleUIElement):
+        (WebCore::AccessibilityObject::correspondingLabelForControlElement):
+        (WebCore::AccessibilityObject::correspondingControlForLabelElement):
+        (WebCore::AccessibilityObject::scrollBar):
+        (WebCore::AccessibilityObject::anchorElement):
+        (WebCore::AccessibilityObject::actionElement):
+        (WebCore::AccessibilityObject::widget):
+        (WebCore::AccessibilityObject::widgetForAttachmentView):
+        (WebCore::AccessibilityObject::activeDescendant):
+        (WebCore::AccessibilityObject::mathRadicandObject):
+        (WebCore::AccessibilityObject::mathRootIndexObject):
+        (WebCore::AccessibilityObject::mathUnderObject):
+        (WebCore::AccessibilityObject::mathOverObject):
+        (WebCore::AccessibilityObject::mathNumeratorObject):
+        (WebCore::AccessibilityObject::mathDenominatorObject):
+        (WebCore::AccessibilityObject::mathBaseObject):
+        (WebCore::AccessibilityObject::mathSubscriptObject):
+        (WebCore::AccessibilityObject::mathSuperscriptObject):
+        (WebCore::AccessibilityObject::getScrollableAreaIfScrollable):
+        * accessibility/AccessibilityProgressIndicator.cpp:
+        (WebCore::AccessibilityProgressIndicator::progressElement):
+        (WebCore::AccessibilityProgressIndicator::meterElement):
+        * accessibility/AccessibilityRenderObject.cpp:
+        (WebCore::AccessibilityRenderObject::detach):
+        (WebCore::AccessibilityRenderObject::renderBoxModelObject):
+        (WebCore::AccessibilityRenderObject::firstChild):
+        (WebCore::AccessibilityRenderObject::lastChild):
+        (WebCore::startOfContinuations):
+        (WebCore::childBeforeConsideringContinuations):
+        (WebCore::AccessibilityRenderObject::previousSibling):
+        (WebCore::AccessibilityRenderObject::nextSibling):
+        (WebCore::nextContinuation):
+        (WebCore::AccessibilityRenderObject::renderParentObject):
+        (WebCore::AccessibilityRenderObject::parentObject):
+        (WebCore::AccessibilityRenderObject::anchorElement):
+        (WebCore::AccessibilityRenderObject::textUnderElement):
+        (WebCore::AccessibilityRenderObject::node):
+        (WebCore::AccessibilityRenderObject::labelElementContainer):
+        (WebCore::AccessibilityRenderObject::internalLinkElement):
+        (WebCore::AccessibilityRenderObject::titleUIElement):
+        (WebCore::AccessibilityRenderObject::setFocused):
+        (WebCore::AccessibilityRenderObject::topRenderer):
+        (WebCore::AccessibilityRenderObject::document):
+        (WebCore::AccessibilityRenderObject::widget):
+        (WebCore::AccessibilityRenderObject::accessibilityParentForImageMap):
+        (WebCore::AccessibilityRenderObject::documentFrameView):
+        (WebCore::AccessibilityRenderObject::widgetForAttachmentView):
+        (WebCore::AccessibilityRenderObject::rootEditableElementForPosition):
+        (WebCore::AccessibilityRenderObject::visiblePositionForPoint):
+        (WebCore::AccessibilityRenderObject::accessibilityImageMapHitTest):
+        (WebCore::AccessibilityRenderObject::remoteSVGElementHitTest):
+        (WebCore::AccessibilityRenderObject::accessibilityHitTest):
+        (WebCore::AccessibilityRenderObject::correspondingControlForLabelElement):
+        (WebCore::AccessibilityRenderObject::correspondingLabelForControlElement):
+        (WebCore::AccessibilityRenderObject::observableObject):
+        (WebCore::AccessibilityRenderObject::inheritsPresentationalRole):
+        (WebCore::AccessibilityRenderObject::detachRemoteSVGRoot):
+        (WebCore::AccessibilityRenderObject::addHiddenChildren):
+        (WebCore::AccessibilityRenderObject::setAccessibleName):
+        (WebCore::AccessibilityRenderObject::getScrollableAreaIfScrollable):
+        (WebCore::AccessibilityRenderObject::mathRadicandObject):
+        (WebCore::AccessibilityRenderObject::mathRootIndexObject):
+        (WebCore::AccessibilityRenderObject::mathNumeratorObject):
+        (WebCore::AccessibilityRenderObject::mathDenominatorObject):
+        (WebCore::AccessibilityRenderObject::mathUnderObject):
+        (WebCore::AccessibilityRenderObject::mathOverObject):
+        (WebCore::AccessibilityRenderObject::mathBaseObject):
+        (WebCore::AccessibilityRenderObject::mathSubscriptObject):
+        (WebCore::AccessibilityRenderObject::mathSuperscriptObject):
+        * accessibility/AccessibilitySVGRoot.cpp:
+        (WebCore::AccessibilitySVGRoot::AccessibilitySVGRoot):
+        * accessibility/AccessibilityScrollView.cpp:
+        (WebCore::AccessibilityScrollView::detach):
+        (WebCore::AccessibilityScrollView::scrollBar):
+        (WebCore::AccessibilityScrollView::updateScrollbars):
+        (WebCore::AccessibilityScrollView::addChildScrollbar):
+        (WebCore::AccessibilityScrollView::clearChildren):
+        (WebCore::AccessibilityScrollView::webAreaObject):
+        (WebCore::AccessibilityScrollView::accessibilityHitTest):
+        (WebCore::AccessibilityScrollView::documentFrameView):
+        (WebCore::AccessibilityScrollView::parentObject):
+        (WebCore::AccessibilityScrollView::parentObjectIfExists):
+        * accessibility/AccessibilityScrollbar.cpp:
+        (WebCore::AccessibilityScrollbar::document):
+        * accessibility/AccessibilitySpinButton.cpp:
+        (WebCore::AccessibilitySpinButton::AccessibilitySpinButton):
+        * accessibility/AccessibilityTable.cpp:
+        (WebCore::AccessibilityTable::AccessibilityTable):
+        (WebCore::AccessibilityTable::clearChildren):
+        (WebCore::AccessibilityTable::cellForColumnAndRow):
+        * accessibility/AccessibilityTableCell.cpp:
+        (WebCore::AccessibilityTableCell::parentTable):
+        (WebCore::AccessibilityTableCell::titleUIElement):
+        * accessibility/AccessibilityTableColumn.cpp:
+        (WebCore::AccessibilityTableColumn::headerObject):
+        (WebCore::AccessibilityTableColumn::headerObjectForSection):
+        * accessibility/AccessibilityTableRow.cpp:
+        (WebCore::AccessibilityTableRow::parentTable):
+        (WebCore::AccessibilityTableRow::headerObject):
+        * accessibility/ios/AXObjectCacheIOS.mm:
+        (WebCore::AXObjectCache::detachWrapper):
+        * accessibility/ios/WebAccessibilityObjectWrapperIOS.mm:
+        (-[WebAccessibilityObjectWrapper detach]):
+        (-[WebAccessibilityObjectWrapper tableCellParent]):
+        (-[WebAccessibilityObjectWrapper tableParent]):
+        (-[WebAccessibilityObjectWrapper convertPointToScreenSpace:]):
+        (-[WebAccessibilityObjectWrapper convertRectToScreenSpace:]):
+        (rendererForView):
+        (-[WebAccessibilityObjectWrapper _convertToDOMRange:]):
+        * accessibility/mac/AXObjectCacheMac.mm:
+        (WebCore::AXObjectCache::detachWrapper):
+        * accessibility/mac/AccessibilityObjectMac.mm:
+        (WebCore::AccessibilityObject::detachFromParent):
+        (WebCore::AccessibilityObject::accessibilityIgnoreAttachment):
+        * accessibility/mac/WebAccessibilityObjectWrapperBase.mm:
+        (-[WebAccessibilityObjectWrapperBase detach]):
+        * accessibility/mac/WebAccessibilityObjectWrapperMac.mm:
+        (CreateCGColorIfDifferent):
+        (-[WebAccessibilityObjectWrapper convertPointToScreenSpace:]):
+        (rendererForView):
+        (-[WebAccessibilityObjectWrapper accessibilityAttributeValue:forParameter:]):
+        * accessibility/win/AccessibilityObjectWrapperWin.h:
+        (WebCore::AccessibilityObjectWrapper::AccessibilityObjectWrapper):
+
 2014-07-23  Mihnea Ovidenie  <mihnea@adobe.com>
 
         ASSERTION FAILED: generatingElement() in WebCore::RenderNamedFlowFragment::regionOversetState
index f194810..c31d642 100644 (file)
@@ -145,15 +145,15 @@ AccessibilityObject* AXObjectCache::focusedImageMapUIElement(HTMLAreaElement* ar
     // Find the corresponding accessibility object for the HTMLAreaElement. This should be
     // in the list of children for its corresponding image.
     if (!areaElement)
-        return 0;
+        return nullptr;
     
     HTMLImageElement* imageElement = areaElement->imageElement();
     if (!imageElement)
-        return 0;
+        return nullptr;
     
     AccessibilityObject* axRenderImage = areaElement->document().axObjectCache()->getOrCreate(imageElement);
     if (!axRenderImage)
-        return 0;
+        return nullptr;
     
     for (const auto& child : axRenderImage->children()) {
         if (!child->isImageMapLink())
@@ -163,13 +163,13 @@ AccessibilityObject* AXObjectCache::focusedImageMapUIElement(HTMLAreaElement* ar
             return child.get();
     }    
     
-    return 0;
+    return nullptr;
 }
     
 AccessibilityObject* AXObjectCache::focusedUIElementForPage(const Page* page)
 {
     if (!gAccessibilityEnabled)
-        return 0;
+        return nullptr;
 
     // get the focused node in the page
     Document* focusedDocument = page->focusController().focusedOrMainFrame().document();
@@ -179,7 +179,7 @@ AccessibilityObject* AXObjectCache::focusedUIElementForPage(const Page* page)
 
     AccessibilityObject* obj = focusedDocument->axObjectCache()->getOrCreate(focusedElement ? static_cast<Node*>(focusedElement) : focusedDocument);
     if (!obj)
-        return 0;
+        return nullptr;
 
     if (obj->shouldFocusActiveDescendant()) {
         if (AccessibilityObject* descendant = obj->activeDescendant())
@@ -196,12 +196,12 @@ AccessibilityObject* AXObjectCache::focusedUIElementForPage(const Page* page)
 AccessibilityObject* AXObjectCache::get(Widget* widget)
 {
     if (!widget)
-        return 0;
+        return nullptr;
         
     AXID axID = m_widgetObjectMapping.get(widget);
     ASSERT(!HashTraits<AXID>::isDeletedValue(axID));
     if (!axID)
-        return 0;
+        return nullptr;
     
     return m_objects.get(axID);    
 }
@@ -209,12 +209,12 @@ AccessibilityObject* AXObjectCache::get(Widget* widget)
 AccessibilityObject* AXObjectCache::get(RenderObject* renderer)
 {
     if (!renderer)
-        return 0;
+        return nullptr;
     
     AXID axID = m_renderObjectMapping.get(renderer);
     ASSERT(!HashTraits<AXID>::isDeletedValue(axID));
     if (!axID)
-        return 0;
+        return nullptr;
 
     return m_objects.get(axID);    
 }
@@ -222,7 +222,7 @@ AccessibilityObject* AXObjectCache::get(RenderObject* renderer)
 AccessibilityObject* AXObjectCache::get(Node* node)
 {
     if (!node)
-        return 0;
+        return nullptr;
 
     AXID renderID = node->renderer() ? m_renderObjectMapping.get(node->renderer()) : 0;
     ASSERT(!HashTraits<AXID>::isDeletedValue(renderID));
@@ -235,14 +235,14 @@ AccessibilityObject* AXObjectCache::get(Node* node)
         // rendered, but later something changes and it gets a renderer (like if it's
         // reparented).
         remove(nodeID);
-        return 0;
+        return nullptr;
     }
 
     if (renderID)
         return m_objects.get(renderID);
 
     if (!nodeID)
-        return 0;
+        return nullptr;
 
     return m_objects.get(nodeID);
 }
@@ -335,12 +335,12 @@ static PassRefPtr<AccessibilityObject> createFromNode(Node* node)
 AccessibilityObject* AXObjectCache::getOrCreate(Widget* widget)
 {
     if (!widget)
-        return 0;
+        return nullptr;
 
     if (AccessibilityObject* obj = get(widget))
         return obj;
     
-    RefPtr<AccessibilityObject> newObj = 0;
+    RefPtr<AccessibilityObject> newObj = nullptr;
     if (widget->isFrameView())
         newObj = AccessibilityScrollView::create(toScrollView(widget));
     else if (widget->isScrollbar())
@@ -352,7 +352,7 @@ AccessibilityObject* AXObjectCache::getOrCreate(Widget* widget)
     // Catch the case if an (unsupported) widget type is used. Only FrameView and ScrollBar are supported now.
     ASSERT(newObj);
     if (!newObj)
-        return 0;
+        return nullptr;
 
     getAXID(newObj.get());
     
@@ -366,7 +366,7 @@ AccessibilityObject* AXObjectCache::getOrCreate(Widget* widget)
 AccessibilityObject* AXObjectCache::getOrCreate(Node* node)
 {
     if (!node)
-        return 0;
+        return nullptr;
 
     if (AccessibilityObject* obj = get(node))
         return obj;
@@ -375,7 +375,7 @@ AccessibilityObject* AXObjectCache::getOrCreate(Node* node)
         return getOrCreate(node->renderer());
 
     if (!node->parentElement())
-        return 0;
+        return nullptr;
     
     // It's only allowed to create an AccessibilityObject from a Node if it's in a canvas subtree.
     // Or if it's a hidden element, but we still want to expose it because of other ARIA attributes.
@@ -388,7 +388,7 @@ AccessibilityObject* AXObjectCache::getOrCreate(Node* node)
 #endif
     
     if (!inCanvasSubtree && !isHidden && !insideMeterElement)
-        return 0;
+        return nullptr;
 
     RefPtr<AccessibilityObject> newObj = createFromNode(node);
 
@@ -413,7 +413,7 @@ AccessibilityObject* AXObjectCache::getOrCreate(Node* node)
 AccessibilityObject* AXObjectCache::getOrCreate(RenderObject* renderer)
 {
     if (!renderer)
-        return 0;
+        return nullptr;
 
     if (AccessibilityObject* obj = get(renderer))
         return obj;
@@ -441,7 +441,7 @@ AccessibilityObject* AXObjectCache::getOrCreate(RenderObject* renderer)
 AccessibilityObject* AXObjectCache::rootObject()
 {
     if (!gAccessibilityEnabled)
-        return 0;
+        return nullptr;
 
     return getOrCreate(m_document.view());
 }
@@ -449,16 +449,16 @@ AccessibilityObject* AXObjectCache::rootObject()
 AccessibilityObject* AXObjectCache::rootObjectForFrame(Frame* frame)
 {
     if (!gAccessibilityEnabled)
-        return 0;
+        return nullptr;
 
     if (!frame)
-        return 0;
+        return nullptr;
     return getOrCreate(frame->view());
 }    
     
 AccessibilityObject* AXObjectCache::getOrCreate(AccessibilityRole role)
 {
-    RefPtr<AccessibilityObject> obj = 0;
+    RefPtr<AccessibilityObject> obj = nullptr;
     
     // will be filled in...
     switch (role) {
@@ -490,13 +490,13 @@ AccessibilityObject* AXObjectCache::getOrCreate(AccessibilityRole role)
         obj = AccessibilitySpinButtonPart::create();
         break;
     default:
-        obj = 0;
+        obj = nullptr;
     }
     
     if (obj)
         getAXID(obj.get());
     else
-        return 0;
+        return nullptr;
 
     m_objects.set(obj->axObjectID(), obj);    
     obj->init();
index fde561f..a4ebd03 100644 (file)
@@ -272,22 +272,22 @@ inline AccessibilityObjectInclusion AXComputedObjectAttributeCache::getIgnored(A
 inline void AXComputedObjectAttributeCache::setIgnored(AXID, AccessibilityObjectInclusion) { }
 inline AXObjectCache::AXObjectCache(Document& document) : m_document(document), m_notificationPostTimer(this, (Timer<AXObjectCache>::TimerFiredFunction) nullptr) { }
 inline AXObjectCache::~AXObjectCache() { }
-inline AccessibilityObject* AXObjectCache::focusedUIElementForPage(const Page*) { return 0; }
-inline AccessibilityObject* AXObjectCache::get(RenderObject*) { return 0; }
-inline AccessibilityObject* AXObjectCache::get(Node*) { return 0; }
-inline AccessibilityObject* AXObjectCache::get(Widget*) { return 0; }
-inline AccessibilityObject* AXObjectCache::getOrCreate(AccessibilityRole) { return 0; }
-inline AccessibilityObject* AXObjectCache::getOrCreate(RenderObject*) { return 0; }
-inline AccessibilityObject* AXObjectCache::getOrCreate(Node*) { return 0; }
-inline AccessibilityObject* AXObjectCache::getOrCreate(Widget*) { return 0; }
-inline AccessibilityObject* AXObjectCache::rootObject() { return 0; }
-inline AccessibilityObject* AXObjectCache::rootObjectForFrame(Frame*) { return 0; }
-inline Element* AXObjectCache::rootAXEditableElement(Node*) { return 0; }
+inline AccessibilityObject* AXObjectCache::focusedUIElementForPage(const Page*) { return nullptr; }
+inline AccessibilityObject* AXObjectCache::get(RenderObject*) { return nullptr; }
+inline AccessibilityObject* AXObjectCache::get(Node*) { return nullptr; }
+inline AccessibilityObject* AXObjectCache::get(Widget*) { return nullptr; }
+inline AccessibilityObject* AXObjectCache::getOrCreate(AccessibilityRole) { return nullptr; }
+inline AccessibilityObject* AXObjectCache::getOrCreate(RenderObject*) { return nullptr; }
+inline AccessibilityObject* AXObjectCache::getOrCreate(Node*) { return nullptr; }
+inline AccessibilityObject* AXObjectCache::getOrCreate(Widget*) { return nullptr; }
+inline AccessibilityObject* AXObjectCache::rootObject() { return nullptr; }
+inline AccessibilityObject* AXObjectCache::rootObjectForFrame(Frame*) { return nullptr; }
+inline Element* AXObjectCache::rootAXEditableElement(Node*) { return nullptr; }
 inline bool nodeHasRole(Node*, const String&) { return false; }
 inline void AXObjectCache::startCachingComputedObjectAttributesUntilTreeMutates() { }
 inline void AXObjectCache::stopCachingComputedObjectAttributes() { }
 inline bool isNodeAriaVisible(Node*) { return true; }
-inline const Element* AXObjectCache::rootAXEditableElement(const Node*) { return 0; }
+inline const Element* AXObjectCache::rootAXEditableElement(const Node*) { return nullptr; }
 inline void AXObjectCache::attachWrapper(AccessibilityObject*) { }
 inline void AXObjectCache::checkedStateChanged(Node*) { }
 inline void AXObjectCache::childrenChanged(RenderObject*, RenderObject*) { }
index c3fe0dd..9dfa0be 100644 (file)
@@ -91,19 +91,19 @@ AccessibilityObject* AccessibilityARIAGridRow::disclosedByRow() const
     // that is aria-level subtract 1 from this row.
     AccessibilityObject* parent = parentObjectUnignored();
     if (!parent || !parent->isAccessibilityTable())
-        return 0;
+        return nullptr;
     
     // If the level is 1 or less, than nothing discloses this row.
     unsigned level = hierarchicalLevel();
     if (level <= 1)
-        return 0;
+        return nullptr;
     
     // Search for the previous row that matches the correct level.
     int index = rowIndex();
     auto& allRows = toAccessibilityTable(parent)->rows();
     int rowCount = allRows.size();
     if (index >= rowCount)
-        return 0;
+        return nullptr;
     
     for (int k = index - 1; k >= 0; --k) {
         AccessibilityObject* row = allRows[k].get();
index 4af0ccf..abc00db 100644 (file)
@@ -40,8 +40,8 @@ namespace WebCore {
 using namespace HTMLNames;
 
 AccessibilityImageMapLink::AccessibilityImageMapLink()
-    : m_areaElement(0)
-    , m_mapElement(0)
+    : m_areaElement(nullptr)
+    , m_mapElement(nullptr)
 {
 }
 
@@ -60,7 +60,7 @@ AccessibilityObject* AccessibilityImageMapLink::parentObject() const
         return m_parent;
     
     if (!m_mapElement.get() || !m_mapElement->renderer())
-        return 0;
+        return nullptr;
     
     return m_mapElement->document().axObjectCache()->getOrCreate(m_mapElement->renderer());
 }
index 70cf407..62b934d 100644 (file)
@@ -136,7 +136,7 @@ AccessibilityObject* AccessibilityListBox::listBoxOptionAccessibilityObject(HTML
 {
     // skip hr elements
     if (!element || element->hasTagName(hrTag))
-        return 0;
+        return nullptr;
     
     AccessibilityObject* listBoxObject = m_renderer->document().axObjectCache()->getOrCreate(ListBoxOptionRole);
     toAccessibilityListBoxOption(listBoxObject)->setHTMLElement(element);
@@ -149,15 +149,15 @@ AccessibilityObject* AccessibilityListBox::elementAccessibilityHitTest(const Int
     // the internal HTMLSelectElement methods for returning a listbox option at a point
     // ignore optgroup elements.
     if (!m_renderer)
-        return 0;
+        return nullptr;
     
     Node* node = m_renderer->node();
     if (!node)
-        return 0;
+        return nullptr;
     
     LayoutRect parentRect = boundingBoxRect();
     
-    AccessibilityObject* listBoxOption = 0;
+    AccessibilityObject* listBoxOption = nullptr;
     unsigned length = m_children.size();
     for (unsigned i = 0; i < length; i++) {
         LayoutRect rect = toRenderListBox(m_renderer)->itemBoundingBoxRect(parentRect.location(), i);
index a5133fa..b7591d4 100644 (file)
@@ -46,7 +46,7 @@ namespace WebCore {
 using namespace HTMLNames;
     
 AccessibilityListBoxOption::AccessibilityListBoxOption()
-    : m_optionElement(0)
+    : m_optionElement(nullptr)
 {
 }
 
@@ -174,7 +174,7 @@ AccessibilityObject* AccessibilityListBoxOption::parentObject() const
 {
     HTMLSelectElement* parentNode = listBoxOptionParentNode();
     if (!parentNode)
-        return 0;
+        return nullptr;
     
     return m_optionElement->document().axObjectCache()->getOrCreate(parentNode);
 }
@@ -200,7 +200,7 @@ void AccessibilityListBoxOption::setSelected(bool selected)
 HTMLSelectElement* AccessibilityListBoxOption::listBoxOptionParentNode() const
 {
     if (!m_optionElement)
-        return 0;
+        return nullptr;
 
     if (isHTMLOptionElement(m_optionElement))
         return toHTMLOptionElement(m_optionElement)->ownerSelectElement();
@@ -208,7 +208,7 @@ HTMLSelectElement* AccessibilityListBoxOption::listBoxOptionParentNode() const
     if (isHTMLOptGroupElement(m_optionElement))
         return toHTMLOptGroupElement(m_optionElement)->ownerSelectElement();
 
-    return 0;
+    return nullptr;
 }
 
 int AccessibilityListBoxOption::listBoxOptionIndex() const
index 572092e..1d5219d 100644 (file)
@@ -71,7 +71,7 @@ bool AccessibilityMenuListPopup::computeAccessibilityIsIgnored() const
 AccessibilityMenuListOption* AccessibilityMenuListPopup::menuListOptionAccessibilityObject(HTMLElement* element) const
 {
     if (!element || !isHTMLOptionElement(element) || !element->inRenderedDocument())
-        return 0;
+        return nullptr;
 
     AccessibilityObject* object = document()->axObjectCache()->getOrCreate(MenuListOptionRole);
     ASSERT_WITH_SECURITY_IMPLICATION(object->isMenuListOption());
index f481561..0d804ce 100644 (file)
@@ -29,7 +29,7 @@
 namespace WebCore {
     
 AccessibilityMockObject::AccessibilityMockObject()
-    : m_parent(0)
+    : m_parent(nullptr)
 {
 }
 
index 985a219..e04fd7f 100644 (file)
@@ -45,7 +45,7 @@ protected:
     AccessibilityObject* m_parent;
 
     // Must be called when the parent object clears its children.
-    virtual void detachFromParent() override { m_parent = 0; }
+    virtual void detachFromParent() override { m_parent = nullptr; }
 
 private:
     virtual bool isMockObject() const override { return true; }
index 4ac32d3..b34fe96 100644 (file)
@@ -123,7 +123,7 @@ void AccessibilityNodeObject::detach(AccessibilityDetachmentType detachmentType,
 {
     // AccessibilityObject calls clearChildren.
     AccessibilityObject::detach(detachmentType, cache);
-    m_node = 0;
+    m_node = nullptr;
 }
 
 void AccessibilityNodeObject::childrenChanged()
@@ -170,12 +170,12 @@ void AccessibilityNodeObject::updateAccessibilityRole()
 AccessibilityObject* AccessibilityNodeObject::firstChild() const
 {
     if (!node())
-        return 0;
+        return nullptr;
     
     Node* firstChild = node()->firstChild();
 
     if (!firstChild)
-        return 0;
+        return nullptr;
     
     return axObjectCache()->getOrCreate(firstChild);
 }
@@ -183,11 +183,11 @@ AccessibilityObject* AccessibilityNodeObject::firstChild() const
 AccessibilityObject* AccessibilityNodeObject::lastChild() const
 {
     if (!node())
-        return 0;
+        return nullptr;
     
     Node* lastChild = node()->lastChild();
     if (!lastChild)
-        return 0;
+        return nullptr;
     
     return axObjectCache()->getOrCreate(lastChild);
 }
@@ -195,11 +195,11 @@ AccessibilityObject* AccessibilityNodeObject::lastChild() const
 AccessibilityObject* AccessibilityNodeObject::previousSibling() const
 {
     if (!node())
-        return 0;
+        return nullptr;
 
     Node* previousSibling = node()->previousSibling();
     if (!previousSibling)
-        return 0;
+        return nullptr;
 
     return axObjectCache()->getOrCreate(previousSibling);
 }
@@ -207,11 +207,11 @@ AccessibilityObject* AccessibilityNodeObject::previousSibling() const
 AccessibilityObject* AccessibilityNodeObject::nextSibling() const
 {
     if (!node())
-        return 0;
+        return nullptr;
 
     Node* nextSibling = node()->nextSibling();
     if (!nextSibling)
-        return 0;
+        return nullptr;
 
     return axObjectCache()->getOrCreate(nextSibling);
 }
@@ -224,7 +224,7 @@ AccessibilityObject* AccessibilityNodeObject::parentObjectIfExists() const
 AccessibilityObject* AccessibilityNodeObject::parentObject() const
 {
     if (!node())
-        return 0;
+        return nullptr;
 
     Node* parentObj = node()->parentNode();
     if (!parentObj)
@@ -233,7 +233,7 @@ AccessibilityObject* AccessibilityNodeObject::parentObject() const
     if (AXObjectCache* cache = axObjectCache())
         return cache->getOrCreate(parentObj);
     
-    return 0;
+    return nullptr;
 }
 
 LayoutRect AccessibilityNodeObject::elementRect() const
@@ -269,7 +269,7 @@ void AccessibilityNodeObject::setNode(Node* node)
 Document* AccessibilityNodeObject::document() const
 {
     if (!node())
-        return 0;
+        return nullptr;
     return &node()->document();
 }
 
@@ -961,7 +961,7 @@ Element* AccessibilityNodeObject::anchorElement() const
 {
     Node* node = this->node();
     if (!node)
-        return 0;
+        return nullptr;
 
     AXObjectCache* cache = axObjectCache();
 
@@ -972,7 +972,7 @@ Element* AccessibilityNodeObject::anchorElement() const
             return toElement(node);
     }
 
-    return 0;
+    return nullptr;
 }
 
 static bool isNodeActionElement(Node* node)
@@ -990,7 +990,7 @@ static bool isNodeActionElement(Node* node)
 static Element* nativeActionElement(Node* start)
 {
     if (!start)
-        return 0;
+        return nullptr;
     
     // Do a deep-dive to see if any nodes should be used as the action element.
     // We have to look at Nodes, since this method should only be called on objects that do not have children (like buttons).
@@ -1003,14 +1003,14 @@ static Element* nativeActionElement(Node* start)
         if (Element* subChild = nativeActionElement(child))
             return subChild;
     }
-    return 0;
+    return nullptr;
 }
     
 Element* AccessibilityNodeObject::actionElement() const
 {
     Node* node = this->node();
     if (!node)
-        return 0;
+        return nullptr;
 
     if (isNodeActionElement(node))
         return toElement(node);
@@ -1045,7 +1045,7 @@ Element* AccessibilityNodeObject::mouseButtonListener(MouseButtonListenerResultF
 {
     Node* node = this->node();
     if (!node)
-        return 0;
+        return nullptr;
 
     // check if our parent is a mouse button listener
     // FIXME: Do the continuation search like anchorElement does
@@ -1059,7 +1059,7 @@ Element* AccessibilityNodeObject::mouseButtonListener(MouseButtonListenerResultF
             return &element;
     }
 
-    return 0;
+    return nullptr;
 }
 
 bool AccessibilityNodeObject::isDescendantOfBarrenParent() const
@@ -1165,7 +1165,7 @@ bool AccessibilityNodeObject::isGenericFocusableElement() const
 HTMLLabelElement* AccessibilityNodeObject::labelForElement(Element* element) const
 {
     if (!element->isHTMLElement() || !toHTMLElement(element)->isLabelable())
-        return 0;
+        return nullptr;
 
     const AtomicString& id = element->getIdAttribute();
     if (!id.isEmpty()) {
@@ -1222,7 +1222,7 @@ AccessibilityObject* AccessibilityNodeObject::menuForMenuButton() const
 Element* AccessibilityNodeObject::menuItemElementForMenu() const
 {
     if (ariaRoleAttribute() != MenuRole)
-        return 0;
+        return nullptr;
     
     return siblingWithAriaRole("menuitem", node());    
 }
@@ -1241,7 +1241,7 @@ AccessibilityObject* AccessibilityNodeObject::menuButtonForMenu() const
         if (menuItemAX && menuItemAX->isMenuButton())
             return menuItemAX;
     }
-    return 0;
+    return nullptr;
 }
 
 bool AccessibilityNodeObject::usesAltTagForTextComputation() const
index 9566b26..938992a 100644 (file)
@@ -83,7 +83,7 @@ AccessibilityObject::AccessibilityObject()
     , m_role(UnknownRole)
     , m_lastKnownIsIgnoredValue(DefaultBehavior)
 #if PLATFORM(GTK) || (PLATFORM(EFL) && HAVE(ACCESSIBILITY))
-    , m_wrapper(0)
+    , m_wrapper(nullptr)
 #endif
 {
 }
@@ -104,7 +104,7 @@ void AccessibilityObject::detach(AccessibilityDetachmentType detachmentType, AXO
     clearChildren();
 
 #if HAVE(ACCESSIBILITY)
-    setWrapper(0);
+    setWrapper(nullptr);
 #endif
 }
 
@@ -380,7 +380,7 @@ AccessibilityObject* AccessibilityObject::parentObjectUnignored() const
 AccessibilityObject* AccessibilityObject::firstAccessibleObjectFromNode(const Node* node)
 {
     if (!node)
-        return 0;
+        return nullptr;
 
     AXObjectCache* cache = node->document().axObjectCache();
     if (!cache)
@@ -394,7 +394,7 @@ AccessibilityObject* AccessibilityObject::firstAccessibleObjectFromNode(const No
             node = NodeTraversal::nextSkippingChildren(node);
 
         if (!node)
-            return 0;
+            return nullptr;
 
         accessibleObject = cache->getOrCreate(node->renderer());
     }
@@ -487,7 +487,7 @@ void AccessibilityObject::findMatchingObjects(AccessibilitySearchCriteria* crite
     // The first iteration of the outer loop will examine the children of the start object for matches. However, when
     // iterating backwards, the start object children should not be considered, so the loop is skipped ahead. We make an
     // exception when no start object was specified because we want to search everything regardless of search direction.
-    AccessibilityObject* previousObject = 0;
+    AccessibilityObject* previousObject = nullptr;
     if (!isForward && startObject != this) {
         previousObject = startObject;
         startObject = startObject->parentObjectUnignored();
@@ -1070,7 +1070,7 @@ static RenderListItem* renderListItemContainerForNode(Node* node)
         if (renderer && renderer->isListItem())
             return toRenderListItem(renderer);
     }
-    return 0;
+    return nullptr;
 }
     
 // Returns the text associated with a list marker if this node is contained within a list item.
@@ -1326,11 +1326,11 @@ VisiblePosition AccessibilityObject::previousParagraphStartPosition(const Visibl
 AccessibilityObject* AccessibilityObject::accessibilityObjectForPosition(const VisiblePosition& visiblePos) const
 {
     if (visiblePos.isNull())
-        return 0;
+        return nullptr;
 
     RenderObject* obj = visiblePos.deepEquivalent().deprecatedNode()->renderer();
     if (!obj)
-        return 0;
+        return nullptr;
 
     return obj->document().axObjectCache()->getOrCreate(obj);
 }
@@ -1454,7 +1454,7 @@ Document* AccessibilityObject::document() const
 {
     FrameView* frameView = documentFrameView();
     if (!frameView)
-        return 0;
+        return nullptr;
     
     return frameView->frame().document();
 }
@@ -1463,7 +1463,7 @@ Page* AccessibilityObject::page() const
 {
     Document* document = this->document();
     if (!document)
-        return 0;
+        return nullptr;
     return document->page();
 }
 
@@ -1474,7 +1474,7 @@ FrameView* AccessibilityObject::documentFrameView() const
         object = object->parentObject();
         
     if (!object)
-        return 0;
+        return nullptr;
 
     return object->documentFrameView();
 }
@@ -1509,16 +1509,16 @@ AccessibilityObject* AccessibilityObject::anchorElementForNode(Node* node)
 {
     RenderObject* obj = node->renderer();
     if (!obj)
-        return 0;
+        return nullptr;
     
     RefPtr<AccessibilityObject> axObj = obj->document().axObjectCache()->getOrCreate(obj);
     Element* anchor = axObj->anchorElement();
     if (!anchor)
-        return 0;
+        return nullptr;
     
     RenderObject* anchorRenderer = anchor->renderer();
     if (!anchorRenderer)
-        return 0;
+        return nullptr;
     
     return anchorRenderer->document().axObjectCache()->getOrCreate(anchorRenderer);
 }
@@ -1526,11 +1526,11 @@ AccessibilityObject* AccessibilityObject::anchorElementForNode(Node* node)
 AccessibilityObject* AccessibilityObject::headingElementForNode(Node* node)
 {
     if (!node)
-        return 0;
+        return nullptr;
     
     RenderObject* renderObject = node->renderer();
     if (!renderObject)
-        return 0;
+        return nullptr;
     
     AccessibilityObject* axObject = renderObject->document().axObjectCache()->getOrCreate(renderObject);
     for (; axObject && axObject->roleValue() != HeadingRole; axObject = axObject->parentObject()) { }
@@ -1729,7 +1729,7 @@ AccessibilityObject* AccessibilityObject::firstAnonymousBlockChild() const
         if (child->renderer() && child->renderer()->isAnonymousBlock())
             return child;
     }
-    return 0;
+    return nullptr;
 }
 
 typedef HashMap<String, AccessibilityRole, CaseFoldingHash> ARIARoleMap;
@@ -1876,7 +1876,7 @@ Element* AccessibilityObject::element() const
     Node* node = this->node();
     if (node && node->isElementNode())
         return toElement(node);
-    return 0;
+    return nullptr;
 }
 
 const AtomicString& AccessibilityObject::placeholderValue() const
@@ -1964,11 +1964,11 @@ AccessibilityObject* AccessibilityObject::focusedUIElement() const
 {
     Document* doc = document();
     if (!doc)
-        return 0;
+        return nullptr;
     
     Page* page = doc->page();
     if (!page)
-        return 0;
+        return nullptr;
     
     return AXObjectCache::focusedUIElementForPage(page);
 }
@@ -2211,7 +2211,7 @@ void AccessibilityObject::scrollToMakeVisibleWithSubFocus(const IntRect& subfocu
     // Search up the parent chain until we find the first one that's scrollable.
     AccessibilityObject* scrollParent = parentObject();
     ScrollableArea* scrollableArea;
-    for (scrollableArea = 0;
+    for (scrollableArea = nullptr;
          scrollParent && !(scrollableArea = scrollParent->getScrollableAreaIfScrollable());
          scrollParent = scrollParent->parentObject()) { }
     if (!scrollableArea)
index 5c2b19d..6f46848 100644 (file)
@@ -556,8 +556,8 @@ public:
     virtual bool canSetExpandedAttribute() const { return false; }
     
     Element* element() const;
-    virtual Node* node() const { return 0; }
-    virtual RenderObject* renderer() const { return 0; }
+    virtual Node* node() const { return nullptr; }
+    virtual RenderObject* renderer() const { return nullptr; }
     virtual bool accessibilityIsIgnored() const;
     virtual AccessibilityObjectInclusion defaultObjectInclusion() const;
     bool accessibilityIsIgnoredByDefault() const;
@@ -571,8 +571,8 @@ public:
     virtual float maxValueForRange() const { return 0.0f; }
     virtual float minValueForRange() const { return 0.0f; }
     virtual float stepValueForRange() const { return 0.0f; }
-    virtual AccessibilityObject* selectedRadioButton() { return 0; }
-    virtual AccessibilityObject* selectedTabItem() { return 0; }    
+    virtual AccessibilityObject* selectedRadioButton() { return nullptr; }
+    virtual AccessibilityObject* selectedTabItem() { return nullptr; }
     virtual int layoutCount() const { return 0; }
     virtual double estimatedLoadingProgress() const { return 0; }
     static bool isARIAControl(AccessibilityRole);
@@ -610,19 +610,19 @@ public:
     virtual void determineARIADropEffects(Vector<String>&) { }
     
     // Called on the root AX object to return the deepest available element.
-    virtual AccessibilityObject* accessibilityHitTest(const IntPoint&) const { return 0; }
+    virtual AccessibilityObject* accessibilityHitTest(const IntPoint&) const { return nullptr; }
     // Called on the AX object after the render tree determines which is the right AccessibilityRenderObject.
     virtual AccessibilityObject* elementAccessibilityHitTest(const IntPoint&) const;
 
     virtual AccessibilityObject* focusedUIElement() const;
 
-    virtual AccessibilityObject* firstChild() const { return 0; }
-    virtual AccessibilityObject* lastChild() const { return 0; }
-    virtual AccessibilityObject* previousSibling() const { return 0; }
-    virtual AccessibilityObject* nextSibling() const { return 0; }
+    virtual AccessibilityObject* firstChild() const { return nullptr; }
+    virtual AccessibilityObject* lastChild() const { return nullptr; }
+    virtual AccessibilityObject* previousSibling() const { return nullptr; }
+    virtual AccessibilityObject* nextSibling() const { return nullptr; }
     virtual AccessibilityObject* parentObject() const = 0;
     virtual AccessibilityObject* parentObjectUnignored() const;
-    virtual AccessibilityObject* parentObjectIfExists() const { return 0; }
+    virtual AccessibilityObject* parentObjectIfExists() const { return nullptr; }
     static AccessibilityObject* firstAccessibleObjectFromNode(const Node*);
     void findMatchingObjects(AccessibilitySearchCriteria*, AccessibilityChildrenVector&);
     virtual bool isDescendantOfBarrenParent() const { return false; }
@@ -632,13 +632,13 @@ public:
     PassRefPtr<Range> selectionRange() const;
     String selectText(AccessibilitySelectTextCriteria*);
     
-    virtual AccessibilityObject* observableObject() const { return 0; }
+    virtual AccessibilityObject* observableObject() const { return nullptr; }
     virtual void linkedUIElements(AccessibilityChildrenVector&) const { }
-    virtual AccessibilityObject* titleUIElement() const { return 0; }
+    virtual AccessibilityObject* titleUIElement() const { return nullptr; }
     virtual bool exposesTitleUIElement() const { return true; }
-    virtual AccessibilityObject* correspondingLabelForControlElement() const { return 0; }
-    virtual AccessibilityObject* correspondingControlForLabelElement() const { return 0; }
-    virtual AccessibilityObject* scrollBar(AccessibilityOrientation) { return 0; }
+    virtual AccessibilityObject* correspondingLabelForControlElement() const { return nullptr; }
+    virtual AccessibilityObject* correspondingControlForLabelElement() const { return nullptr; }
+    virtual AccessibilityObject* scrollBar(AccessibilityOrientation) { return nullptr; }
     
     virtual AccessibilityRole ariaRoleAttribute() const { return UnknownRole; }
     virtual bool isPresentationalChildOfAriaRole() const { return false; }
@@ -683,8 +683,8 @@ public:
     
     static AccessibilityObject* anchorElementForNode(Node*);
     static AccessibilityObject* headingElementForNode(Node*);
-    virtual Element* anchorElement() const { return 0; }
-    virtual Element* actionElement() const { return 0; }
+    virtual Element* anchorElement() const { return nullptr; }
+    virtual Element* actionElement() const { return nullptr; }
     virtual LayoutRect boundingBoxRect() const { return LayoutRect(); }
     IntRect pixelSnappedBoundingBoxRect() const { return pixelSnappedIntRect(boundingBoxRect()); }
     virtual LayoutRect elementRect() const = 0;
@@ -706,8 +706,8 @@ public:
     virtual String selectedText() const { return String(); }
     virtual const AtomicString& accessKey() const { return nullAtom; }
     const String& actionVerb() const;
-    virtual Widget* widget() const { return 0; }
-    virtual Widget* widgetForAttachmentView() const { return 0; }
+    virtual Widget* widget() const { return nullptr; }
+    virtual Widget* widgetForAttachmentView() const { return nullptr; }
     Page* page() const;
     virtual Document* document() const;
     virtual FrameView* documentFrameView() const;
@@ -758,7 +758,7 @@ public:
     virtual void visibleChildren(AccessibilityChildrenVector&) { }
     virtual void tabChildren(AccessibilityChildrenVector&) { }
     virtual bool shouldFocusActiveDescendant() const { return false; }
-    virtual AccessibilityObject* activeDescendant() const { return 0; }    
+    virtual AccessibilityObject* activeDescendant() const { return nullptr; }
     virtual void handleActiveDescendantChanged() { }
     virtual void handleAriaExpandedChanged() { }
     bool isDescendantOfObject(const AccessibilityObject*) const;
@@ -891,21 +891,21 @@ public:
     virtual bool isMathMultiscript() const { return false; }
 
     // Root components.
-    virtual AccessibilityObject* mathRadicandObject() { return 0; }
-    virtual AccessibilityObject* mathRootIndexObject() { return 0; }
+    virtual AccessibilityObject* mathRadicandObject() { return nullptr; }
+    virtual AccessibilityObject* mathRootIndexObject() { return nullptr; }
     
     // Under over components.
-    virtual AccessibilityObject* mathUnderObject() { return 0; }
-    virtual AccessibilityObject* mathOverObject() { return 0; }
+    virtual AccessibilityObject* mathUnderObject() { return nullptr; }
+    virtual AccessibilityObject* mathOverObject() { return nullptr; }
 
     // Fraction components.
-    virtual AccessibilityObject* mathNumeratorObject() { return 0; }
-    virtual AccessibilityObject* mathDenominatorObject() { return 0; }
+    virtual AccessibilityObject* mathNumeratorObject() { return nullptr; }
+    virtual AccessibilityObject* mathDenominatorObject() { return nullptr; }
 
     // Subscript/superscript components.
-    virtual AccessibilityObject* mathBaseObject() { return 0; }
-    virtual AccessibilityObject* mathSubscriptObject() { return 0; }
-    virtual AccessibilityObject* mathSuperscriptObject() { return 0; }
+    virtual AccessibilityObject* mathBaseObject() { return nullptr; }
+    virtual AccessibilityObject* mathSubscriptObject() { return nullptr; }
+    virtual AccessibilityObject* mathSuperscriptObject() { return nullptr; }
     
     // Fenced components.
     virtual String mathFencedOpenString() const { return String(); }
@@ -969,7 +969,7 @@ protected:
     virtual bool computeAccessibilityIsIgnored() const { return true; }
 
     // If this object itself scrolls, return its ScrollableArea.
-    virtual ScrollableArea* getScrollableAreaIfScrollable() const { return 0; }
+    virtual ScrollableArea* getScrollableAreaIfScrollable() const { return nullptr; }
     virtual void scrollTo(const IntPoint&) const { }
 
     static bool isAccessibilityObjectSearchMatchAtIndex(AccessibilityObject*, AccessibilitySearchCriteria*, size_t);
index 781b293..b52bf78 100644 (file)
@@ -123,7 +123,7 @@ float AccessibilityProgressIndicator::minValueForRange() const
 HTMLProgressElement* AccessibilityProgressIndicator::progressElement() const
 {
     if (!m_renderer->isProgress())
-        return 0;
+        return nullptr;
     
     return toRenderProgress(m_renderer)->progressElement();
 }
@@ -132,7 +132,7 @@ HTMLProgressElement* AccessibilityProgressIndicator::progressElement() const
 HTMLMeterElement* AccessibilityProgressIndicator::meterElement() const
 {
     if (!m_renderer->isMeter())
-        return 0;
+        return nullptr;
 
     return toRenderMeter(m_renderer)->meterElement();
 }
index 5fe9d3d..67e05aa 100644 (file)
@@ -143,13 +143,13 @@ void AccessibilityRenderObject::detach(AccessibilityDetachmentType detachmentTyp
     if (m_renderer)
         m_renderer->setHasAXObject(false);
 #endif
-    m_renderer = 0;
+    m_renderer = nullptr;
 }
 
 RenderBoxModelObject* AccessibilityRenderObject::renderBoxModelObject() const
 {
     if (!m_renderer || !m_renderer->isBoxModelObject())
-        return 0;
+        return nullptr;
     return toRenderBoxModelObject(m_renderer);
 }
 
@@ -225,7 +225,7 @@ static inline RenderObject* lastChildConsideringContinuation(RenderObject* rende
 AccessibilityObject* AccessibilityRenderObject::firstChild() const
 {
     if (!m_renderer)
-        return 0;
+        return nullptr;
     
     RenderObject* firstChild = firstChildConsideringContinuation(m_renderer);
 
@@ -242,7 +242,7 @@ AccessibilityObject* AccessibilityRenderObject::firstChild() const
 AccessibilityObject* AccessibilityRenderObject::lastChild() const
 {
     if (!m_renderer)
-        return 0;
+        return nullptr;
 
     RenderObject* lastChild = lastChildConsideringContinuation(m_renderer);
 
@@ -261,7 +261,7 @@ static inline RenderInline* startOfContinuations(RenderObject* r)
     if (r->isRenderBlock() && toRenderBlock(r)->inlineElementContinuation())
         return toRenderInline(toRenderBlock(r)->inlineElementContinuation()->element()->renderer());
 
-    return 0;
+    return nullptr;
 }
 
 static inline RenderObject* endOfContinuations(RenderObject* renderer)
@@ -288,8 +288,8 @@ static inline RenderObject* endOfContinuations(RenderObject* renderer)
 static inline RenderObject* childBeforeConsideringContinuations(RenderInline* r, RenderObject* child)
 {
     RenderBoxModelObject* curContainer = r;
-    RenderObject* cur = 0;
-    RenderObject* prev = 0;
+    RenderObject* cur = nullptr;
+    RenderObject* prev = nullptr;
 
     while (curContainer) {
         if (curContainer->isRenderInline()) {
@@ -313,7 +313,7 @@ static inline RenderObject* childBeforeConsideringContinuations(RenderInline* r,
 
     ASSERT_NOT_REACHED();
 
-    return 0;
+    return nullptr;
 }
 
 static inline bool firstChildIsInlineContinuation(RenderObject* renderer)
@@ -325,9 +325,9 @@ static inline bool firstChildIsInlineContinuation(RenderObject* renderer)
 AccessibilityObject* AccessibilityRenderObject::previousSibling() const
 {
     if (!m_renderer)
-        return 0;
+        return nullptr;
 
-    RenderObject* previousSibling = 0;
+    RenderObject* previousSibling = nullptr;
 
     // Case 1: The node is a block and is an inline's continuation. In that case, the inline's
     // last child is our previous sibling (or further back in the continuation chain)
@@ -354,7 +354,7 @@ AccessibilityObject* AccessibilityRenderObject::previousSibling() const
         previousSibling = childBeforeConsideringContinuations(startOfConts, m_renderer->parent()->firstChild());
 
     if (!previousSibling)
-        return 0;
+        return nullptr;
     
     return axObjectCache()->getOrCreate(previousSibling);
 }
@@ -368,9 +368,9 @@ static inline bool lastChildHasContinuation(RenderObject* renderer)
 AccessibilityObject* AccessibilityRenderObject::nextSibling() const
 {
     if (!m_renderer)
-        return 0;
+        return nullptr;
 
-    RenderObject* nextSibling = 0;
+    RenderObject* nextSibling = nullptr;
 
     // Case 1: node is a block and has an inline continuation. Next sibling is the inline continuation's
     // first child.
@@ -409,7 +409,7 @@ AccessibilityObject* AccessibilityRenderObject::nextSibling() const
     }
 
     if (!nextSibling)
-        return 0;
+        return nullptr;
     
     return axObjectCache()->getOrCreate(nextSibling);
 }
@@ -421,20 +421,20 @@ static RenderBoxModelObject* nextContinuation(RenderObject* renderer)
         return toRenderInline(renderer)->continuation();
     if (renderer->isRenderBlock())
         return toRenderBlock(renderer)->inlineElementContinuation();
-    return 0;
+    return nullptr;
 }
     
 RenderObject* AccessibilityRenderObject::renderParentObject() const
 {
     if (!m_renderer)
-        return 0;
+        return nullptr;
 
     RenderElement* parent = m_renderer->parent();
 
     // Case 1: node is a block and is an inline's continuation. Parent
     // is the start of the continuation chain.
     RenderInline* startOfConts = nullptr;
-    RenderObject* firstChild = 0;
+    RenderObject* firstChild = nullptr;
     if (m_renderer->isRenderBlock() && (startOfConts = startOfContinuations(m_renderer)))
         parent = startOfConts;
 
@@ -483,7 +483,7 @@ AccessibilityObject* AccessibilityRenderObject::parentObjectIfExists() const
 AccessibilityObject* AccessibilityRenderObject::parentObject() const
 {
     if (!m_renderer)
-        return 0;
+        return nullptr;
     
     if (ariaRoleAttribute() == MenuBarRole)
         return axObjectCache()->getOrCreate(m_renderer->parent());
@@ -507,7 +507,7 @@ AccessibilityObject* AccessibilityRenderObject::parentObject() const
     if (isWebArea())
         return cache->getOrCreate(&m_renderer->view().frameView());
     
-    return 0;
+    return nullptr;
 }
     
 bool AccessibilityRenderObject::isAttachment() const
@@ -560,7 +560,7 @@ bool AccessibilityRenderObject::isOffScreen() const
 Element* AccessibilityRenderObject::anchorElement() const
 {
     if (!m_renderer)
-        return 0;
+        return nullptr;
     
     AXObjectCache* cache = axObjectCache();
     if (!cache)
@@ -589,7 +589,7 @@ Element* AccessibilityRenderObject::anchorElement() const
             return toElement(node);
     }
     
-    return 0;
+    return nullptr;
 }
 
 String AccessibilityRenderObject::helpText() const
@@ -655,7 +655,7 @@ String AccessibilityRenderObject::textUnderElement(AccessibilityTextUnderElement
     if (m_renderer->isText() || mode.childrenInclusion == AccessibilityTextUnderElementMode::TextUnderElementModeIncludeAllChildren) {
         // If possible, use a text iterator to get the text, so that whitespace
         // is handled consistently.
-        Document* nodeDocument = 0;
+        Document* nodeDocument = nullptr;
         RefPtr<Range> textRange;
         if (Node* node = m_renderer->node()) {
             nodeDocument = &node->document();
@@ -712,7 +712,7 @@ String AccessibilityRenderObject::textUnderElement(AccessibilityTextUnderElement
 Node* AccessibilityRenderObject::node() const
 {
     if (!m_renderer)
-        return 0;
+        return nullptr;
     if (m_renderer->isRenderView())
         return &m_renderer->document();
     return m_renderer->node();
@@ -774,11 +774,11 @@ String AccessibilityRenderObject::stringValue() const
 HTMLLabelElement* AccessibilityRenderObject::labelElementContainer() const
 {
     if (!m_renderer)
-        return 0;
+        return nullptr;
 
     // the control element should not be considered part of the label
     if (isControl())
-        return 0;
+        return nullptr;
     
     // find if this has a parent that is a label
     for (Node* parentNode = m_renderer->node(); parentNode; parentNode = parentNode->parentNode()) {
@@ -786,7 +786,7 @@ HTMLLabelElement* AccessibilityRenderObject::labelElementContainer() const
             return toHTMLLabelElement(parentNode);
     }
     
-    return 0;
+    return nullptr;
 }
 
 // The boundingBox for elements within the remote SVG element needs to be offset by its position
@@ -911,26 +911,26 @@ AccessibilityObject* AccessibilityRenderObject::internalLinkElement() const
 {
     Element* element = anchorElement();
     if (!element)
-        return 0;
+        return nullptr;
     
     // Right now, we do not support ARIA links as internal link elements
     if (!isHTMLAnchorElement(element))
-        return 0;
+        return nullptr;
     HTMLAnchorElement* anchor = toHTMLAnchorElement(element);
     
     URL linkURL = anchor->href();
     String fragmentIdentifier = linkURL.fragmentIdentifier();
     if (fragmentIdentifier.isEmpty())
-        return 0;
+        return nullptr;
     
     // check if URL is the same as current URL
     URL documentURL = m_renderer->document().url();
     if (!equalIgnoringFragmentIdentifier(documentURL, linkURL))
-        return 0;
+        return nullptr;
     
     Node* linkedNode = m_renderer->document().findAnchor(fragmentIdentifier);
     if (!linkedNode)
-        return 0;
+        return nullptr;
     
     // The element we find may not be accessible, so find the first accessible object.
     return firstAccessibleObjectFromNode(linkedNode);
@@ -1097,7 +1097,7 @@ bool AccessibilityRenderObject::exposesTitleUIElement() const
 AccessibilityObject* AccessibilityRenderObject::titleUIElement() const
 {
     if (!m_renderer)
-        return 0;
+        return nullptr;
     
     // if isFieldset is true, the renderer is guaranteed to be a RenderFieldset
     if (isFieldset())
@@ -1105,12 +1105,12 @@ AccessibilityObject* AccessibilityRenderObject::titleUIElement() const
     
     Node* node = m_renderer->node();
     if (!node || !node->isElementNode())
-        return 0;
+        return nullptr;
     HTMLLabelElement* label = labelForElement(toElement(node));
     if (label && label->renderer())
         return axObjectCache()->getOrCreate(label);
 
-    return 0;   
+    return nullptr;
 }
     
 bool AccessibilityRenderObject::isAllowedChildOfTree() const
@@ -1638,7 +1638,7 @@ void AccessibilityRenderObject::setFocused(bool on)
     Node* node = this->node();
 
     if (!on || !node || !node->isElementNode()) {
-        document->setFocusedElement(0);
+        document->setFocusedElement(nullptr);
         return;
     }
 
@@ -1646,7 +1646,7 @@ void AccessibilityRenderObject::setFocused(bool on)
     // That is a problem when focus is removed from the webpage to chrome, and then returns.
     // In these cases, we need to do what keyboard and mouse focus do, which is reset focus first.
     if (document->focusedElement() == node)
-        document->setFocusedElement(0);
+        document->setFocusedElement(nullptr);
 
     toElement(node)->focus();
 }
@@ -1705,7 +1705,7 @@ RenderView* AccessibilityRenderObject::topRenderer() const
 {
     Document* topDoc = topDocument();
     if (!topDoc)
-        return 0;
+        return nullptr;
     
     return topDoc->renderView();
 }
@@ -1713,14 +1713,14 @@ RenderView* AccessibilityRenderObject::topRenderer() const
 Document* AccessibilityRenderObject::document() const
 {
     if (!m_renderer)
-        return 0;
+        return nullptr;
     return &m_renderer->document();
 }
 
 Widget* AccessibilityRenderObject::widget() const
 {
     if (!m_renderer->isBoxModelObject() || !toRenderBoxModelObject(m_renderer)->isWidget())
-        return 0;
+        return nullptr;
     return toRenderWidget(m_renderer)->widget();
 }
 
@@ -1728,11 +1728,11 @@ AccessibilityObject* AccessibilityRenderObject::accessibilityParentForImageMap(H
 {
     // find an image that is using this map
     if (!map)
-        return 0;
+        return nullptr;
 
     HTMLImageElement* imageElement = map->imageElement();
     if (!imageElement)
-        return 0;
+        return nullptr;
     
     if (AXObjectCache* cache = axObjectCache())
         return cache->getOrCreate(imageElement);
@@ -1769,7 +1769,7 @@ void AccessibilityRenderObject::getDocumentLinks(AccessibilityChildrenVector& re
 FrameView* AccessibilityRenderObject::documentFrameView() const 
 { 
     if (!m_renderer)
-        return 0; 
+        return nullptr;
 
     // this is the RenderObject's Document's Frame's FrameView 
     return &m_renderer->view().frameView();
@@ -1778,7 +1778,7 @@ FrameView* AccessibilityRenderObject::documentFrameView() const
 Widget* AccessibilityRenderObject::widgetForAttachmentView() const
 {
     if (!isAttachment())
-        return 0;
+        return nullptr;
     return toRenderWidget(m_renderer)->widget();
 }
 
@@ -1886,7 +1886,7 @@ int AccessibilityRenderObject::indexForVisiblePosition(const VisiblePosition& po
 Element* AccessibilityRenderObject::rootEditableElementForPosition(const Position& position) const
 {
     // Find the root editable or pseudo-editable (i.e. having an editable ARIA role) element.
-    Element* result = 0;
+    Element* result = nullptr;
     
     Element* rootEditableElement = position.rootEditableElement();
 
@@ -1986,7 +1986,7 @@ VisiblePosition AccessibilityRenderObject::visiblePositionForPoint(const IntPoin
     FrameView* frameView = &renderView->frameView();
 #endif
 
-    Node* innerNode = 0;
+    Node* innerNode = nullptr;
     
     // locate the node containing the point
     LayoutPoint pointResult;
@@ -2148,9 +2148,9 @@ IntRect AccessibilityRenderObject::doAXBoundsForRange(const PlainTextRange& rang
 AccessibilityObject* AccessibilityRenderObject::accessibilityImageMapHitTest(HTMLAreaElement* area, const IntPoint& point) const
 {
     if (!area)
-        return 0;
+        return nullptr;
 
-    AccessibilityObject* parent = 0;
+    AccessibilityObject* parent = nullptr;
     for (Element* mapParent = area->parentElement(); mapParent; mapParent = mapParent->parentElement()) {
         if (isHTMLMapElement(mapParent)) {
             parent = accessibilityParentForImageMap(toHTMLMapElement(mapParent));
@@ -2158,21 +2158,21 @@ AccessibilityObject* AccessibilityRenderObject::accessibilityImageMapHitTest(HTM
         }
     }
     if (!parent)
-        return 0;
+        return nullptr;
     
     for (const auto& child : parent->children()) {
         if (child->elementRect().contains(point))
             return child.get();
     }
     
-    return 0;
+    return nullptr;
 }
 
 AccessibilityObject* AccessibilityRenderObject::remoteSVGElementHitTest(const IntPoint& point) const
 {
     AccessibilityObject* remote = remoteSVGRootElement();
     if (!remote)
-        return 0;
+        return nullptr;
     
     IntSize offset = point - roundedIntPoint(boundingBoxRect().location());
     return remote->accessibilityHitTest(IntPoint(offset));
@@ -2189,7 +2189,7 @@ AccessibilityObject* AccessibilityRenderObject::elementAccessibilityHitTest(cons
 AccessibilityObject* AccessibilityRenderObject::accessibilityHitTest(const IntPoint& point) const
 {
     if (!m_renderer || !m_renderer->hasLayer())
-        return 0;
+        return nullptr;
     
     RenderLayer* layer = toRenderBox(m_renderer)->layer();
      
@@ -2197,7 +2197,7 @@ AccessibilityObject* AccessibilityRenderObject::accessibilityHitTest(const IntPo
     HitTestResult hitTestResult = HitTestResult(point);
     layer->hitTest(request, hitTestResult);
     if (!hitTestResult.innerNode())
-        return 0;
+        return nullptr;
     Node* node = hitTestResult.innerNode()->deprecatedShadowAncestorNode();
 
     if (isHTMLAreaElement(node))
@@ -2208,7 +2208,7 @@ AccessibilityObject* AccessibilityRenderObject::accessibilityHitTest(const IntPo
     
     RenderObject* obj = node->renderer();
     if (!obj)
-        return 0;
+        return nullptr;
     
     AccessibilityObject* result = obj->document().axObjectCache()->getOrCreate(obj);
     result->updateChildrenIfNecessary();
@@ -2349,15 +2349,15 @@ AccessibilityObject* AccessibilityRenderObject::correspondingControlForLabelElem
 {
     HTMLLabelElement* labelElement = labelElementContainer();
     if (!labelElement)
-        return 0;
+        return nullptr;
     
     HTMLElement* correspondingControl = labelElement->control();
     if (!correspondingControl)
-        return 0;
+        return nullptr;
 
     // Make sure the corresponding control isn't a descendant of this label that's in the middle of being destroyed.
     if (correspondingControl->renderer() && !correspondingControl->renderer()->parent())
-        return 0;
+        return nullptr;
     
     return axObjectCache()->getOrCreate(correspondingControl);     
 }
@@ -2365,12 +2365,12 @@ AccessibilityObject* AccessibilityRenderObject::correspondingControlForLabelElem
 AccessibilityObject* AccessibilityRenderObject::correspondingLabelForControlElement() const
 {
     if (!m_renderer)
-        return 0;
+        return nullptr;
 
     // ARIA: section 2A, bullet #3 says if aria-labeledby or aria-label appears, it should
     // override the "label" element association.
     if (hasTextAlternative())
-        return 0;
+        return nullptr;
 
     Node* node = m_renderer->node();
     if (node && node->isHTMLElement()) {
@@ -2379,7 +2379,7 @@ AccessibilityObject* AccessibilityRenderObject::correspondingLabelForControlElem
             return axObjectCache()->getOrCreate(label);
     }
 
-    return 0;
+    return nullptr;
 }
 
 bool AccessibilityRenderObject::renderObjectIsObservable(RenderObject* renderer) const
@@ -2413,7 +2413,7 @@ AccessibilityObject* AccessibilityRenderObject::observableObject() const
         }
     }
     
-    return 0;
+    return nullptr;
 }
 
 bool AccessibilityRenderObject::isDescendantOfElementType(const QualifiedName& tagName) const
@@ -2658,7 +2658,7 @@ bool AccessibilityRenderObject::inheritsPresentationalRole() const
     static NeverDestroyed<HashSet<QualifiedName>> listItemParents;
     static NeverDestroyed<HashSet<QualifiedName>> tableCellParents;
 
-    HashSet<QualifiedName>* possibleParentTagNames = 0;
+    HashSet<QualifiedName>* possibleParentTagNames = nullptr;
     switch (roleValue()) {
     case ListItemRole:
     case ListMarkerRole:
@@ -2849,7 +2849,7 @@ bool AccessibilityRenderObject::isSVGImage() const
 void AccessibilityRenderObject::detachRemoteSVGRoot()
 {
     if (AccessibilitySVGRoot* root = remoteSVGRootElement())
-        root->setParent(0);
+        root->setParent(nullptr);
 }
 
 AccessibilitySVGRoot* AccessibilityRenderObject::remoteSVGRootElement() const
@@ -2988,7 +2988,7 @@ void AccessibilityRenderObject::addHiddenChildren()
                 if (children.size())
                     childObject = children.last().get();
                 else
-                    childObject = 0;
+                    childObject = nullptr;
             }
 
             if (childObject)
@@ -3235,7 +3235,7 @@ void AccessibilityRenderObject::setAccessibleName(const AtomicString& name)
     if (!m_renderer)
         return;
 
-    Node* domNode = 0;
+    Node* domNode = nullptr;
     // For web areas, set the aria-label on the HTML element.
     if (isWebArea())
         domNode = m_renderer->document().documentElement();
@@ -3450,14 +3450,14 @@ ScrollableArea* AccessibilityRenderObject::getScrollableAreaIfScrollable() const
 {
     // If the parent is a scroll view, then this object isn't really scrollable, the parent ScrollView should handle the scrolling.
     if (parentObject() && parentObject()->isAccessibilityScrollView())
-        return 0;
+        return nullptr;
 
     if (!m_renderer || !m_renderer->isBox())
-        return 0;
+        return nullptr;
 
     RenderBox* box = toRenderBox(m_renderer);
     if (!box->canBeScrolledAndHasScrollableArea())
-        return 0;
+        return nullptr;
 
     return box->layer();
 }
@@ -3612,7 +3612,7 @@ bool AccessibilityRenderObject::isIgnoredElementWithinMathTree() const
 AccessibilityObject* AccessibilityRenderObject::mathRadicandObject()
 {
     if (!isMathRoot())
-        return 0;
+        return nullptr;
     
     const auto& children = this->children();
     if (children.size() < 1)
@@ -3625,11 +3625,11 @@ AccessibilityObject* AccessibilityRenderObject::mathRadicandObject()
 AccessibilityObject* AccessibilityRenderObject::mathRootIndexObject()
 {
     if (!isMathRoot())
-        return 0;
+        return nullptr;
     
     const auto& children = this->children();
     if (children.size() != 2)
-        return 0;
+        return nullptr;
 
     // The index in a root is the value which determines if it's a square, cube, etc, root
     // and must be listed second.
@@ -3639,11 +3639,11 @@ AccessibilityObject* AccessibilityRenderObject::mathRootIndexObject()
 AccessibilityObject* AccessibilityRenderObject::mathNumeratorObject()
 {
     if (!isMathFraction())
-        return 0;
+        return nullptr;
     
     const auto& children = this->children();
     if (children.size() != 2)
-        return 0;
+        return nullptr;
     
     return children[0].get();
 }
@@ -3651,11 +3651,11 @@ AccessibilityObject* AccessibilityRenderObject::mathNumeratorObject()
 AccessibilityObject* AccessibilityRenderObject::mathDenominatorObject()
 {
     if (!isMathFraction())
-        return 0;
+        return nullptr;
 
     const auto& children = this->children();
     if (children.size() != 2)
-        return 0;
+        return nullptr;
     
     return children[1].get();
 }
@@ -3663,67 +3663,67 @@ AccessibilityObject* AccessibilityRenderObject::mathDenominatorObject()
 AccessibilityObject* AccessibilityRenderObject::mathUnderObject()
 {
     if (!isMathUnderOver() || !node())
-        return 0;
+        return nullptr;
     
     const auto& children = this->children();
     if (children.size() < 2)
-        return 0;
+        return nullptr;
     
     if (node()->hasTagName(MathMLNames::munderTag) || node()->hasTagName(MathMLNames::munderoverTag))
         return children[1].get();
     
-    return 0;
+    return nullptr;
 }
 
 AccessibilityObject* AccessibilityRenderObject::mathOverObject()
 {
     if (!isMathUnderOver() || !node())
-        return 0;
+        return nullptr;
     
     const auto& children = this->children();
     if (children.size() < 2)
-        return 0;
+        return nullptr;
     
     if (node()->hasTagName(MathMLNames::moverTag))
         return children[1].get();
     if (node()->hasTagName(MathMLNames::munderoverTag))
         return children[2].get();
 
-    return 0;
+    return nullptr;
 }
 
 AccessibilityObject* AccessibilityRenderObject::mathBaseObject()
 {
     if (!isMathSubscriptSuperscript() && !isMathUnderOver() && !isMathMultiscript())
-        return 0;
+        return nullptr;
     
     const auto& children = this->children();
     // The base object in question is always the first child.
     if (children.size() > 0)
         return children[0].get();
 
-    return 0;
+    return nullptr;
 }
 
 AccessibilityObject* AccessibilityRenderObject::mathSubscriptObject()
 {
     if (!isMathSubscriptSuperscript() || !node())
-        return 0;
+        return nullptr;
     
     const auto& children = this->children();
     if (children.size() < 2)
-        return 0;
+        return nullptr;
 
     if (node()->hasTagName(MathMLNames::msubTag) || node()->hasTagName(MathMLNames::msubsupTag))
         return children[1].get();
     
-    return 0;
+    return nullptr;
 }
 
 AccessibilityObject* AccessibilityRenderObject::mathSuperscriptObject()
 {
     if (!isMathSubscriptSuperscript() || !node())
-        return 0;
+        return nullptr;
     
     const auto& children = this->children();
     unsigned count = children.size();
@@ -3734,7 +3734,7 @@ AccessibilityObject* AccessibilityRenderObject::mathSuperscriptObject()
     if (count >= 3 && node()->hasTagName(MathMLNames::msubsupTag))
         return children[2].get();
     
-    return 0;
+    return nullptr;
 }
     
 String AccessibilityRenderObject::mathFencedOpenString() const
index b30e1e1..e2ad00f 100644 (file)
@@ -35,7 +35,7 @@ namespace WebCore {
 
 AccessibilitySVGRoot::AccessibilitySVGRoot(RenderObject* renderer)
     : AccessibilityRenderObject(renderer)
-    , m_parent(0)
+    , m_parent(nullptr)
 {
 }
 
index 3a93b09..7c6a82d 100644 (file)
@@ -51,7 +51,7 @@ AccessibilityScrollView::~AccessibilityScrollView()
 void AccessibilityScrollView::detach(AccessibilityDetachmentType detachmentType, AXObjectCache* cache)
 {
     AccessibilityObject::detach(detachmentType, cache);
-    m_scrollView = 0;
+    m_scrollView = nullptr;
 }
 
 PassRefPtr<AccessibilityScrollView> AccessibilityScrollView::create(ScrollView* view)
@@ -70,7 +70,7 @@ AccessibilityObject* AccessibilityScrollView::scrollBar(AccessibilityOrientation
         return m_horizontalScrollbar ? m_horizontalScrollbar.get() : 0;
     }
     
-    return 0;
+    return nullptr;
 }
 
 // If this is WebKit1 then the native scroll view needs to return the
@@ -124,14 +124,14 @@ void AccessibilityScrollView::updateScrollbars()
         m_horizontalScrollbar = addChildScrollbar(m_scrollView->horizontalScrollbar());
     else if (!m_scrollView->horizontalScrollbar() && m_horizontalScrollbar) {
         removeChildScrollbar(m_horizontalScrollbar.get());
-        m_horizontalScrollbar = 0;
+        m_horizontalScrollbar = nullptr;
     }
 
     if (m_scrollView->verticalScrollbar() && !m_verticalScrollbar)
         m_verticalScrollbar = addChildScrollbar(m_scrollView->verticalScrollbar());
     else if (!m_scrollView->verticalScrollbar() && m_verticalScrollbar) {
         removeChildScrollbar(m_verticalScrollbar.get());
-        m_verticalScrollbar = 0;
+        m_verticalScrollbar = nullptr;
     }
 }
     
@@ -147,7 +147,7 @@ void AccessibilityScrollView::removeChildScrollbar(AccessibilityObject* scrollba
 AccessibilityScrollbar* AccessibilityScrollView::addChildScrollbar(Scrollbar* scrollbar)
 {
     if (!scrollbar)
-        return 0;
+        return nullptr;
     
     AXObjectCache* cache = axObjectCache();
     if (!cache)
@@ -162,8 +162,8 @@ AccessibilityScrollbar* AccessibilityScrollView::addChildScrollbar(Scrollbar* sc
 void AccessibilityScrollView::clearChildren()
 {
     AccessibilityObject::clearChildren();
-    m_verticalScrollbar = 0;
-    m_horizontalScrollbar = 0;
+    m_verticalScrollbar = nullptr;
+    m_horizontalScrollbar = nullptr;
 }
 
 bool AccessibilityScrollView::computeAccessibilityIsIgnored() const
@@ -190,11 +190,11 @@ void AccessibilityScrollView::addChildren()
 AccessibilityObject* AccessibilityScrollView::webAreaObject() const
 {
     if (!m_scrollView || !m_scrollView->isFrameView())
-        return 0;
+        return nullptr;
     
     Document* doc = toFrameView(m_scrollView)->frame().document();
     if (!doc || !doc->hasLivingRenderTree())
-        return 0;
+        return nullptr;
 
     if (AXObjectCache* cache = axObjectCache())
         return cache->getOrCreate(doc);
@@ -206,7 +206,7 @@ AccessibilityObject* AccessibilityScrollView::accessibilityHitTest(const IntPoin
 {
     AccessibilityObject* webArea = webAreaObject();
     if (!webArea)
-        return 0;
+        return nullptr;
     
     if (m_horizontalScrollbar && m_horizontalScrollbar->elementRect().contains(point))
         return m_horizontalScrollbar.get();
@@ -229,7 +229,7 @@ LayoutRect AccessibilityScrollView::elementRect() const
 FrameView* AccessibilityScrollView::documentFrameView() const
 {
     if (!m_scrollView || !m_scrollView->isFrameView())
-        return 0;
+        return nullptr;
     
     return toFrameView(m_scrollView);
 }    
@@ -237,7 +237,7 @@ FrameView* AccessibilityScrollView::documentFrameView() const
 AccessibilityObject* AccessibilityScrollView::parentObject() const
 {
     if (!m_scrollView || !m_scrollView->isFrameView())
-        return 0;
+        return nullptr;
 
     AXObjectCache* cache = axObjectCache();
     if (!cache)
@@ -247,13 +247,13 @@ AccessibilityObject* AccessibilityScrollView::parentObject() const
     if (owner && owner->renderer())
         return cache->getOrCreate(owner);
 
-    return 0;
+    return nullptr;
 }
     
 AccessibilityObject* AccessibilityScrollView::parentObjectIfExists() const
 {
     if (!m_scrollView || !m_scrollView->isFrameView())
-        return 0;
+        return nullptr;
     
     AXObjectCache* cache = axObjectCache();
     if (!cache)
@@ -263,7 +263,7 @@ AccessibilityObject* AccessibilityScrollView::parentObjectIfExists() const
     if (owner && owner->renderer())
         return cache->get(owner);
     
-    return 0;
+    return nullptr;
 }
 
 ScrollableArea* AccessibilityScrollView::getScrollableAreaIfScrollable() const
index 7b44b15..eedc269 100644 (file)
@@ -59,7 +59,7 @@ Document* AccessibilityScrollbar::document() const
 {
     AccessibilityObject* parent = parentObject();
     if (!parent)
-        return 0;
+        return nullptr;
     return parent->document();
 }
 
index bc3088f..932acb4 100644 (file)
@@ -37,7 +37,7 @@ PassRefPtr<AccessibilitySpinButton> AccessibilitySpinButton::create()
 }
     
 AccessibilitySpinButton::AccessibilitySpinButton()
-    : m_spinButtonElement(0)
+    : m_spinButtonElement(nullptr)
 {
 }
 
index 0dfa100..d9d435f 100644 (file)
@@ -50,7 +50,7 @@ using namespace HTMLNames;
 
 AccessibilityTable::AccessibilityTable(RenderObject* renderer)
     : AccessibilityRenderObject(renderer)
-    , m_headerContainer(0)
+    , m_headerContainer(nullptr)
     , m_isAccessibilityTable(true)
 {
 }
@@ -342,7 +342,7 @@ void AccessibilityTable::clearChildren()
 
     if (m_headerContainer) {
         m_headerContainer->detachFromParent();
-        m_headerContainer = 0;
+        m_headerContainer = nullptr;
     }
 }
 
@@ -537,7 +537,7 @@ AccessibilityTableCell* AccessibilityTable::cellForColumnAndRow(unsigned column,
 {
     updateChildrenIfNecessary();
     if (column >= columnCount() || row >= rowCount())
-        return 0;
+        return nullptr;
     
     // Iterate backwards through the rows in case the desired cell has a rowspan and exists in a previous row.
     for (unsigned rowIndexCounter = row + 1; rowIndexCounter > 0; --rowIndexCounter) {
@@ -564,7 +564,7 @@ AccessibilityTableCell* AccessibilityTable::cellForColumnAndRow(unsigned column,
         }
     }
     
-    return 0;
+    return nullptr;
 }
 
 AccessibilityRole AccessibilityTable::roleValue() const
index bfe57ff..903ba17 100644 (file)
@@ -76,11 +76,11 @@ bool AccessibilityTableCell::computeAccessibilityIsIgnored() const
 AccessibilityTable* AccessibilityTableCell::parentTable() const
 {
     if (!m_renderer || !m_renderer->isTableCell())
-        return 0;
+        return nullptr;
 
     // If the document no longer exists, we might not have an axObjectCache.
     if (!axObjectCache())
-        return 0;
+        return nullptr;
     
     // Do not use getOrCreate. parentTable() can be called while the render tree is being modified 
     // by javascript, and creating a table element may try to access the render tree while in a bad state.
@@ -261,33 +261,33 @@ AccessibilityObject* AccessibilityTableCell::titleUIElement() const
     // then it can act as the title ui element. (This is only in the
     // case when the table is not appearing as an AXTable.)
     if (isTableCell() || !m_renderer || !m_renderer->isTableCell())
-        return 0;
+        return nullptr;
 
     // Table cells that are th cannot have title ui elements, since by definition
     // they are title ui elements
     Node* node = m_renderer->node();
     if (node && node->hasTagName(thTag))
-        return 0;
+        return nullptr;
     
     RenderTableCell* renderCell = toRenderTableCell(m_renderer);
 
     // If this cell is in the first column, there is no need to continue.
     int col = renderCell->col();
     if (!col)
-        return 0;
+        return nullptr;
 
     int row = renderCell->rowIndex();
 
     RenderTableSection* section = renderCell->section();
     if (!section)
-        return 0;
+        return nullptr;
     
     RenderTableCell* headerCell = section->primaryCellAt(row, 0);
     if (!headerCell || headerCell == renderCell)
-        return 0;
+        return nullptr;
 
     if (!headerCell->element() || !headerCell->element()->hasTagName(thTag))
-        return 0;
+        return nullptr;
     
     return axObjectCache()->getOrCreate(headerCell);
 }
index 7cee3da..78b6d5f 100644 (file)
@@ -70,14 +70,14 @@ LayoutRect AccessibilityTableColumn::elementRect() const
 AccessibilityObject* AccessibilityTableColumn::headerObject()
 {
     if (!m_parent)
-        return 0;
+        return nullptr;
     
     RenderObject* renderer = m_parent->renderer();
     if (!renderer)
-        return 0;
+        return nullptr;
     
     if (!m_parent->isAccessibilityTable())
-        return 0;
+        return nullptr;
     
     AccessibilityTable* parentTable = toAccessibilityTable(m_parent);
     if (parentTable->isAriaTable()) {
@@ -86,15 +86,15 @@ AccessibilityObject* AccessibilityTableColumn::headerObject()
                 return cell.get();
         }
         
-        return 0;
+        return nullptr;
     }
 
     if (!renderer->isTable())
-        return 0;
+        return nullptr;
     
     RenderTable* table = toRenderTable(renderer);
     
-    AccessibilityObject* headerObject = 0;
+    AccessibilityObject* headerObject = nullptr;
     
     // try the <thead> section first. this doesn't require th tags
     headerObject = headerObjectForSection(table->header(), false);
@@ -111,16 +111,16 @@ AccessibilityObject* AccessibilityTableColumn::headerObject()
 AccessibilityObject* AccessibilityTableColumn::headerObjectForSection(RenderTableSection* section, bool thTagRequired)
 {
     if (!section)
-        return 0;
+        return nullptr;
     
     unsigned numCols = section->numColumns();
     if (m_columnIndex >= numCols)
-        return 0;
+        return nullptr;
     
     if (!section->numRows())
-        return 0;
+        return nullptr;
     
-    RenderTableCell* cell = 0;
+    RenderTableCell* cell = nullptr;
     // also account for cells that have a span
     for (int testCol = m_columnIndex; testCol >= 0; --testCol) {
         RenderTableCell* testCell = section->primaryCellAt(0, testCol);
@@ -142,7 +142,7 @@ AccessibilityObject* AccessibilityTableColumn::headerObjectForSection(RenderTabl
     }
     
     if (!cell)
-        return 0;
+        return nullptr;
 
     return axObjectCache()->getOrCreate(cell);
 }
index 71f5af6..634d144 100644 (file)
@@ -110,30 +110,30 @@ AccessibilityTable* AccessibilityTableRow::parentTable() const
             return parent->isAccessibilityTable() ? toAccessibilityTable(parent) : 0;
     }
     
-    return 0;
+    return nullptr;
 }
     
 AccessibilityObject* AccessibilityTableRow::headerObject()
 {
     if (!m_renderer || !m_renderer->isTableRow())
-        return 0;
+        return nullptr;
     
     const auto& rowChildren = children();
     if (!rowChildren.size())
-        return 0;
+        return nullptr;
     
     // check the first element in the row to see if it is a TH element
     AccessibilityObject* cell = rowChildren[0].get();
     if (!cell->isTableCell())
-        return 0;
+        return nullptr;
     
     RenderObject* cellRenderer = toAccessibilityTableCell(cell)->renderer();
     if (!cellRenderer)
-        return 0;
+        return nullptr;
     
     Node* cellNode = cellRenderer->node();
     if (!cellNode || !cellNode->hasTagName(thTag))
-        return 0;
+        return nullptr;
     
     return cell;
 }
index b48b51e..500b177 100644 (file)
@@ -40,7 +40,7 @@ namespace WebCore {
 void AXObjectCache::detachWrapper(AccessibilityObject* obj, AccessibilityDetachmentType)
 {
     [obj->wrapper() detach];
-    obj->setWrapper(0);
+    obj->setWrapper(nullptr);
 }
 
 void AXObjectCache::attachWrapper(AccessibilityObject* obj)
index 6b7ba07..23a5536 100644 (file)
@@ -214,7 +214,7 @@ static AccessibilityObjectWrapper* AccessibilityUnignoredAncestor(AccessibilityO
 {
     // rdar://8798960 Make sure the object is gone early, so that anything _accessibilityUnregister 
     // does can't call back into the render tree.
-    m_object = 0;
+    m_object = nullptr;
 
     if ([self respondsToSelector:@selector(_accessibilityUnregister)])
         [self _accessibilityUnregister];
@@ -794,12 +794,12 @@ static void appendStringToResult(NSMutableString *result, NSString *string)
 - (AccessibilityTableCell*)tableCellParent
 {
     // Find if this element is in a table cell.
-    AccessibilityObject* cell = 0;
+    AccessibilityObject* cell = nullptr;
     for (cell = m_object; cell && !cell->isTableCell(); cell = cell->parentObject()) 
     { }
     
     if (!cell)
-        return 0;
+        return nil;
 
     return static_cast<AccessibilityTableCell*>(cell);
 }
@@ -807,12 +807,12 @@ static void appendStringToResult(NSMutableString *result, NSString *string)
 - (AccessibilityTable*)tableParent
 {
     // Find if the parent table for the table cell.
-    AccessibilityObject* parentTable = 0;
+    AccessibilityObject* parentTable = nullptr;
     for (parentTable = m_object; parentTable && !parentTable->isDataTable(); parentTable = parentTable->parentObject()) 
     { }
     
     if (!parentTable)
-        return 0;
+        return nil;
     
     return static_cast<AccessibilityTable*>(parentTable);
 }
@@ -1110,8 +1110,8 @@ static void appendStringToResult(NSMutableString *result, NSString *string)
     }
     else {
         // Find the appropriate scroll view to use to convert the contents to the window.
-        ScrollView* scrollView = 0;
-        AccessibilityObject* parent = 0;
+        ScrollView* scrollView = nullptr;
+        AccessibilityObject* parent = nullptr;
         for (parent = m_object->parentObject(); parent; parent = parent->parentObject()) {
             if (parent->isAccessibilityScrollView()) {
                 scrollView = toAccessibilityScrollView(parent)->scrollView();
@@ -1164,8 +1164,8 @@ static void appendStringToResult(NSMutableString *result, NSString *string)
         
     } else {
         // Find the appropriate scroll view to use to convert the contents to the window.
-        ScrollView* scrollView = 0;
-        AccessibilityObject* parent = 0;
+        ScrollView* scrollView = nullptr;
+        AccessibilityObject* parent = nullptr;
         for (parent = m_object->parentObject(); parent; parent = parent->parentObject()) {
             if (parent->isAccessibilityScrollView()) {
                 scrollView = toAccessibilityScrollView(parent)->scrollView();
@@ -1417,16 +1417,16 @@ static void appendStringToResult(NSMutableString *result, NSString *string)
 static RenderObject* rendererForView(WAKView* view)
 {
     if (![view conformsToProtocol:@protocol(WebCoreFrameView)])
-        return 0;
+        return nil;
     
     WAKView<WebCoreFrameView>* frameView = (WAKView<WebCoreFrameView>*)view;
     Frame* frame = [frameView _web_frame];
     if (!frame)
-        return 0;
+        return nil;
     
     Node* node = frame->document()->ownerElement();
     if (!node)
-        return 0;
+        return nil;
     
     return node->renderer();
 }
@@ -1887,7 +1887,7 @@ static void AXAttributedStringAppendText(NSMutableAttributedString* attrString,
 - (PassRefPtr<Range>)_convertToDOMRange:(NSRange)nsrange
 {
     if (nsrange.location > INT_MAX)
-        return 0;
+        return nullptr;
     if (nsrange.length > INT_MAX || nsrange.location + nsrange.length > INT_MAX)
         nsrange.length = INT_MAX - nsrange.location;
         
@@ -2474,8 +2474,8 @@ static void AXAttributedStringAppendText(NSMutableAttributedString* attrString,
 // These are used by DRT so that it can know when notifications are sent.
 // Since they are static, only one callback can be installed at a time (that's all DRT should need).
 typedef void (*AXPostedNotificationCallback)(id element, NSString* notification, void* context);
-static AXPostedNotificationCallback AXNotificationCallback = 0;
-static void* AXPostedNotificationContext = 0;
+static AXPostedNotificationCallback AXNotificationCallback = nullptr;
+static void* AXPostedNotificationContext = nullptr;
 
 - (void)accessibilitySetPostedNotificationCallback:(AXPostedNotificationCallback)function withContext:(void*)context
 {
index ff8dec4..701202a 100644 (file)
@@ -50,7 +50,7 @@ namespace WebCore {
 void AXObjectCache::detachWrapper(AccessibilityObject* obj, AccessibilityDetachmentType)
 {
     [obj->wrapper() detach];
-    obj->setWrapper(0);
+    obj->setWrapper(nullptr);
 }
 
 void AXObjectCache::attachWrapper(AccessibilityObject* obj)
index 3965776..1cc08cf 100644 (file)
@@ -39,7 +39,7 @@ namespace WebCore {
 void AccessibilityObject::detachFromParent()
 {
     if (isAttachment())
-        overrideAttachmentParent(0);
+        overrideAttachmentParent(nullptr);
 }
 
 void AccessibilityObject::overrideAttachmentParent(AccessibilityObject* parent)
@@ -61,7 +61,7 @@ bool AccessibilityObject::accessibilityIgnoreAttachment() const
 {
     // FrameView attachments are now handled by AccessibilityScrollView, 
     // so if this is the attachment, it should be ignored.
-    Widget* widget = 0;
+    Widget* widget = nullptr;
     if (isAttachment() && (widget = widgetForAttachmentView()) && widget->isFrameView())
         return true;
 
index 9bc1e20..1138b33 100644 (file)
@@ -102,7 +102,7 @@ static NSArray *convertMathPairsToNSArray(const AccessibilityObject::Accessibili
 
 - (void)detach
 {
-    m_object = 0;
+    m_object = nullptr;
 }
 
 - (BOOL)updateObjectBackingStore
index 5b22cc1..7443b45 100644 (file)
@@ -806,7 +806,7 @@ static CGColorRef CreateCGColorIfDifferent(NSColor* nsColor, CGColorRef existing
     // check for match with existing color
     if (existingColor && CGColorEqualToColor(cgColor, existingColor)) {
         CGColorRelease(cgColor);
-        cgColor = 0;
+        cgColor = nullptr;
     }
     
     return cgColor;
@@ -1749,8 +1749,8 @@ static NSMutableArray *convertStringsToNSArray(const Vector<String>& vector)
     } else {
         
         // Find the appropriate scroll view to use to convert the contents to the window.
-        ScrollView* scrollView = 0;
-        AccessibilityObject* parent = 0;
+        ScrollView* scrollView = nullptr;
+        AccessibilityObject* parent = nullptr;
         for (parent = m_object->parentObject(); parent; parent = parent->parentObject()) {
             if (parent->isAccessibilityScrollView()) {
                 scrollView = toAccessibilityScrollView(parent)->scrollView();
@@ -3322,16 +3322,16 @@ static NSString* roleValueToNSString(AccessibilityRole value)
 static RenderObject* rendererForView(NSView* view)
 {
     if (![view conformsToProtocol:@protocol(WebCoreFrameView)])
-        return 0;
+        return nullptr;
     
     NSView<WebCoreFrameView>* frameView = (NSView<WebCoreFrameView>*)view;
     Frame* frame = [frameView _web_frame];
     if (!frame)
-        return 0;
+        return nullptr;
     
     Node* node = frame->document()->ownerElement();
     if (!node)
-        return 0;
+        return nullptr;
     
     return node->renderer();
 }
@@ -3420,7 +3420,7 @@ static RenderObject* rendererForView(NSView* view)
     NSNumber* number = nil;
     NSArray* array = nil;
     NSDictionary* dictionary = nil;
-    RefPtr<AccessibilityObject> uiElement = 0;
+    RefPtr<AccessibilityObject> uiElement = nullptr;
     NSPoint point = NSZeroPoint;
     bool pointSet = false;
     NSRange range = {0, 0};
index c076ba3..3b09e4b 100644 (file)
@@ -49,7 +49,7 @@ namespace WebCore {
 
     protected:
         AccessibilityObjectWrapper(AccessibilityObject* obj) : m_object(obj) { }
-        AccessibilityObjectWrapper() : m_object(0) { }
+        AccessibilityObjectWrapper() : m_object(nullptr) { }
 
         AccessibilityObject* m_object;
     };