Invalidate previous paint rect in RenderObject::paintInvalidationForWholeRenderer()

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 1515 matching lines @@
 
     if (view()->document().printing())
         return; // Don't invalidate paints if we're printing.
 
     // FIXME: really, we're in the paint invalidation phase here, and the following queries are legal.
     // Until those states are fully fledged, I'll just disable the ASSERTS.
     DisableCompositingQueryAsserts disabler;
     const RenderLayerModelObject* paintInvalidationContainer = containerForPaintInvalidation();
     LayoutRect paintInvalidationRect = boundsRectForPaintInvalidation(paintInvalidationContainer);
     invalidatePaintUsingContainer(paintInvalidationContainer, paintInvalidationRect, InvalidationPaint);
+    if (paintInvalidationRect != previousPaintInvalidationRect())
+        invalidatePaintUsingContainer(paintInvalidationContainer, previousPaintInvalidationRect(), InvalidationPaint);

[Julien - ping for review, 2014/07/15 00:58:31]

I think we should only invalidate the previousPaintInvalidation here actually.
The other invalidation above will invalidate at position we don't care about
(e.g. intermediate forced layout + style recalc between frames).

The reason is simple: all our invalidations should be based on the previous
stored rectangles (and positions), if we don't have any that means we didn't
push a frame so we don't care about invalidating.

[Xianzhu, 2014/07/15 01:16:24]

I tried that but layout test results showed under-paints. Most of such tests are
about transformations (perhaps in squashed layers), such as
fast/repaint/fixed-scale.html. Only the rects before change of transformations
were invalidated. It seems that code path is parallel with the normal RAL path
and expects this method to invalidate the current paint rect. Will look into the
callers in such cases, but I wonder if there are also other callers expecting
the same.

 }
 
 LayoutRect RenderObject::boundsRectForPaintInvalidation(const RenderLayerModelObject* paintInvalidationContainer) const
 {
     if (!paintInvalidationContainer)
         return computePaintInvalidationRect(paintInvalidationContainer);
     return RenderLayer::computePaintInvalidationRect(this, paintInvalidationContainer->layer());
 }
 
 void RenderObject::invalidatePaintRectangle(const LayoutRect& r) const
@@ skipping 1899 matching lines @@
 {
     if (object1) {
         const WebCore::RenderObject* root = object1;
         while (root->parent())
             root = root->parent();
         root->showRenderTreeAndMark(object1, "*", object2, "-", 0);
     }
 }
 
 #endif