Remove 2 calls to paintInvalidationForWholeRenderer

Source/core/rendering/RenderBox.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  *           (C) 2005, 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Adobe Systems Incorporated. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 124 matching lines @@
     }
 
     if (isOutOfFlowPositioned())
         RenderBlock::removePositionedObject(this);
 }
 
 void RenderBox::styleWillChange(StyleDifference diff, const RenderStyle& newStyle)
 {
     RenderStyle* oldStyle = style();
     if (oldStyle) {
-        // The background of the root element or the body element could propagate up to
-        // the canvas.  Just dirty the entire canvas when our style changes substantially.
-        if ((diff.needsRepaint() || diff.needsLayout()) && node()
-            && (isHTMLHtmlElement(*node()) || isHTMLBodyElement(*node()))) {
-            view()->paintInvalidationForWholeRenderer();
-
+        if ((diff.needsRepaint() || diff.needsLayout()) && backgroundCanBleedToCanvas()) {
             if (oldStyle->hasEntirelyFixedBackground() != newStyle.hasEntirelyFixedBackground())
                 view()->compositor()->setNeedsUpdateFixedBackground();
         }
 
         // When a layout hint happens and an object's position style changes, we have to do a layout
         // to dirty the render tree using the old position value now.
         if (diff.needsFullLayout() && parent() && oldStyle->position() != newStyle.position()) {
             markContainingBlocksForLayout();
             if (oldStyle->position() == StaticPosition)
                 paintInvalidationForWholeRenderer();
             else if (newStyle.hasOutOfFlowPosition())
                 parent()->setChildNeedsLayout();
             if (isFloating() && !isOutOfFlowPositioned() && newStyle.hasOutOfFlowPosition())
                 removeFloatingOrPositionedChildFromBlockLists();
         }
-    // FIXME: This branch runs when !oldStyle, which means that layout was never called
-    // so what's the point in invalidating the whole view that we never painted?
-    } else if (isBody()) {
-        view()->paintInvalidationForWholeRenderer();
     }
 
     RenderBoxModelObject::styleWillChange(diff, newStyle);
 }
 
 void RenderBox::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
 {
     // Horizontal writing mode definition is updated in RenderBoxModelObject::updateFromStyle,
     // (as part of the RenderBoxModelObject::styleDidChange call below). So, we can safely cache the horizontal
     // writing mode value before style change here.
@@ skipping 1774 matching lines @@
         ASSERT(m_rareData);
         m_rareData->m_inlineBoxWrapper = 0;
     }
 }
 
 LayoutRect RenderBox::clippedOverflowRectForPaintInvalidation(const RenderLayerModelObject* paintInvalidationContainer, const PaintInvalidationState* paintInvalidationState) const
 {
     if (style()->visibility() != VISIBLE && enclosingLayer()->subtreeIsInvisible())
         return LayoutRect();
 
+    // If we have a background that could bleed into the canvas, just return
+    // the viewport's rectangle. This works as only body and the document
+    // element's renderer can bleed into the viewport so we are guaranteed
+    // to be in the RenderView's coordinate space.
+    if (style()->hasBackground() && backgroundCanBleedToCanvas())
+        return view()->viewRect();

[dsinclair, 2014/07/21 19:32:28]

Should we add an ASSERT here just to be safe that we're body or html? Not sure
if it would happen, but we could potentially expand the meaning of
backgroundCanBleedToCanvas in the future.

[Julien - ping for review, 2014/07/21 20:33:33]

I don't think that would give us much as that's the definition of
backgroundCanBleedToCanvas and I don't think this definition will evolve (this
is an old HTML concept). If we did evolve it, I would expect hackers / reviewers
to check this comment.

+
     LayoutRect r = visualOverflowRect();
     mapRectToPaintInvalidationBacking(paintInvalidationContainer, r, false /*fixed*/, paintInvalidationState);
     return r;
 }
 
 void RenderBox::mapRectToPaintInvalidationBacking(const RenderLayerModelObject* paintInvalidationContainer, LayoutRect& rect, bool fixed, const PaintInvalidationState* paintInvalidationState) const
 {
     // The rect we compute at each step is shifted by our x/y offset in the parent container's coordinate space.
     // Only when we cross a writing mode boundary will we have to possibly flipForWritingMode (to convert into a more appropriate
     // offset corner for the enclosing container).  This allows for a fully RL or BT document to repaint
@@ skipping 2651 matching lines @@
 
         // We need the old border box size only when the box has background or box decorations.
         if (!style()->hasBackground() && !style()->hasBoxDecorations())
             return;
     }
 
     ensureRareData().m_previousBorderBoxSize = size();
 }
 
 } // namespace WebCore