RAL: Eliminate n^2 walk to find repaint containers

Source/core/rendering/RenderObject.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 1234 matching lines @@
     drawLineForBoxSide(graphicsContext, rightInner, topOuter, rightOuter, bottomOuter, BSRight, outlineColor, outlineStyle, outlineWidth, outlineWidth);
     drawLineForBoxSide(graphicsContext, leftOuter, bottomInner, rightOuter, bottomOuter, BSBottom, outlineColor, outlineStyle, outlineWidth, outlineWidth);
 
     if (useTransparencyLayer)
         graphicsContext->endLayer();
 }
 
 // FIXME: In repaint-after-layout, we should be able to change the logic to remove the need for this function. See crbug.com/368416.
 LayoutPoint RenderObject::positionFromRepaintContainer(const RenderLayerModelObject* repaintContainer) const
 {
-    ASSERT(containerForRepaint() == repaintContainer);
+    // FIXME: This assert should be re-enabled when we move repaint to after compositing update. crbug.com/360286
+    // ASSERT(containerForRepaint() == repaintContainer);
 
     LayoutPoint offset = isBox() ? toRenderBox(this)->location() : LayoutPoint();
     if (repaintContainer == this)
         return offset;
 
     return roundedIntPoint(localToContainerPoint(offset, repaintContainer));
 }
 
 IntRect RenderObject::absoluteBoundingBoxRect() const
 {
@@ skipping 79 matching lines @@
 
 void RenderObject::paint(PaintInfo&, const LayoutPoint&)
 {
 }
 
 const RenderLayerModelObject* RenderObject::containerForRepaint() const
 {
     if (!isRooted())
         return 0;
 
-    const RenderLayerModelObject* repaintContainer = 0;
+    return adjustCompositedContainerForSpecialAncestors(enclosingCompositedContainer());
+}
 
-    RenderView* renderView = view();
-    if (renderView->usesCompositing()) {
+const RenderLayerModelObject* RenderObject::enclosingCompositedContainer() const
+{
+    RenderLayerModelObject* container = 0;
+    if (view()->usesCompositing()) {
         // FIXME: CompositingState is not necessarily up to date for many callers of this function.
         DisableCompositingQueryAsserts disabler;
 
         if (RenderLayer* compositingLayer = enclosingLayer()->enclosingCompositingLayerForRepaint())
-            repaintContainer = compositingLayer->renderer();
+            container = compositingLayer->renderer();
     }
+    return container;
+}
+
+const RenderLayerModelObject* RenderObject::adjustCompositedContainerForSpecialAncestors(const RenderLayerModelObject* repaintContainer) const
+{
 
     if (document().view()->hasSoftwareFilters()) {
         if (RenderLayer* enclosingFilterLayer = enclosingLayer()->enclosingFilterLayer())
             return enclosingFilterLayer->renderer();
     }
 
     // If we have a flow thread, then we need to do individual repaints within the RenderRegions instead.
     // Return the flow thread as a repaint container in order to create a chokepoint that allows us to change
     // repainting to do individual region repaints.
     if (RenderFlowThread* parentRenderFlowThread = flowThreadContainingBlock()) {
         // If we have already found a repaint container then we will repaint into that container only if it is part of the same
         // flow thread. Otherwise we will need to catch the repaint call and send it to the flow thread.
         if (!repaintContainer || repaintContainer->flowThreadContainingBlock() != parentRenderFlowThread)
             repaintContainer = parentRenderFlowThread;
     }
-    return repaintContainer ? repaintContainer : renderView;
+    return repaintContainer ? repaintContainer : view();
+}
+
+bool RenderObject::isRepaintContainer() const
+{
+    return hasLayer() && toRenderLayerModelObject(this)->layer()->isRepaintContainer();
 }
 
 template<typename T> PassRefPtr<JSONValue> jsonObjectForRect(const T& rect)
 {
     RefPtr<JSONObject> object = JSONObject::create();
     object->setNumber("x", rect.x());
     object->setNumber("y", rect.y());
     object->setNumber("width", rect.width());
     object->setNumber("height", rect.height());
     return object.release();
@@ skipping 125 matching lines @@
         return "layer";
     case InvalidationRepaint:
         return "repaint";
     case InvalidationRepaintRectangle:
         return "repaint rectangle";
     }
     ASSERT_NOT_REACHED();
     return "";
 }
 
-void RenderObject::repaintTreeAfterLayout()
+void RenderObject::repaintTreeAfterLayout(const RenderLayerModelObject& repaintContainer)
 {
     // If we didn't need invalidation then our children don't need as well.
     // Skip walking down the tree as everything should be fine below us.
     if (!shouldCheckForInvalidationAfterLayout())
         return;
 
     clearRepaintState();
 
     for (RenderObject* child = firstChild(); child; child = child->nextSibling()) {
         if (!child->isOutOfFlowPositioned())
-            child->repaintTreeAfterLayout();
+            child->repaintTreeAfterLayout(repaintContainer);
     }
 }
 
 static PassRefPtr<JSONValue> jsonObjectForOldAndNewRects(const LayoutRect& oldRect, const LayoutRect& newRect)
 {
     RefPtr<JSONObject> object = JSONObject::create();
 
     object->setValue("old", jsonObjectForRect(oldRect));
     object->setValue("new", jsonObjectForRect(newRect));
     return object.release();
@@ skipping 1916 matching lines @@
 {
     if (object1) {
         const WebCore::RenderObject* root = object1;
         while (root->parent())
             root = root->parent();
         root->showRenderTreeAndMark(object1, "*", object2, "-", 0);
     }
 }
 
 #endif