Issue trace events to gather repaint information.

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 64 matching lines @@
 #include "core/rendering/compositing/RenderLayerCompositor.h"
 #include "core/rendering/style/ContentData.h"
 #include "core/rendering/style/CursorList.h"
 #include "core/rendering/style/ShadowList.h"
 #include "core/rendering/svg/SVGRenderSupport.h"
 #include "platform/Partitions.h"
 #include "platform/geometry/TransformState.h"
 #include "platform/graphics/GraphicsContext.h"
 #include "wtf/RefCountedLeakCounter.h"
 #include "wtf/text/StringBuilder.h"
+#include "wtf/text/WTFString.h"
 #include <algorithm>
 #ifndef NDEBUG
 #include <stdio.h>
 #endif
 
 using namespace std;
 
 namespace WebCore {
 
 using namespace HTMLNames;
@@ skipping 1276 matching lines @@
         // flow thread. Otherwise we will need to catch the repaint call and send it to the flow thread.
         RenderFlowThread* repaintContainerFlowThread = repaintContainer ? repaintContainer->flowThreadContainingBlock() : 0;
         if (!repaintContainerFlowThread || repaintContainerFlowThread != parentRenderFlowThread)
             repaintContainer = parentRenderFlowThread;
     }
     return repaintContainer;
 }
 
 void RenderObject::repaintUsingContainer(const RenderLayerModelObject* repaintContainer, const IntRect& r) const
 {
+    TRACE_EVENT2(TRACE_DISABLED_BY_DEFAULT("blink.repaint"), "RenderObject::repaintUsingContainer()",
+        "object", TRACE_STR_COPY(this->debugName().ascii().data()),
+        "rect", TRACE_STR_COPY(String::format("%d,%d %dx%d", r.x(), r.y(), r.width(), r.height()).ascii().data()));
+
     if (!repaintContainer) {
         view()->repaintViewRectangle(r);
         return;
     }
 
     // FIXME: Don't read compositing state here since we do this in the middle of recalc/layout.
     DisableCompositingQueryAsserts disabler;
     if (repaintContainer->compositingState() == PaintsIntoGroupedBacking) {
         ASSERT(repaintContainer->groupedMapping());
 
@@ skipping 51 matching lines @@
 void RenderObject::repaint() const
 {
     // Don't repaint if we're unrooted (note that view() still returns the view when unrooted)
     RenderView* view;
     if (!isRooted(&view))
         return;
 
     if (view->document().printing())
         return; // Don't repaint if we're printing.
 
+    TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("blink.repaint"), "RenderObject::repaint()",
+        "object", TRACE_STR_COPY(this->debugName().ascii().data()));
+
     // FIXME: really, we're in the repaint phase here, and the following queries are legal.
     // Until those states are fully fledged, I'll just disable the ASSERTS.
     DisableCompositingQueryAsserts disabler;
     RenderLayerModelObject* repaintContainer = containerForRepaint();
     repaintUsingContainer(repaintContainer ? repaintContainer : view, pixelSnappedIntRect(clippedOverflowRectForRepaint(repaintContainer)));
 }
 
 void RenderObject::repaintRectangle(const LayoutRect& r) const
 {
     // Don't repaint if we're unrooted (note that view() still returns the view when unrooted)
     RenderView* view;
     if (!isRooted(&view))
         return;
 
     if (view->document().printing())
         return; // Don't repaint if we're printing.
 
+    TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("blink.repaint"), "RenderObject::repaintRectangle()",

[Julien - ping for review, 2014/03/21 18:35:34]

Is there a lot of values in tracing callers of repaintUsingContainer considering
the InvalidationReason?

[dsinclair, 2014/03/24 15:04:31]

The invalidationReasons are only coming from repaintAfterlayoutIfNeeded. Having
these events lets us know where repaintUsingContainer is being called from if it
doesn't go through repaintAfterLayoutIfNeeded.

+        "object", TRACE_STR_COPY(this->debugName().ascii().data()));
+
     LayoutRect dirtyRect(r);
 
     if (!RuntimeEnabledFeatures::repaintAfterLayoutEnabled()) {
         // FIXME: layoutDelta needs to be applied in parts before/after transforms and
         // repaint containers. https://bugs.webkit.org/show_bug.cgi?id=23308
         dirtyRect.move(view->layoutDelta());
     }
 
     RenderLayerModelObject* repaintContainer = containerForRepaint();
     computeRectForRepaint(repaintContainer, dirtyRect);
     repaintUsingContainer(repaintContainer ? repaintContainer : view, pixelSnappedIntRect(dirtyRect));
 }
 
 IntRect RenderObject::pixelSnappedAbsoluteClippedOverflowRect() const
 {
     return pixelSnappedIntRect(absoluteClippedOverflowRect());
 }
 
