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

Source/core/rendering/RenderLayerCompositor.cpp

 /*
  * Copyright (C) 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
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 245 matching lines @@
             destroyRootLayer();
     }
 }
 
 void RenderLayerCompositor::cacheAcceleratedCompositingFlags()
 {
     bool hasAcceleratedCompositing = false;
     bool showRepaintCounter = false;
     bool forceCompositingMode = false;
 
-    if (Settings* settings = m_renderView->document()->settings()) {
+    if (Settings* settings = m_renderView->document().settings()) {
         hasAcceleratedCompositing = settings->acceleratedCompositingEnabled();
 
         // We allow the chrome to override the settings, in case the page is rendered
         // on a chrome that doesn't allow accelerated compositing.
         if (hasAcceleratedCompositing) {
             if (Page* page = this->page()) {
                 m_compositingTriggers = page->chrome().client().allowedCompositingTriggers();
                 hasAcceleratedCompositing = m_compositingTriggers;
             }
         }
@@ skipping 919 matching lines @@
 void RenderLayerCompositor::frameViewDidScroll()
 {
     FrameView* frameView = m_renderView->frameView();
     IntPoint scrollPosition = frameView->scrollPosition();
 
     if (!m_scrollLayer)
         return;
 
     bool scrollingCoordinatorHandlesOffset = false;
     if (ScrollingCoordinator* scrollingCoordinator = this->scrollingCoordinator()) {
-        if (Settings* settings = m_renderView->document()->settings()) {
+        if (Settings* settings = m_renderView->document().settings()) {
             if (isMainFrame() || settings->compositedScrollingForFramesEnabled())
                 scrollingCoordinatorHandlesOffset = scrollingCoordinator->scrollableAreaScrollLayerDidChange(frameView);
         }
     }
 
     // Scroll position = scroll minimum + scroll offset. Adjust the layer's
     // position to handle whatever the scroll coordinator isn't handling.
     // The minimum scroll position is non-zero for RTL pages with overflow.
     if (scrollingCoordinatorHandlesOffset)
         m_scrollLayer->setPosition(-frameView->minimumScrollPosition());
@@ skipping 683 matching lines @@
     if (AnimationController* animController = renderer->animation())
         return animController->isRunningAcceleratableAnimationOnRenderer(renderer);
     return false;
 }
 
 bool RenderLayerCompositor::requiresCompositingForTransition(RenderObject* renderer) const
 {
     if (!(m_compositingTriggers & ChromeClient::AnimationTrigger))
         return false;
 
-    if (Settings* settings = m_renderView->document()->settings()) {
+    if (Settings* settings = m_renderView->document().settings()) {
         if (!settings->acceleratedCompositingForTransitionEnabled())
             return false;
     }
 
     return renderer->style()->transitionForProperty(CSSPropertyOpacity)
         || renderer->style()->transitionForProperty(CSSPropertyWebkitFilter)
         || renderer->style()->transitionForProperty(CSSPropertyWebkitTransform);
 }
 
 CompositingReasons RenderLayerCompositor::subtreeReasonsForCompositing(RenderObject* renderer, bool hasCompositedDescendants, bool has3DTransformedDescendants) const
@@ skipping 102 matching lines @@
     EPosition position = renderer->style()->position();
     bool isFixed = renderer->isOutOfFlowPositioned() && position == FixedPosition;
     if (isFixed && !layer->isStackingContainer())
         return false;
 
     bool isSticky = renderer->isInFlowPositioned() && position == StickyPosition;
     if (!isFixed && !isSticky)
         return false;
 
     // FIXME: acceleratedCompositingForFixedPositionEnabled should probably be renamed acceleratedCompositingForViewportConstrainedPositionEnabled().
-    if (Settings* settings = m_renderView->document()->settings()) {
+    if (Settings* settings = m_renderView->document().settings()) {
         if (!settings->acceleratedCompositingForFixedPositionEnabled())
             return false;
     }
 
     if (isSticky)
         return true;
 
     RenderObject* container = renderer->container();
     // If the renderer is not hooked up yet then we have to wait until it is.
     if (!container) {
@@ skipping 118 matching lines @@
 #if ENABLE(RUBBER_BANDING)
     } else if (graphicsLayer == layerForOverhangAreas()) {
         ScrollView* view = m_renderView->frameView();
         view->calculateAndPaintOverhangBackground(&context, clip);
 #endif
     }
 }
 
 bool RenderLayerCompositor::supportsFixedRootBackgroundCompositing() const
 {
-    if (Settings* settings = m_renderView->document()->settings()) {
+    if (Settings* settings = m_renderView->document().settings()) {
         if (settings->acceleratedCompositingForFixedRootBackgroundEnabled())
             return true;
     }
     return false;
 }
 
 bool RenderLayerCompositor::needsFixedRootBackgroundLayer(const RenderLayer* layer) const
 {
     if (layer != m_renderView->layer())
         return false;
@@ skipping 284 matching lines @@
             Frame* frame = m_renderView->frameView()->frame();
             Page* page = frame ? frame->page() : 0;
             if (!page)
                 return;
             page->chrome().client().attachRootGraphicsLayer(frame, rootGraphicsLayer());
             break;
         }
         case RootLayerAttachedViaEnclosingFrame: {
             // The layer will get hooked up via RenderLayerBacking::updateGraphicsLayerConfiguration()
             // for the frame's renderer in the parent document.
-            m_renderView->document()->ownerElement()->scheduleLayerUpdate();
+            m_renderView->document().ownerElement()->scheduleLayerUpdate();
             break;
         }
     }
 
     m_rootLayerAttachment = attachment;
 }
 
 void RenderLayerCompositor::detachRootLayer()
 {
     if (!m_rootContentLayer || m_rootLayerAttachment == RootLayerUnattached)
         return;
 
     switch (m_rootLayerAttachment) {
     case RootLayerAttachedViaEnclosingFrame: {
         // The layer will get unhooked up via RenderLayerBacking::updateGraphicsLayerConfiguration()
         // for the frame's renderer in the parent document.
         if (m_overflowControlsHostLayer)
             m_overflowControlsHostLayer->removeFromParent();
         else
             m_rootContentLayer->removeFromParent();
 
-        if (HTMLFrameOwnerElement* ownerElement = m_renderView->document()->ownerElement())
+        if (HTMLFrameOwnerElement* ownerElement = m_renderView->document().ownerElement())
             ownerElement->scheduleLayerUpdate();
         break;
     }
     case RootLayerAttachedViaChromeClient: {
         Frame* frame = m_renderView->frameView()->frame();
         Page* page = frame ? frame->page() : 0;
         if (!page)
             return;
         page->chrome().client().attachRootGraphicsLayer(frame, 0);
     }
     break;
     case RootLayerUnattached:
         break;
     }
 
     m_rootLayerAttachment = RootLayerUnattached;
 }
 
 void RenderLayerCompositor::updateRootLayerAttachment()
 {
     ensureRootLayer();
 }
 
 bool RenderLayerCompositor::isMainFrame() const
 {
-    return !m_renderView->document()->ownerElement();
+    return !m_renderView->document().ownerElement();
 }
 
 // IFrames are special, because we hook compositing layers together across iframe boundaries
 // when both parent and iframe content are composited. So when this frame becomes composited, we have
 // to use a synthetic style change to get the iframes into RenderLayers in order to allow them to composite.
 void RenderLayerCompositor::notifyIFramesOfCompositingChange()
 {
     Frame* frame = m_renderView->frameView() ? m_renderView->frameView()->frame() : 0;
     if (!frame)
         return;
 
     for (Frame* child = frame->tree()->firstChild(); child; child = child->tree()->traverseNext(frame)) {
         if (child->document() && child->document()->ownerElement())
             child->document()->ownerElement()->scheduleLayerUpdate();
     }
 
     // Compositing also affects the answer to RenderIFrame::requiresAcceleratedCompositing(), so
     // we need to schedule a style recalc in our parent document.
-    if (HTMLFrameOwnerElement* ownerElement = m_renderView->document()->ownerElement())
+    if (HTMLFrameOwnerElement* ownerElement = m_renderView->document().ownerElement())
         ownerElement->scheduleLayerUpdate();
 }
 
 bool RenderLayerCompositor::layerHas3DContent(const RenderLayer* layer) const
 {
     const RenderStyle* style = layer->renderer()->style();
 
     if (style &&
         (style->transformStyle3D() == TransformStyle3DPreserve3D ||
          style->hasPerspective() ||
@@ skipping 180 matching lines @@
     } else if (graphicsLayer == m_scrollLayer.get()) {
         name = "Frame Scrolling Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace WebCore