Have Node::document() return a reference instead of a pointer

Source/core/accessibility/AXObjectCache.cpp

 /*
  * Copyright (C) 2008, 2009, 2010 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 113 matching lines @@
 {
     // Find the corresponding accessibility object for the HTMLAreaElement. This should be
     // in the list of children for its corresponding image.
     if (!areaElement)
         return 0;
 
     HTMLImageElement* imageElement = areaElement->imageElement();
     if (!imageElement)
         return 0;
 
-    AccessibilityObject* axRenderImage = areaElement->document()->axObjectCache()->getOrCreate(imageElement);
+    AccessibilityObject* axRenderImage = areaElement->document().axObjectCache()->getOrCreate(imageElement);
     if (!axRenderImage)
         return 0;
 
     AccessibilityObject::AccessibilityChildrenVector imageChildren = axRenderImage->children();
     unsigned count = imageChildren.size();
     for (unsigned k = 0; k < count; ++k) {
         AccessibilityObject* child = imageChildren[k].get();
         if (!child->isImageMapLink())
             continue;
 
@@ skipping 11 matching lines @@
 
     // get the focused node in the page
     Document* focusedDocument = page->focusController().focusedOrMainFrame()->document();
     Node* focusedNode = focusedDocument->focusedElement();
     if (!focusedNode)
         focusedNode = focusedDocument;
 
     if (isHTMLAreaElement(focusedNode))
         return focusedImageMapUIElement(toHTMLAreaElement(focusedNode));
 
-    AccessibilityObject* obj = focusedNode->document()->axObjectCache()->getOrCreate(focusedNode);
+    AccessibilityObject* obj = focusedNode->document().axObjectCache()->getOrCreate(focusedNode);
     if (!obj)
         return 0;
 
     if (obj->shouldFocusActiveDescendant()) {
         if (AccessibilityObject* descendant = obj->activeDescendant())
             obj = descendant;
     }
 
     // the HTML element, for example, is focusable but has an AX object that is ignored
     if (obj->accessibilityIsIgnored())
@@ skipping 480 matching lines @@
     // because a render update may be in progress and creating an AX object can re-trigger a layout
     RefPtr<AccessibilityObject> object = get(renderer);
     while (!object && renderer) {
         renderer = renderer->parent();
         object = get(renderer);
     }
 
     if (!renderer)
         return;
 
-    postNotification(object.get(), renderer->document(), notification, postToElement, postType);
+    postNotification(object.get(), &renderer->document(), notification, postToElement, postType);
 }
 
 void AXObjectCache::postNotification(Node* node, AXNotification notification, bool postToElement, PostType postType)
 {
     if (!node)
         return;
 
     stopCachingComputedObjectAttributes();
 
     // Get an accessibility object that already exists. One should not be created here
     // because a render update may be in progress and creating an AX object can re-trigger a layout
     RefPtr<AccessibilityObject> object = get(node);
     while (!object && node) {
         node = node->parentNode();
         object = get(node);
     }
 
     if (!node)
         return;
 
-    postNotification(object.get(), node->document(), notification, postToElement, postType);
+    postNotification(object.get(), &node->document(), notification, postToElement, postType);
 }
 
 void AXObjectCache::postNotification(AccessibilityObject* object, Document* document, AXNotification notification, bool postToElement, PostType postType)
 {
     stopCachingComputedObjectAttributes();
 
     if (object && !postToElement)
         object = object->observableObject();
 
     if (!object && document)
@@ skipping 126 matching lines @@
     // FIXME: Accessability should make it clear these are DOM-compliant offsets or store Position objects.
     VisiblePosition visiblePos = VisiblePosition(createLegacyEditingPosition(textMarkerData.node, textMarkerData.offset), textMarkerData.affinity);
     Position deepPos = visiblePos.deepEquivalent();
     if (deepPos.isNull())
         return VisiblePosition();
 
     RenderObject* renderer = deepPos.deprecatedNode()->renderer();
     if (!renderer)
         return VisiblePosition();
 
-    AXObjectCache* cache = renderer->document()->axObjectCache();
+    AXObjectCache* cache = renderer->document().axObjectCache();
     if (!cache->isIDinUse(textMarkerData.axID))
         return VisiblePosition();
 
     if (deepPos.deprecatedNode() != textMarkerData.node || deepPos.deprecatedEditingOffset() != textMarkerData.offset)
         return VisiblePosition();
 
     return visiblePos;
 }
 
 void AXObjectCache::textMarkerDataForVisiblePosition(TextMarkerData& textMarkerData, const VisiblePosition& visiblePos)
 {
     // This memory must be bzero'd so instances of TextMarkerData can be tested for byte-equivalence.
     // This also allows callers to check for failure by looking at textMarkerData upon return.
     memset(&textMarkerData, 0, sizeof(TextMarkerData));
 
     if (visiblePos.isNull())
         return;
 
     Position deepPos = visiblePos.deepEquivalent();
     Node* domNode = deepPos.deprecatedNode();
     ASSERT(domNode);
     if (!domNode)
         return;
 
     if (domNode->hasTagName(inputTag) && toHTMLInputElement(domNode)->isPasswordField())
         return;
 
     // find or create an accessibility object for this node
-    AXObjectCache* cache = domNode->document()->axObjectCache();
+    AXObjectCache* cache = domNode->document().axObjectCache();
     RefPtr<AccessibilityObject> obj = cache->getOrCreate(domNode);
 
     textMarkerData.axID = obj.get()->axObjectID();
     textMarkerData.node = domNode;
     textMarkerData.offset = deepPos.deprecatedEditingOffset();
     textMarkerData.affinity = visiblePos.affinity();
 
     cache->setNodeInUse(domNode);
 }
 
@@ skipping 67 matching lines @@
     }
 
     client.postAccessibilityNotification(obj, notification);
 }
 
 void AXObjectCache::handleFocusedUIElementChanged(Node*, Node* newFocusedNode)
 {
     if (!newFocusedNode)
         return;
 
-    Page* page = newFocusedNode->document()->page();
+    Page* page = newFocusedNode->document().page();
     if (!page)
         return;
 
     AccessibilityObject* focusedObject = focusedUIElementForPage(page);
     if (!focusedObject)
         return;
 
     postPlatformNotification(focusedObject, AXFocusedUIElementChanged);
 }
 
 void AXObjectCache::handleScrolledToAnchor(const Node* anchorNode)
 {
     // The anchor node may not be accessible. Post the notification for the
     // first accessible object.
     postPlatformNotification(AccessibilityObject::firstAccessibleObjectFromNode(anchorNode), AXScrolledToAnchor);
 }
 
 } // namespace WebCore
 
 #endif // HAVE(ACCESSIBILITY)