Add the ubercomp DelegatedRendererLayer.

cc/CCLayerTreeHostCommon.cpp

 // 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 "config.h"
 
 #include "CCLayerTreeHostCommon.h"
 
 #include "CCLayerImpl.h"
@@ skipping 323 matching lines @@
 }
 
 // Should be called just before the recursive calculateDrawTransformsInternal().
 template<typename LayerType, typename LayerList>
 void setupRootLayerAndSurfaceForRecursion(LayerType* rootLayer, LayerList& renderSurfaceLayerList, const IntSize& deviceViewportSize)
 {
     if (!rootLayer->renderSurface())
         rootLayer->createRenderSurface();
 
     rootLayer->renderSurface()->setContentRect(IntRect(IntPoint::zero(), deviceViewportSize));
-    rootLayer->renderSurface()->clearLayerList();
+    rootLayer->renderSurface()->clearLayerLists();
 
     ASSERT(renderSurfaceLayerList.isEmpty());
     renderSurfaceLayerList.append(rootLayer);
 }
 
 // Recursively walks the layer tree starting at the given node and computes all the
 // necessary transformations, clipRects, render surfaces, etc.
 template<typename LayerType, typename LayerList, typename RenderSurfaceType, typename LayerSorter>
 static void calculateDrawTransformsInternal(LayerType* layer, LayerType* rootLayer, const WebTransformationMatrix& parentMatrix,
     const WebTransformationMatrix& fullHierarchyMatrix, const WebTransformationMatrix& currentScrollCompensationMatrix,
@@ skipping 166 matching lines @@
 
     if (subtreeShouldRenderToSeparateSurface(layer, isScaleOrTranslation(combinedTransform))) {
         // Check back-face visibility before continuing with this surface and its subtree
         if (!layer->doubleSided() && transformToParentIsKnown(layer) && isSurfaceBackFaceVisible(layer, combinedTransform))
             return;
 
         if (!layer->renderSurface())
             layer->createRenderSurface();
 
         RenderSurfaceType* renderSurface = layer->renderSurface();
-        renderSurface->clearLayerList();
+        renderSurface->clearLayerLists();
 
         // The origin of the new surface is the upper left corner of the layer.
         renderSurface->setDrawTransform(drawTransform);
         WebTransformationMatrix layerDrawTransform;
         layerDrawTransform.scale(deviceScaleFactor);
         if (!layer->contentBounds().isEmpty() && !layer->bounds().isEmpty()) {
             layerDrawTransform.scaleNonUniform(layer->bounds().width() / static_cast<double>(layer->contentBounds().width()),
                                                layer->bounds().height() / static_cast<double>(layer->contentBounds().height()));
         }
         layer->setDrawTransform(layerDrawTransform);
@@ skipping 148 matching lines @@
                 clippedContentRect.intersect(surfaceClipRect);
             }
         }
 
         // The RenderSurface backing texture cannot exceed the maximum supported
         // texture size.
         clippedContentRect.setWidth(std::min(clippedContentRect.width(), maxTextureSize));
         clippedContentRect.setHeight(std::min(clippedContentRect.height(), maxTextureSize));
 
         if (clippedContentRect.isEmpty())
-            renderSurface->clearLayerList();
+            renderSurface->clearLayerLists();
 
         renderSurface->setContentRect(clippedContentRect);
         renderSurface->setScreenSpaceTransform(layer->screenSpaceTransform());
 
         if (layer->replicaLayer()) {
             WebTransformationMatrix surfaceOriginToReplicaOriginTransform;
             surfaceOriginToReplicaOriginTransform.scale(deviceScaleFactor);
             surfaceOriginToReplicaOriginTransform.translate(layer->replicaLayer()->position().x() + layer->replicaLayer()->anchorPoint().x() * bounds.width(),
                                                             layer->replicaLayer()->position().y() + layer->replicaLayer()->anchorPoint().y() * bounds.height());
             surfaceOriginToReplicaOriginTransform.multiply(layer->replicaLayer()->transform());
@@ skipping 35 matching lines @@
     // drawn from back to front. If the preserves-3d property is also set on the parent then
     // skip the sorting as the parent will sort all the descendants anyway.
     if (descendants.size() && layer->preserves3D() && (!layer->parent() || !layer->parent()->preserves3D()))
         sortLayers(&descendants.at(sortingStartIndex), descendants.end(), layerSorter);
 
     if (layer->renderSurface())
         drawableContentRectOfSubtree = enclosingIntRect(layer->renderSurface()->drawableContentRect());
     else
         drawableContentRectOfSubtree = localDrawableContentRectOfSubtree;
 
-    return;
+    if (layer->hasContributingDelegatedRenderPasses())
+        layer->renderTarget()->renderSurface()->addContributingDelegatedRenderPassLayer(layer);
 }
 
 // FIXME: Instead of using the following function to set visibility rects on a second
 // tree pass, revise calculateVisibleContentRect() so that this can be done in a single
 // pass inside calculateDrawTransformsInternal<>().
 template<typename LayerType, typename LayerList, typename RenderSurfaceType>
 static void calculateVisibleRectsInternal(const LayerList& renderSurfaceLayerList)
 {
     // Use BackToFront since it's cheap and this isn't order-dependent.
     typedef CCLayerIterator<LayerType, LayerList, RenderSurfaceType, CCLayerIteratorActions::BackToFront> CCLayerIteratorType;
@@ skipping 117 matching lines @@
 
         foundLayer = currentLayer;
         break;
     }
 
     // This can potentially return 0, which means the viewportPoint did not successfully hit test any layers, not even the root layer.
     return foundLayer;
 }
 
 } // namespace cc