Don't create render passes for transparent images.

cc/layer_tree_host_common.cc

 // Copyright 2011 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 "cc/layer_tree_host_common.h"
 
 #include "cc/layer.h"
 #include "cc/layer_impl.h"
 #include "cc/layer_iterator.h"
 #include "cc/layer_sorter.h"
@@ skipping 123 matching lines @@
         targetSurfaceClipRect = gfx::ToEnclosingRect(MathUtil::projectClippedRect(layer->renderTarget()->renderSurface()->drawTransform().inverse(), layer->renderTarget()->renderSurface()->clipRect()));
         targetSurfaceClipRect.Intersect(layer->drawableContentRect());
     }
 
     if (targetSurfaceClipRect.IsEmpty())
         return gfx::Rect();
 
     return LayerTreeHostCommon::calculateVisibleRect(targetSurfaceClipRect, gfx::Rect(gfx::Point(), layer->contentBounds()), layer->drawTransform());
 }
 
+// Note that this function is short circuiting for speed. When the number of
+// descendants that draw content is >1, the result if guaranteed to by >1 but

[danakj, 2012/11/27 01:57:49]

nit: "to be"

+// not the actual number of descendants that draw content.
+template<typename LayerType>
+static int getNumDescendantsDrawContent(LayerType* layer)
+{
+    typedef LayerType* LayerTypePtr;
+    const typename LayerType::LayerList& children = layer->children();
+
+    int result = 0;
+    for (size_t i = 0; i < children.size(); ++i) {
+        if (children[i]->drawsContent())
+            ++result;
+        result += getNumDescendantsDrawContent(LayerTypePtr(children[i]));
+        if (result > 1)
+            return result;
+    }
+    return result;
+}
+
 static bool isScaleOrTranslation(const WebTransformationMatrix& m)
 {
     return !m.m12() && !m.m13() && !m.m14()
            && !m.m21() && !m.m23() && !m.m24()
            && !m.m31() && !m.m32() && !m.m43()
            && m.m44();
 }
 
 static inline bool transformToParentIsKnown(LayerImpl*)
 {
@@ skipping 86 matching lines @@
 
     // If the layer has a reflection.
     if (layer->replicaLayer())
         return true;
 
     // If the layer uses a CSS filter.
     if (!layer->filters().isEmpty() || !layer->backgroundFilters().isEmpty() || layer->filter())
         return true;
 
     // Cache this value, because otherwise it walks the entire subtree several times.
-    bool descendantDrawsContent = layer->descendantDrawsContent();
+    int numDescendantsDrawContent = getNumDescendantsDrawContent(layer);
+    bool descendantDrawsContent = numDescendantsDrawContent > 0;
 
     // If the layer flattens its subtree (i.e. the layer doesn't preserve-3d), but it is
     // treated as a 3D object by its parent (i.e. parent does preserve-3d).
     if (layerIsInExisting3DRenderingContext(layer) && !layer->preserves3D() && descendantDrawsContent)
         return true;
 
     // If the layer clips its descendants but it is not axis-aligned with respect to its parent.
     if (layerClipsSubtree(layer) && !axisAlignedWithRespectToParent && descendantDrawsContent)
         return true;
 
     // If the layer has opacity != 1 and does not have a preserves-3d transform style.
-    if (layer->opacity() != 1 && !layer->preserves3D() && descendantDrawsContent)
+    if (layer->opacity() != 1 && !layer->preserves3D() && descendantDrawsContent
+        && (layer->drawsContent() || numDescendantsDrawContent > 1))

[shawnsingh, 2012/11/27 07:16:10]

Sorry, I'm not following why this is our desired semantics.  Without yet hearing
your explanation, my immediate reaction is "we shouldn't need to know how many
descendants draw content"...  Can you please explain?

For example, what happens when a layer + one child both draw content?  Why would
that be a reasonable case for us to not make a renderSurface, where having 2
children that draw content is a reasonable case?

And whatever you explain should probably also be added in a comment here, since
it's not obvious...

         return true;
 
     return false;
 }
 
 WebTransformationMatrix computeScrollCompensationForThisLayer(LayerImpl* scrollingLayer, const WebTransformationMatrix& parentMatrix)
 {
     // For every layer that has non-zero scrollDelta, we have to compute a transform that can undo the
     // scrollDelta translation. In particular, we want this matrix to premultiply a fixed-position layer's
     // parentMatrix, so we design this transform in three steps as follows. The steps described here apply
@@ skipping 204 matching lines @@
 
     // If we early-exit anywhere in this function, the drawableContentRect of this subtree should be considered empty.
     drawableContentRectOfSubtree = gfx::Rect();
 
     // The root layer cannot skip calcDrawTransforms.
     if (!isRootLayer(layer) && subtreeShouldBeSkipped(layer))
         return;
 
     gfx::Rect clipRectForSubtree;
     bool subtreeShouldBeClipped = false;
-    
+
     float drawOpacity = layer->opacity();
     bool drawOpacityIsAnimating = layer->opacityIsAnimating();
-    if (layer->parent() && layer->parent()->preserves3D()) {
+    if (layer->parent()) {
         drawOpacity *= layer->parent()->drawOpacity();
         drawOpacityIsAnimating |= layer->parent()->drawOpacityIsAnimating();
     }
 
     bool animatingTransformToTarget = layer->transformIsAnimating();
     bool animatingTransformToScreen = animatingTransformToTarget;
     if (layer->parent()) {
         animatingTransformToTarget |= layer->parent()->drawTransformIsAnimating();
         animatingTransformToScreen |= layer->parent()->screenSpaceTransformIsAnimating();
     }
@@ skipping 486 matching lines @@
 
         foundLayer = currentLayer;
         break;
     }
 
     // This can potentially return 0, which means the screenSpacePoint did not successfully hit test any layers, not even the root layer.
     return foundLayer;
 }
 
 }  // namespace cc