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

Source/core/accessibility/AccessibilityRenderObject.cpp

 /*
 * Copyright (C) 2008 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 494 matching lines @@
 
     Element* anchor = anchorElement();
     if (!anchor || !isHTMLAnchorElement(anchor))
         return false;
 
     return !toHTMLAnchorElement(anchor)->href().isEmpty();
 }
 
 bool AccessibilityRenderObject::isLoaded() const
 {
-    return !m_renderer->document()->parser();
+    return !m_renderer->document().parser();
 }
 
 bool AccessibilityRenderObject::isOffScreen() const
 {
     ASSERT(m_renderer);
     IntRect contentRect = pixelSnappedIntRect(m_renderer->absoluteClippedOverflowRect());
     FrameView* view = m_renderer->frame()->view();
     IntRect viewRect = view->visibleContentRect();
     viewRect.intersect(contentRect);
     return viewRect.isEmpty();
 }
 
 bool AccessibilityRenderObject::isReadOnly() const
 {
     ASSERT(m_renderer);
 
     if (isWebArea()) {
-        Document* document = m_renderer->document();
-        if (!document)
-            return true;
-
-        HTMLElement* body = document->body();
+        Document& document = m_renderer->document();
+        HTMLElement* body = document.body();
         if (body && body->rendererIsEditable())
             return false;
 
-        return !document->rendererIsEditable();
+        return !document.rendererIsEditable();
     }
 
     return AccessibilityNodeObject::isReadOnly();
 }
 
 bool AccessibilityRenderObject::isVisited() const
 {
     // FIXME: Is it a privacy violation to expose visited information to accessibility APIs?
     return m_renderer->style()->isLink() && m_renderer->style()->insideLink() == InsideVisitedLink;
 }
 
 //
 // Check object state.
 //
 
 bool AccessibilityRenderObject::isFocused() const
 {
     if (!m_renderer)
         return false;
 
-    Document* document = m_renderer->document();
-    if (!document)
-        return false;
-
-    Element* focusedElement = document->focusedElement();
+    Document& document = m_renderer->document();
+    Element* focusedElement = document.focusedElement();
     if (!focusedElement)
         return false;
 
     // A web area is represented by the Document node in the DOM tree, which isn't focusable.
     // Check instead if the frame's selection controller is focused
     if (focusedElement == m_renderer->node()
-        || (roleValue() == WebAreaRole && document->frame()->selection()->isFocusedAndActive()))
+        || (roleValue() == WebAreaRole && document.frame()->selection()->isFocusedAndActive()))
         return true;
 
     return false;
 }
 
 bool AccessibilityRenderObject::isSelected() const
 {
     if (!m_renderer)
         return false;
 
@@ skipping 256 matching lines @@
 }
 
 KURL AccessibilityRenderObject::url() const
 {
     if (isAnchor() && isHTMLAnchorElement(m_renderer->node())) {
         if (HTMLAnchorElement* anchor = toHTMLAnchorElement(anchorElement()))
             return anchor->href();
     }
 
     if (isWebArea())
-        return m_renderer->document()->url();
+        return m_renderer->document().url();
 
     if (isImage() && m_renderer->node() && m_renderer->node()->hasTagName(imgTag))
         return toHTMLImageElement(m_renderer->node())->src();
 
     if (isInputImage())
         return toHTMLInputElement(m_renderer->node())->src();
 
     return KURL();
 }
 
@@ skipping 280 matching lines @@
     if (!m_renderer)
         return String();
 
     if (m_renderer->isFileUploadControl())
         return toRenderFileUploadControl(m_renderer)->buttonValue();
 
     if (m_renderer->isText()) {
         // If possible, use a text iterator to get the text, so that whitespace
         // is handled consistently.
         if (Node* node = this->node()) {
-            if (Frame* frame = node->document()->frame()) {
+            if (Frame* frame = node->document().frame()) {
                 // catch stale WebCoreAXObject (see <rdar://problem/3960196>)
-                if (frame->document() != node->document())
+                if (frame->document() != &node->document())
                     return String();
 
                 return plainText(rangeOfContents(node).get(), textIteratorBehaviorForTextRange());
             }
         }
 
         // Sometimes text fragments don't have Nodes associated with them (like when
         // CSS content is used to insert text or when a RenderCounter is used.)
         RenderText* renderTextObject = toRenderText(m_renderer);
         if (renderTextObject->isTextFragment())
@@ skipping 148 matching lines @@
     if (isHTMLAreaElement(node))
         return accessibilityImageMapHitTest(toHTMLAreaElement(node), point);
 
     if (node->hasTagName(optionTag))
         node = toHTMLOptionElement(node)->ownerSelectElement();
 
     RenderObject* obj = node->renderer();
     if (!obj)
         return 0;
 
-    AccessibilityObject* result = obj->document()->axObjectCache()->getOrCreate(obj);
+    AccessibilityObject* result = obj->document().axObjectCache()->getOrCreate(obj);
     result->updateChildrenIfNecessary();
 
     // Allow the element to perform any hit-testing it might need to do to reach non-render children.
     result = result->elementAccessibilityHitTest(point);
 
     if (result && result->accessibilityIsIgnored()) {
         // If this element is the label of a control, a hit test should return the control.
         if (result->isAccessibilityRenderObject()) {
             AccessibilityObject* controlObject = static_cast<AccessibilityRenderObject*>(result)->correspondingControlForLabelElement();
             if (controlObject && !controlObject->exposesTitleUIElement())
@@ skipping 179 matching lines @@
 //
 
 double AccessibilityRenderObject::estimatedLoadingProgress() const
 {
     if (!m_renderer)
         return 0;
 
     if (isLoaded())
         return 1.0;
 
-    if (Page* page = m_renderer->document()->page())
+    if (Page* page = m_renderer->document().page())
         return page->progress().estimatedProgress();
     return 0;
 }
 
 //
 // DOM and Render tree access.
 //
 
 Node* AccessibilityRenderObject::node() const
 {
     return m_renderer ? m_renderer->node() : 0;
 }
 
 Document* AccessibilityRenderObject::document() const
 {
     if (!m_renderer)
         return 0;
-    return m_renderer->document();
+    return &m_renderer->document();
 }
 
 FrameView* AccessibilityRenderObject::documentFrameView() const
 {
-    if (!m_renderer || !m_renderer->document())
+    if (!m_renderer)
         return 0;
 
     // this is the RenderObject's Document's Frame's FrameView
-    return m_renderer->document()->view();
+    return m_renderer->document().view();
 }
 
 Element* AccessibilityRenderObject::anchorElement() const
 {
     if (!m_renderer)
         return 0;
 
     AXObjectCache* cache = axObjectCache();
     RenderObject* currRenderer;
 
@@ skipping 79 matching lines @@
 //
 
 void AccessibilityRenderObject::setSelectedTextRange(const PlainTextRange& range)
 {
     if (isNativeTextControl() && m_renderer->isTextControl()) {
         HTMLTextFormControlElement* textControl = toRenderTextControl(m_renderer)->textFormControlElement();
         textControl->setSelectionRange(range.start, range.start + range.length);
         return;
     }
 
-    Document* document = m_renderer->document();
-    if (!document)
-        return;
-    Frame* frame = document->frame();
+    Document& document = m_renderer->document();
+    Frame* frame = document.frame();
     if (!frame)
         return;
     Node* node = m_renderer->node();
     frame->selection()->setSelection(VisibleSelection(Position(node, range.start, Position::PositionIsOffsetInAnchor),
         Position(node, range.start + range.length, Position::PositionIsOffsetInAnchor), DOWNSTREAM));
 }
 
 void AccessibilityRenderObject::setValue(const String& string)
 {
     if (!m_renderer || !m_renderer->node() || !m_renderer->node()->isElementNode())
@@ skipping 27 matching lines @@
 
 //
 // Notifications that this object may have changed.
 //
 
 void AccessibilityRenderObject::handleActiveDescendantChanged()
 {
     Element* element = toElement(renderer()->node());
     if (!element)
         return;
-    Document* doc = renderer()->document();
-    if (!doc->frame()->selection()->isFocusedAndActive() || doc->focusedElement() != element)
+    Document& doc = renderer()->document();
+    if (!doc.frame()->selection()->isFocusedAndActive() || doc.focusedElement() != element)
         return;
     AccessibilityRenderObject* activedescendant = static_cast<AccessibilityRenderObject*>(activeDescendant());
 
     if (activedescendant && shouldNotifyActiveDescendant())
-        doc->axObjectCache()->postNotification(m_renderer, AXObjectCache::AXActiveDescendantChanged, true);
+        doc.axObjectCache()->postNotification(m_renderer, AXObjectCache::AXActiveDescendantChanged, true);
 }
 
 void AccessibilityRenderObject::handleAriaExpandedChanged()
 {
     // Find if a parent of this object should handle aria-expanded changes.
     AccessibilityObject* containerParent = this->parentObject();
     while (containerParent) {
         bool foundParent = false;
 
         switch (containerParent->roleValue()) {
@@ skipping 50 matching lines @@
     if (!allowsTextRanges() && !m_renderer->isText())
         return VisiblePosition();
 
     Node* node = m_renderer->node();
     if (!node)
         return VisiblePosition();
 
     if (index <= 0)
         return VisiblePosition(firstPositionInOrBeforeNode(node), DOWNSTREAM);
 
-    RefPtr<Range> range = Range::create(m_renderer->document());
+    RefPtr<Range> range = Range::create(&m_renderer->document());
     range->selectNodeContents(node, IGNORE_EXCEPTION);
     CharacterIterator it(range.get());
     it.advance(index - 1);
     return VisiblePosition(Position(it.range()->endContainer(), it.range()->endOffset(), Position::PositionIsOffsetInAnch\
 or), UPSTREAM);
 }
 
 int AccessibilityRenderObject::indexForVisiblePosition(const VisiblePosition& pos) const
 {
     if (isNativeTextControl() && m_renderer->isTextControl()) {
         HTMLTextFormControlElement* textControl = toRenderTextControl(m_renderer)->textFormControlElement();
         return textControl->indexForVisiblePosition(pos);
     }
 
     if (!isTextControl())
         return 0;
 
     Node* node = m_renderer->node();
     if (!node)
         return 0;
 
     Position indexPosition = pos.deepEquivalent();
     if (indexPosition.isNull() || highestEditableRoot(indexPosition, HasEditableAXRole) != node)
         return 0;
 
-    RefPtr<Range> range = Range::create(m_renderer->document());
+    RefPtr<Range> range = Range::create(&m_renderer->document());
     range->setStart(node, 0, IGNORE_EXCEPTION);
     range->setEnd(indexPosition, IGNORE_EXCEPTION);
 
     return TextIterator::rangeLength(range.get());
 }
 
 void AccessibilityRenderObject::lineBreaks(Vector<int>& lineBreaks) const
 {
     if (!isTextControl())
         return;
@@ skipping 147 matching lines @@
     if (!isHTMLAnchorElement(element))
         return 0;
     HTMLAnchorElement* anchor = toHTMLAnchorElement(element);
 
     KURL linkURL = anchor->href();
     String fragmentIdentifier = linkURL.fragmentIdentifier();
     if (fragmentIdentifier.isEmpty())
         return 0;
 
     // check if URL is the same as current URL
-    KURL documentURL = m_renderer->document()->url();
+    KURL documentURL = m_renderer->document().url();
     if (!equalIgnoringFragmentIdentifier(documentURL, linkURL))
         return 0;
 
-    Node* linkedNode = m_renderer->document()->findAnchor(fragmentIdentifier);
+    Node* linkedNode = m_renderer->document().findAnchor(fragmentIdentifier);
     if (!linkedNode)
         return 0;
 
     // The element we find may not be accessible, so find the first accessible object.
     return firstAccessibleObjectFromNode(linkedNode);
 }
 
 AccessibilityObject* AccessibilityRenderObject::accessibilityImageMapHitTest(HTMLAreaElement* area, const IntPoint& point) const
 {
     if (!area)
@@ skipping 400 matching lines @@
         if (label && label->renderer()) {
             LayoutRect labelRect = axObjectCache()->getOrCreate(label)->elementRect();
             result.unite(labelRect);
         }
     }
 
     return result;
 }
 
 } // namespace WebCore