cc: DelegatedRenderer layer needs a surface if rotated.

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 <algorithm>
 
 #include "base/debug/trace_event.h"
 #include "cc/layer.h"
@@ skipping 114 matching lines @@
         return layer->transform().IsBackFaceVisible();
 
     // If the renderSurface is not part of a new or existing rendering context, then the
     // layers that contribute to this surface will decide back-face visibility for themselves.
     return false;
 }
 
 template<typename LayerType>
 static inline bool layerClipsSubtree(LayerType* layer)
 {
-    return layer->masksToBounds() || layer->maskLayer();
+    return layer->masksToBounds() || layer->maskLayer() || layer->hasDelegatedContent();

[piman, 2013/01/19 02:39:09]

I wonder if this could have a bad side effect if we add a child to a DRL (not
that we'd do that normally in Aura, but with the browser tag, I dunno?), because
while it wants to clip the render passes, it may not necessarily want to clip
child layers.

[danakj, 2013/01/19 02:43:00]

In my mind the DRLayer should never have any children.

With browser tag, it should have the parent compositor as the renderer, so the
DRLayer would include all the quads from the renderer and any browser tags.
Otherwise it's impossible to do things like correct z order.

SG?

 }
 
 template<typename LayerType>
 static gfx::Rect calculateVisibleContentRect(LayerType* layer, const gfx::Rect& ancestorClipRectInDescendantSurfaceSpace, const gfx::Rect& layerRectInTargetSpace)
 {
     DCHECK(layer->renderTarget());
 
     // Nothing is visible if the layer bounds are empty.
     if (!layer->drawsContent() || layer->contentBounds().IsEmpty() || layer->drawableContentRect().IsEmpty())
         return gfx::Rect();
@@ skipping 149 matching lines @@
     {
         TRACE_EVENT_INSTANT0("cc", "LayerTreeHostCommon::requireSurface clipping");
         return true;
     }
 
     // If the layer has some translucency and does not have a preserves-3d transform style.
     // This condition only needs a render surface if two or more layers in the
     // subtree overlap. But checking layer overlaps is unnecessarily costly so
     // instead we conservatively create a surface whenever at least two layers
     // draw content for this subtree.
-    bool atLeastTwoLayersInSubtreeDrawContent = layer->hasDelegatedContent() ||
-        (numDescendantsThatDrawContent > 0 && (layer->drawsContent() || numDescendantsThatDrawContent > 1));
+    bool atLeastTwoLayersInSubtreeDrawContent = numDescendantsThatDrawContent > 0 && (layer->drawsContent() || numDescendantsThatDrawContent > 1);
 
     if (layer->opacity() != 1 && !layer->preserves3D() && atLeastTwoLayersInSubtreeDrawContent) {
         TRACE_EVENT_INSTANT0("cc", "LayerTreeHostCommon::requireSurface opacity");
         return true;
     }
 
     return false;
 }
 
 gfx::Transform computeScrollCompensationForThisLayer(LayerImpl* scrollingLayer, const gfx::Transform& parentMatrix)
@@ skipping 171 matching lines @@
     DCHECK(renderSurfaceLayerList.back() == layerToRemove);
     renderSurfaceLayerList.pop_back();
     layerToRemove->clearRenderSurface();
 }
 
 // Recursively walks the layer tree to compute any information that is needed
 // before doing the main recursion.
 template<typename LayerType>
 static void preCalculateMetaInformation(LayerType* layer)
 {
+    if (layer->hasDelegatedContent()) {
+        // Layers with delegated content need to be treated as if they have as many children as the number
+        // of layers they own delegated quads for. Since we don't know this number right now, we choose
+        // one that acts like infinity for our purposes.
+        layer->drawProperties().num_descendants_that_draw_content = 1000;
+        layer->drawProperties().descendants_can_clip_selves = false;
+        return;
+    }
+
     int numDescendantsThatDrawContent = 0;
     bool descendantsCanClipSelves = true;
     bool sublayerTransformPreventsClip = !layer->sublayerTransform().IsPositiveScaleOrTranslation();
 
     for (size_t i = 0; i < layer->children().size(); ++i) {
         LayerType* childLayer = layer->children()[i];
         preCalculateMetaInformation<LayerType>(childLayer);
 
         numDescendantsThatDrawContent += childLayer->drawsContent() ? 1 : 0;
         numDescendantsThatDrawContent += childLayer->drawProperties().num_descendants_that_draw_content;
@@ skipping 666 matching lines @@
 
   // At this point, we think the point does hit the touch event handler region on the layer, but we need to walk up
   // the parents to ensure that the layer was not clipped in such a way that the
   // hit point actually should not hit the layer.
   if (pointIsClippedBySurfaceOrClipRect(screenSpacePoint, layerImpl))
      return false;
 
   return true;
 }
 }  // namespace cc