Remove outdated FIXME

Source/core/layout/LayoutObject.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  *           (C) 2004 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Google Inc. All rights reserved.
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 1027 matching lines @@
 void LayoutObject::paint(const PaintInfo&, const LayoutPoint&)
 {
 }
 
 const LayoutBoxModelObject* LayoutObject::containerForPaintInvalidation() const
 {
     RELEASE_ASSERT(isRooted());
     return adjustCompositedContainerForSpecialAncestors(enclosingCompositedContainer());
 }
 
+const LayoutBoxModelObject& LayoutObject::containerForPaintInvalidationOnRootedTree() const
+{
+    RELEASE_ASSERT(isRooted());
+
+    const LayoutBoxModelObject* paintInvalidationContainer = containerForPaintInvalidation();
+    ASSERT(paintInvalidationContainer);
+
+    return *paintInvalidationContainer;
+}
+
 const LayoutBoxModelObject* LayoutObject::enclosingCompositedContainer() const
 {
     LayoutBoxModelObject* container = 0;
     // FIXME: CompositingState is not necessarily up to date for many callers of this function.
     DisableCompositingQueryAsserts disabler;
 
     if (DeprecatedPaintLayer* compositingLayer = enclosingLayer()->enclosingLayerForPaintInvalidationCrossingFrameBoundaries())
         container = compositingLayer->layoutObject();
     return container;
 }
@@ skipping 75 matching lines @@
     addJsonObjectForRect(value.get(), "rect", rect);
     value->setString("invalidation_reason", invalidationReason);
     return value;
 }
 
 LayoutRect LayoutObject::computePaintInvalidationRect(const LayoutBoxModelObject* paintInvalidationContainer, const PaintInvalidationState* paintInvalidationState) const
 {
     return clippedOverflowRectForPaintInvalidation(paintInvalidationContainer, paintInvalidationState);
 }
 
-void LayoutObject::invalidatePaintUsingContainer(const LayoutBoxModelObject* paintInvalidationContainer, const LayoutRect& r, PaintInvalidationReason invalidationReason) const
+void LayoutObject::invalidatePaintUsingContainer(const LayoutBoxModelObject& paintInvalidationContainer, const LayoutRect& r, PaintInvalidationReason invalidationReason) const
 {
     ASSERT(gDisablePaintInvalidationStateAsserts || document().lifecycle().state() == DocumentLifecycle::InPaintInvalidation);
 
     if (r.isEmpty())
         return;
 
     RELEASE_ASSERT(isRooted());
 
     // FIXME: Unify "devtools.timeline.invalidationTracking" and "blink.invalidation". crbug.com/413527.
     TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline.invalidationTracking"),
         "PaintInvalidationTracking",
         TRACE_EVENT_SCOPE_THREAD,
         "data", InspectorPaintInvalidationTrackingEvent::data(this, paintInvalidationContainer));
     TRACE_EVENT2(TRACE_DISABLED_BY_DEFAULT("blink.invalidation"), "LayoutObject::invalidatePaintUsingContainer()",
         "object", this->debugName().ascii(),
         "info", jsonObjectForPaintInvalidationInfo(r, paintInvalidationReasonToString(invalidationReason)));
 
