Change PaintLayer::m_layoutObject to a reference.

third_party/WebKit/Source/core/paint/PaintLayerStackingNode.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights
  * reserved.
  *
  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
  *
  * Other contributors:
  *   Robert O'Callahan <roc+@cs.cmu.edu>
  *   David Baron <dbaron@fas.harvard.edu>
  *   Christian Biesinger <cbiesinger@web.de>
@@ skipping 48 matching lines @@
 // in order to determine if we isStacked() we have to ask the paint
 // layer about some of its state.
 PaintLayerStackingNode::PaintLayerStackingNode(PaintLayer* layer)
     : m_layer(layer)
 #if DCHECK_IS_ON()
       ,
       m_layerListMutationAllowed(true),
       m_stackingParent(0)
 #endif
 {
-  m_isStacked = layoutObject()->styleRef().isStacked();
+  m_isStacked = layoutObject().styleRef().isStacked();
 
   // Non-stacking contexts should have empty z-order lists. As this is already
   // the case, there is no need to dirty / recompute these lists.
   m_zOrderListsDirty = isStackingContext();
 }
 
 PaintLayerStackingNode::~PaintLayerStackingNode() {
 #if DCHECK_IS_ON()
-  if (!layoutObject()->documentBeingDestroyed()) {
+  if (!layoutObject().documentBeingDestroyed()) {
     DCHECK(!isInStackingParentZOrderLists());
 
     updateStackingParentForZOrderLists(0);
   }
 #endif
 }
 
 // Helper for the sorting of layers by z-index.
 static inline bool compareZIndex(PaintLayerStackingNode* first,
                                  PaintLayerStackingNode* second) {
   return first->zIndex() < second->zIndex();
 }
 
 PaintLayerCompositor* PaintLayerStackingNode::compositor() const {
-  DCHECK(layoutObject()->view());
-  return layoutObject()->view()->compositor();
+  DCHECK(layoutObject().view());
+  return layoutObject().view()->compositor();
 }
 
 void PaintLayerStackingNode::dirtyZOrderLists() {
 #if DCHECK_IS_ON()
   DCHECK(m_layerListMutationAllowed);
 #endif
   DCHECK(isStackingContext());
 
 #if DCHECK_IS_ON()
   updateStackingParentForZOrderLists(0);
 #endif
 
   if (m_posZOrderList)
     m_posZOrderList->clear();
   if (m_negZOrderList)
     m_negZOrderList->clear();
   m_zOrderListsDirty = true;
 
-  if (!layoutObject()->documentBeingDestroyed())
+  if (!layoutObject().documentBeingDestroyed())
     compositor()->setNeedsCompositingUpdate(CompositingUpdateRebuildTree);
 }
 
 void PaintLayerStackingNode::dirtyStackingContextZOrderLists() {
   if (PaintLayerStackingNode* stackingNode = ancestorStackingContextNode())
     stackingNode->dirtyZOrderLists();
 }
 
 void PaintLayerStackingNode::rebuildZOrderLists() {
 #if DCHECK_IS_ON()
@@ skipping 12 matching lines @@
 
   if (m_negZOrderList)
     std::stable_sort(m_negZOrderList->begin(), m_negZOrderList->end(),
                      compareZIndex);
 
   // Append layers for top layer elements after normal layer collection, to
   // ensure they are on top regardless of z-indexes.  The layoutObjects of top
   // layer elements are children of the view, sorted in top layer stacking
   // order.
   if (layer()->isRootLayer()) {
-    LayoutBlockFlow* rootBlock = layoutObject()->view();
+    LayoutBlockFlow* rootBlock = layoutObject().view();
     // If the viewport is paginated, everything (including "top-layer" elements)
     // gets redirected to the flow thread. So that's where we have to look, in
     // that case.
     if (LayoutBlockFlow* multiColumnFlowThread =
             rootBlock->multiColumnFlowThread())
       rootBlock = multiColumnFlowThread;
     for (LayoutObject* child = rootBlock->firstChild(); child;
          child = child->nextSibling()) {
       Element* childElement = (child->node() && child->node()->isElementNode())
                                   ? toElement(child->node())
@@ skipping 71 matching lines @@
 
 void PaintLayerStackingNode::updateLayerListsIfNeeded() {
   updateZOrderLists();
 }
 
 void PaintLayerStackingNode::styleDidChange(const ComputedStyle* oldStyle) {
   bool wasStackingContext = oldStyle ? oldStyle->isStackingContext() : false;
   int oldZIndex = oldStyle ? oldStyle->zIndex() : 0;
 
   bool isStackingContext = this->isStackingContext();
-  bool shouldBeStacked = layoutObject()->styleRef().isStacked();
+  bool shouldBeStacked = layoutObject().styleRef().isStacked();
   if (isStackingContext == wasStackingContext &&
       m_isStacked == shouldBeStacked && oldZIndex == zIndex())
     return;
 
   dirtyStackingContextZOrderLists();
 
   if (isStackingContext)
     dirtyZOrderLists();
   else
     clearZOrderLists();
 
   if (m_isStacked != shouldBeStacked) {
     m_isStacked = shouldBeStacked;
-    if (!layoutObject()->documentBeingDestroyed() && !layer()->isRootLayer())
+    if (!layoutObject().documentBeingDestroyed() && !layer()->isRootLayer())
       compositor()->setNeedsCompositingUpdate(CompositingUpdateRebuildTree);
   }
 }
 
 PaintLayerStackingNode* PaintLayerStackingNode::ancestorStackingContextNode()
     const {
   for (PaintLayer* ancestor = layer()->parent(); ancestor;
        ancestor = ancestor->parent()) {
     PaintLayerStackingNode* stackingNode = ancestor->stackingNode();
     if (stackingNode->isStackingContext())
       return stackingNode;
   }
   return 0;
 }
 
-LayoutBoxModelObject* PaintLayerStackingNode::layoutObject() const {
+LayoutBoxModelObject& PaintLayerStackingNode::layoutObject() const {
   return m_layer->layoutObject();
 }
 
 }  // namespace blink