+const char* RenderObject::repaintReasonToString(const RepaintReason reason) const
+{
+    switch (reason) {
+    case RepaintNone:
+        return "none";
+    case RepaintSelfLayout:
+        return "self layout";
+    case RepaintBorderFitLines:
+        return "border fit lines";
+    case RepaintBorderRadius:
+        return "border radius";
+    case RepaintOutlineBoxChange:
+        return "outline box change";
+    case RepaintBoundsChange:
+        return "bounds change";
+    default:
+        return "unknown";
+    }
+}
+
 bool RenderObject::repaintAfterLayoutIfNeeded(const RenderLayerModelObject* repaintContainer, bool wasSelfLayout,
     const LayoutRect& oldBounds, const LayoutRect& oldOutlineBox,
     const LayoutRect* newBoundsPtr, const LayoutRect* newOutlineBoxRectPtr)
 {
     RenderView* v = view();
     if (v->document().printing())
         return false; // Don't repaint if we're printing.
 
+    TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("blink.repaint"), "RenderObject::repaintAfterLayoutIfNeeded",
+        "object", TRACE_STR_COPY(this->debugName().ascii().data()));
+
     // This ASSERT fails due to animations.  See https://bugs.webkit.org/show_bug.cgi?id=37048
     // ASSERT(!newBoundsPtr || *newBoundsPtr == clippedOverflowRectForRepaint(repaintContainer));
     LayoutRect newBounds = newBoundsPtr ? *newBoundsPtr : clippedOverflowRectForRepaint(repaintContainer);
     LayoutRect newOutlineBox;
 
-    bool fullRepaint = wasSelfLayout;
+    RepaintReason repaintReason = RepaintNone;

[Julien - ping for review, 2014/03/21 18:35:34]

