Paint invisible layer content in presence of composited animations.

third_party/WebKit/Source/core/paint/PaintLayerPainter.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/paint/PaintLayerPainter.h"
 
 #include "core/frame/LocalFrame.h"
 #include "core/layout/LayoutView.h"
 #include "core/paint/ClipPathClipper.h"
 #include "core/paint/FilterPainter.h"
@@ skipping 48 matching lines @@
     const LayoutObject* layoutObject) {
   return (paintFlags & PaintLayerPaintingOverflowContents ||
           (paintFlags & PaintLayerPaintingChildClippingMaskPhase &&
            layoutObject->hasClipPath()))
              ? IgnoreOverflowClip
              : RespectOverflowClip;
 }
 
 bool PaintLayerPainter::paintedOutputInvisible(
     const PaintLayerPaintingInfo& paintingInfo) {
-  if (m_paintLayer.layoutObject()->hasBackdropFilter())
+  const LayoutObject& layoutObject = *m_paintLayer.layoutObject();
+  if (layoutObject.hasBackdropFilter())
     return false;
 
-  if (RuntimeEnabledFeatures::slimmingPaintV2Enabled() &&
-      m_paintLayer.layoutObject()->styleRef().opacity())
-    return false;
+  if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
+    if (layoutObject.styleRef().opacity())

[pdr., 2017/01/26 22:50:38]

Do you need to check opacity > kMinimumVisibleOpacity here?

[wkorman, 2017/01/26 23:09:12]

http://crrev.com/2523103003 added PaintLayerPainterTest.DontPaintWithTinyOpacity
which explicitly checks that for SPv2 any opacity, even one <
kMinimumVisibleOpacity, paints for SPv2. I'm presuming the author had a specific
reason for that, so would like to preserve that logic in this change, though it
does seem like the optimization conceptually should be valid for SPv2 as well.

+      return false;
+
+    const EffectPaintPropertyNode* effect =
+        layoutObject.paintProperties()->effect();
+    const TransformPaintPropertyNode* transform =
+        layoutObject.paintProperties()->transform();
+    if ((effect &&
+         (effect->compositingReasons() & CompositingReasonActiveAnimation)) ||
+        (transform && (transform->compositingReasons() &
+                       CompositingReasonActiveAnimation))) {
+      return false;
+    }
+  }
 
   // 0.0004f < 1/2048. With 10-bit color channels (only available on the
   // newest Macs; otherwise it's 8-bit), we see that an alpha of 1/2048 or
   // less leads to a color output of less than 0.5 in all channels, hence
   // not visible.
   static const float kMinimumVisibleOpacity = 0.0004f;
   if (m_paintLayer.paintsWithTransparency(paintingInfo.getGlobalPaintFlags())) {
-    if (m_paintLayer.layoutObject()->styleRef().opacity() <
-        kMinimumVisibleOpacity) {
+    if (layoutObject.styleRef().opacity() < kMinimumVisibleOpacity) {
       return true;
     }
   }
   return false;
 }
 
 PaintResult PaintLayerPainter::paint(GraphicsContext& context,
                                      const PaintLayerPaintingInfo& paintingInfo,
                                      PaintLayerFlags paintFlags) {
   // https://code.google.com/p/chromium/issues/detail?id=343772
@@ skipping 1084 matching lines @@
           context, layoutObject, PaintPhaseClippingMask))
     return;
 
   IntRect snappedClipRect = pixelSnappedIntRect(clipRect.rect());
   LayoutObjectDrawingRecorder drawingRecorder(
       context, layoutObject, PaintPhaseClippingMask, snappedClipRect);
   context.fillRect(snappedClipRect, Color::black);
 }
 
 }  // namespace blink