-    if (paintInvalidationContainer->isLayoutView()) {
-        toLayoutView(paintInvalidationContainer)->invalidatePaintForRectangle(r, invalidationReason);
+    if (paintInvalidationContainer.isLayoutView()) {
+        toLayoutView(&paintInvalidationContainer)->invalidatePaintForRectangle(r, invalidationReason);
         return;
     }
 
-    if (paintInvalidationContainer->view()->usesCompositing()) {
-        ASSERT(paintInvalidationContainer->isPaintInvalidationContainer());
-        paintInvalidationContainer->setBackingNeedsPaintInvalidationInRect(r, invalidationReason);
+    if (paintInvalidationContainer.view()->usesCompositing()) {
+        ASSERT(paintInvalidationContainer.isPaintInvalidationContainer());
+        paintInvalidationContainer.setBackingNeedsPaintInvalidationInRect(r, invalidationReason);
     }
 }
 
 void LayoutObject::invalidateDisplayItemClient(const DisplayItemClientWrapper& displayItemClient) const
 {
     if (!RuntimeEnabledFeatures::slimmingPaintEnabled())
         return;
 
     // Not using enclosingCompositedContainer() directly because this object may be in an orphaned subtree.
     if (const DeprecatedPaintLayer* enclosingLayer = this->enclosingLayer()) {
@@ skipping 44 matching lines @@
     RELEASE_ASSERT(isRooted());
 
     if (r.isEmpty())
         return nullptr;
 
     if (view()->document().printing())
         return nullptr; // Don't invalidate paints if we're printing.
 
     LayoutRect dirtyRect(r);
 
-    const LayoutBoxModelObject* paintInvalidationContainer = containerForPaintInvalidation();
-    DeprecatedPaintLayer::mapRectToPaintInvalidationBacking(this, paintInvalidationContainer, dirtyRect);
+    const LayoutBoxModelObject& paintInvalidationContainer = containerForPaintInvalidationOnRootedTree();
+    DeprecatedPaintLayer::mapRectToPaintInvalidationBacking(this, &paintInvalidationContainer, dirtyRect);
     invalidatePaintUsingContainer(paintInvalidationContainer, dirtyRect, PaintInvalidationRectangle);
-    return paintInvalidationContainer;
+    return &paintInvalidationContainer;
 }
 
 void LayoutObject::invalidatePaintRectangle(const LayoutRect& r) const
 {
     if (const LayoutBoxModelObject* paintInvalidationContainer = invalidatePaintRectangleInternal(r)) {
         if (RuntimeEnabledFeatures::slimmingPaintEnabled())
             invalidateDisplayItemClients(*paintInvalidationContainer);
     }
 }
 
@@ skipping 175 matching lines @@
 
     return PaintInvalidationIncremental;
 }
 
 void LayoutObject::incrementallyInvalidatePaint(const LayoutBoxModelObject& paintInvalidationContainer, const LayoutRect& oldBounds, const LayoutRect& newBounds, const LayoutPoint& positionFromPaintInvalidationBacking)
 {
     ASSERT(oldBounds.location() == newBounds.location());
 
     LayoutUnit deltaRight = newBounds.maxX() - oldBounds.maxX();
     if (deltaRight > 0)
-        invalidatePaintUsingContainer(&paintInvalidationContainer, LayoutRect(oldBounds.maxX(), newBounds.y(), deltaRight, newBounds.height()), PaintInvalidationIncremental);
+        invalidatePaintUsingContainer(paintInvalidationContainer, LayoutRect(oldBounds.maxX(), newBounds.y(), deltaRight, newBounds.height()), PaintInvalidationIncremental);
     else if (deltaRight < 0)
-        invalidatePaintUsingContainer(&paintInvalidationContainer, LayoutRect(newBounds.maxX(), oldBounds.y(), -deltaRight, oldBounds.height()), PaintInvalidationIncremental);
+        invalidatePaintUsingContainer(paintInvalidationContainer, LayoutRect(newBounds.maxX(), oldBounds.y(), -deltaRight, oldBounds.height()), PaintInvalidationIncremental);
 
     LayoutUnit deltaBottom = newBounds.maxY() - oldBounds.maxY();
     if (deltaBottom > 0)
-        invalidatePaintUsingContainer(&paintInvalidationContainer, LayoutRect(newBounds.x(), oldBounds.maxY(), newBounds.width(), deltaBottom), PaintInvalidationIncremental);
+        invalidatePaintUsingContainer(paintInvalidationContainer, LayoutRect(newBounds.x(), oldBounds.maxY(), newBounds.width(), deltaBottom), PaintInvalidationIncremental);
     else if (deltaBottom < 0)
-        invalidatePaintUsingContainer(&paintInvalidationContainer, LayoutRect(oldBounds.x(), newBounds.maxY(), oldBounds.width(), -deltaBottom), PaintInvalidationIncremental);
+        invalidatePaintUsingContainer(paintInvalidationContainer, LayoutRect(oldBounds.x(), newBounds.maxY(), oldBounds.width(), -deltaBottom), PaintInvalidationIncremental);
 }
 
 void LayoutObject::fullyInvalidatePaint(const LayoutBoxModelObject& paintInvalidationContainer, PaintInvalidationReason invalidationReason, const LayoutRect& oldBounds, const LayoutRect& newBounds)
 {
     // Otherwise do full paint invalidation.
-    invalidatePaintUsingContainer(&paintInvalidationContainer, oldBounds, invalidationReason);
+    invalidatePaintUsingContainer(paintInvalidationContainer, oldBounds, invalidationReason);
     if (newBounds != oldBounds)
-        invalidatePaintUsingContainer(&paintInvalidationContainer, newBounds, invalidationReason);
+        invalidatePaintUsingContainer(paintInvalidationContainer, newBounds, invalidationReason);
 }
 
 void LayoutObject::invalidatePaintForOverflow()
 {
 }
 
 void LayoutObject::invalidatePaintForOverflowIfNeeded()
 {
     if (shouldInvalidateOverflowForPaint())
         invalidatePaintForOverflow();
@@ skipping 689 matching lines @@
 {
     TransformState transformState(TransformState::ApplyTransformDirection, localPoint);
     mapLocalToContainer(paintInvalidationContainer, transformState, mode | ApplyContainerFlip | UseTransforms, wasFixed, paintInvalidationState);
     transformState.flatten();
 
     return transformState.lastPlanarPoint();
 }
 
 FloatPoint LayoutObject::localToInvalidationBackingPoint(const LayoutPoint& localPoint, DeprecatedPaintLayer** backingLayer)
 {
-    const LayoutBoxModelObject* paintInvalidationContainer = containerForPaintInvalidation();
-    ASSERT(paintInvalidationContainer);
-    ASSERT(paintInvalidationContainer->layer());
+    const LayoutBoxModelObject& paintInvalidationContainer = containerForPaintInvalidationOnRootedTree();
+    ASSERT(paintInvalidationContainer.layer());
 
     if (backingLayer)
-        *backingLayer = paintInvalidationContainer->layer();
-    FloatPoint containerPoint = localToContainerPoint(FloatPoint(localPoint), paintInvalidationContainer, TraverseDocumentBoundaries);
+        *backingLayer = paintInvalidationContainer.layer();
+    FloatPoint containerPoint = localToContainerPoint(FloatPoint(localPoint), &paintInvalidationContainer, TraverseDocumentBoundaries);
 
     // A layoutObject can have no invalidation backing if it is from a detached frame,
     // or when forced compositing is disabled.
-    if (paintInvalidationContainer->layer()->compositingState() == NotComposited)
+    if (paintInvalidationContainer.layer()->compositingState() == NotComposited)
         return containerPoint;
 
-    DeprecatedPaintLayer::mapPointToPaintBackingCoordinates(paintInvalidationContainer, containerPoint);
+    DeprecatedPaintLayer::mapPointToPaintBackingCoordinates(&paintInvalidationContainer, containerPoint);
     return containerPoint;
 }
 
 LayoutSize LayoutObject::offsetFromContainer(const LayoutObject* o, const LayoutPoint& point, bool* offsetDependsOnPoint) const
 {
     ASSERT(o == container());
 
     LayoutSize offset = o->columnOffset(point);
 
     if (o->hasOverflowClip())
@@ skipping 1064 matching lines @@
 }
 
 DisablePaintInvalidationStateAsserts::DisablePaintInvalidationStateAsserts()
     : m_disabler(gDisablePaintInvalidationStateAsserts, true)
 {
 }
 
 // Since we're only painting non-composited layers, we know that they all share the same paintInvalidationContainer.
 void LayoutObject::invalidatePaintIncludingNonCompositingDescendants()
 {
-    invalidatePaintIncludingNonCompositingDescendantsInternal(containerForPaintInvalidation());
+    invalidatePaintIncludingNonCompositingDescendantsInternal(containerForPaintInvalidationOnRootedTree());
 }
 
-void LayoutObject::invalidatePaintIncludingNonCompositingDescendantsInternal(const LayoutBoxModelObject* paintInvalidationContainer)
+void LayoutObject::invalidatePaintIncludingNonCompositingDescendantsInternal(const LayoutBoxModelObject& paintInvalidationContainer)
 {
     invalidatePaintUsingContainer(paintInvalidationContainer, previousPaintInvalidationRect(), PaintInvalidationLayer);
     if (RuntimeEnabledFeatures::slimmingPaintEnabled())
-        invalidateDisplayItemClients(*paintInvalidationContainer);
+        invalidateDisplayItemClients(paintInvalidationContainer);
 
     for (LayoutObject* child = slowFirstChild(); child; child = child->nextSibling()) {
         if (!child->isPaintInvalidationContainer())
             child->invalidatePaintIncludingNonCompositingDescendantsInternal(paintInvalidationContainer);
     }
 }
 
 
 } // namespace blink
 
@@ skipping 26 matching lines @@
         const blink::LayoutObject* root = object1;
         while (root->parent())
             root = root->parent();
         root->showLayoutTreeAndMark(object1, "*", object2, "-", 0);
     } else {
         fprintf(stderr, "Cannot showLayoutTree. Root is (nil)\n");
     }
 }
 
 #endif