I hate RepaintNone as a default reason. I think this should just be
IncrementalInvalidation (btw, let's ditch repaint from our vocabulary).

[dsinclair, 2014/03/24 15:04:31]

Done.

+    if (wasSelfLayout)
+        repaintReason = RepaintSelfLayout;
+
     // Presumably a background or a border exists if border-fit:lines was specified.
-    if (!fullRepaint && style()->borderFit() == BorderFitLines)
-        fullRepaint = true;
-    if (!fullRepaint && style()->hasBorderRadius()) {
+    if (repaintReason == RepaintNone && style()->borderFit() == BorderFitLines)
+        repaintReason = RepaintBorderFitLines;
+
+    if (repaintReason == RepaintNone&& style()->hasBorderRadius()) {
         // If a border-radius exists and width/height is smaller than
         // radius width/height, we cannot use delta-repaint.
         RoundedRect oldRoundedRect = style()->getRoundedBorderFor(oldBounds);
         RoundedRect newRoundedRect = style()->getRoundedBorderFor(newBounds);
-        fullRepaint = oldRoundedRect.radii() != newRoundedRect.radii();
+        if (oldRoundedRect.radii() != newRoundedRect.radii())
+            repaintReason = RepaintBorderRadius;
     }
-    if (!fullRepaint) {
+
+    if (repaintReason == RepaintNone) {
         // This ASSERT fails due to animations.  See https://bugs.webkit.org/show_bug.cgi?id=37048
         // ASSERT(!newOutlineBoxRectPtr || *newOutlineBoxRectPtr == outlineBoundsForRepaint(repaintContainer));
         newOutlineBox = newOutlineBoxRectPtr ? *newOutlineBoxRectPtr : outlineBoundsForRepaint(repaintContainer);
 
         if ((hasOutline() && newOutlineBox.location() != oldOutlineBox.location())
             || (mustRepaintBackgroundOrBorder() && (newBounds != oldBounds || (hasOutline() && newOutlineBox != oldOutlineBox))))
-            fullRepaint = true;
+            repaintReason = RepaintOutlineBoxChange;
     }
 
     // If there is no intersection between the old and the new bounds, invalidating
     // the difference is more expensive than just doing a full repaint.
-    if (!fullRepaint && !newBounds.intersects(oldBounds))
-        fullRepaint = true;
+    if (repaintReason == RepaintNone && !newBounds.intersects(oldBounds))
+        repaintReason = RepaintBoundsChange;

[Julien - ping for review, 2014/03/21 18:35:34]

Sir, this is a change in behavior! We don't want to do incremental invalidations
if newBounds and oldBounds don't intersect. This is because once you don't
intersect, incremental invalidations can be more expensive than just a full
invalidation. This made some of our test progress and I think this is correct in
general.

[dsinclair, 2014/03/24 15:04:31]

I'm not sure I understand, there should be no behaviour change from this CL.
It's possible I named the enum badly, but I'm doing the same work as it was
previously. If the new bounds does not intersect the old bounds we will still
trigger the full repainting on line 1569 as repaintReason != RepaintNone.

 
     if (!repaintContainer)
         repaintContainer = v;
 
-    if (fullRepaint) {
+    if (repaintReason != RepaintNone) {
+        TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("blink.repaint"), "repaint_reason::full",
+            "object", TRACE_STR_COPY(this->debugName().ascii().data()),
+            "reason", repaintReasonToString(repaintReason));
+
         repaintUsingContainer(repaintContainer, pixelSnappedIntRect(oldBounds));
         if (newBounds != oldBounds)
             repaintUsingContainer(repaintContainer, pixelSnappedIntRect(newBounds));
         return true;
     }
 
     if (newBounds == oldBounds && newOutlineBox == oldOutlineBox)
         return false;
 
+    repaintReason = RepaintBoundsChange;
+    TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("blink.repaint"), "repaint_reason::delta",
+        "object", TRACE_STR_COPY(this->debugName().ascii().data()),
+        "reason", repaintReasonToString(repaintReason));
+
     LayoutUnit deltaLeft = newBounds.x() - oldBounds.x();
     if (deltaLeft > 0)
         repaintUsingContainer(repaintContainer, pixelSnappedIntRect(oldBounds.x(), oldBounds.y(), deltaLeft, oldBounds.height()));
     else if (deltaLeft < 0)
         repaintUsingContainer(repaintContainer, pixelSnappedIntRect(newBounds.x(), newBounds.y(), -deltaLeft, newBounds.height()));
 
     LayoutUnit deltaRight = newBounds.maxX() - oldBounds.maxX();
     if (deltaRight > 0)
         repaintUsingContainer(repaintContainer, pixelSnappedIntRect(oldBounds.maxX(), newBounds.y(), deltaRight, newBounds.height()));
     else if (deltaRight < 0)
@@ skipping 1859 matching lines @@
 {
     if (object1) {
         const WebCore::RenderObject* root = object1;
         while (root->parent())
             root = root->parent();
         root->showRenderTreeAndMark(object1, "*", object2, "-", 0);
     }
 }
 
 #endif