// 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 #include "base/debug/trace_event.h" #include "cc/layer.h" #include "cc/layer_impl.h" #include "cc/layer_iterator.h" #include "cc/layer_sorter.h" #include "cc/math_util.h" #include "cc/render_surface.h" #include "cc/render_surface_impl.h" #include "ui/gfx/point_conversions.h" #include "ui/gfx/rect_conversions.h" #include "ui/gfx/transform.h" namespace cc { ScrollAndScaleSet::ScrollAndScaleSet() { } ScrollAndScaleSet::~ScrollAndScaleSet() { } static void sortLayers(std::vector::iterator first, std::vector::iterator end, LayerSorter* layerSorter) { NOTREACHED(); } static void sortLayers(std::vector::iterator first, std::vector::iterator end, LayerSorter* layerSorter) { DCHECK(layerSorter); TRACE_EVENT0("cc", "layer_tree_host_common::sortLayers"); layerSorter->sort(first, end); } inline gfx::Rect calculateVisibleRectWithCachedLayerRect(const gfx::Rect& targetSurfaceRect, const gfx::Rect& layerBoundRect, const gfx::Rect& layerRectInTargetSpace, const gfx::Transform& transform) { // Is this layer fully contained within the target surface? if (targetSurfaceRect.Contains(layerRectInTargetSpace)) return layerBoundRect; // If the layer doesn't fill up the entire surface, then find the part of // the surface rect where the layer could be visible. This avoids trying to // project surface rect points that are behind the projection point. gfx::Rect minimalSurfaceRect = targetSurfaceRect; minimalSurfaceRect.Intersect(layerRectInTargetSpace); // Project the corners of the target surface rect into the layer space. // This bounding rectangle may be larger than it needs to be (being // axis-aligned), but is a reasonable filter on the space to consider. // Non-invertible transforms will create an empty rect here. gfx::Transform surfaceToLayer(gfx::Transform::kSkipInitialization); if (!transform.GetInverse(&surfaceToLayer)) { // TODO(shawnsingh): Either we need to handle uninvertible transforms // here, or DCHECK that the transform is invertible. } gfx::Rect layerRect = gfx::ToEnclosingRect(MathUtil::projectClippedRect(surfaceToLayer, gfx::RectF(minimalSurfaceRect))); layerRect.Intersect(layerBoundRect); return layerRect; } gfx::Rect LayerTreeHostCommon::calculateVisibleRect(const gfx::Rect& targetSurfaceRect, const gfx::Rect& layerBoundRect, const gfx::Transform& transform) { gfx::Rect layerInSurfaceSpace = MathUtil::mapClippedRect(transform, layerBoundRect); return calculateVisibleRectWithCachedLayerRect(targetSurfaceRect, layerBoundRect, layerInSurfaceSpace, transform); } template static inline bool isRootLayer(LayerType* layer) { return !layer->parent(); } template static inline bool layerIsInExisting3DRenderingContext(LayerType* layer) { // According to current W3C spec on CSS transforms, a layer is part of an established // 3d rendering context if its parent has transform-style of preserves-3d. return layer->parent() && layer->parent()->preserves3D(); } template static bool isRootLayerOfNewRenderingContext(LayerType* layer) { // According to current W3C spec on CSS transforms (Section 6.1), a layer is the // beginning of 3d rendering context if its parent does not have transform-style: // preserve-3d, but this layer itself does. if (layer->parent()) return !layer->parent()->preserves3D() && layer->preserves3D(); return layer->preserves3D(); } template static bool isLayerBackFaceVisible(LayerType* layer) { // The current W3C spec on CSS transforms says that backface visibility should be // determined differently depending on whether the layer is in a "3d rendering // context" or not. For Chromium code, we can determine whether we are in a 3d // rendering context by checking if the parent preserves 3d. if (layerIsInExisting3DRenderingContext(layer)) return layer->drawTransform().IsBackFaceVisible(); // In this case, either the layer establishes a new 3d rendering context, or is not in // a 3d rendering context at all. return layer->transform().IsBackFaceVisible(); } template static bool isSurfaceBackFaceVisible(LayerType* layer, const gfx::Transform& drawTransform) { if (layerIsInExisting3DRenderingContext(layer)) return drawTransform.IsBackFaceVisible(); if (isRootLayerOfNewRenderingContext(layer)) 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 static inline bool layerClipsSubtree(LayerType* layer) { return layer->masksToBounds() || layer->maskLayer(); } template 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(); // Compute visible bounds in target surface space. gfx::Rect visibleRectInTargetSurfaceSpace = layer->drawableContentRect(); if (!layer->renderTarget()->renderSurface()->clipRect().IsEmpty()) { // In this case the target surface does clip layers that contribute to // it. So, we have to convert the current surface's clipRect from its // ancestor surface space to the current (descendant) surface // space. This conversion is done outside this function so that it can // be cached instead of computing it redundantly for every layer. visibleRectInTargetSurfaceSpace.Intersect(ancestorClipRectInDescendantSurfaceSpace); } if (visibleRectInTargetSurfaceSpace.IsEmpty()) return gfx::Rect(); return calculateVisibleRectWithCachedLayerRect(visibleRectInTargetSurfaceSpace, gfx::Rect(gfx::Point(), layer->contentBounds()), layerRectInTargetSpace, layer->drawTransform()); } static inline bool transformToParentIsKnown(LayerImpl*) { return true; } static inline bool transformToParentIsKnown(Layer* layer) { return !layer->transformIsAnimating(); } static inline bool transformToScreenIsKnown(LayerImpl*) { return true; } static inline bool transformToScreenIsKnown(Layer* layer) { return !layer->screenSpaceTransformIsAnimating(); } template static bool layerShouldBeSkipped(LayerType* layer) { // Layers can be skipped if any of these conditions are met. // - does not draw content. // - is transparent // - has empty bounds // - the layer is not double-sided, but its back face is visible. // // Some additional conditions need to be computed at a later point after the recursion is finished. // - the intersection of render surface content and layer clipRect is empty // - the visibleContentRect is empty // // Note, if the layer should not have been drawn due to being fully transparent, // we would have skipped the entire subtree and never made it into this function, // so it is safe to omit this check here. if (!layer->drawsContent() || layer->bounds().IsEmpty()) return true; LayerType* backfaceTestLayer = layer; if (layer->useParentBackfaceVisibility()) { DCHECK(layer->parent()); DCHECK(!layer->parent()->useParentBackfaceVisibility()); backfaceTestLayer = layer->parent(); } // The layer should not be drawn if (1) it is not double-sided and (2) the back of the layer is known to be facing the screen. if (!backfaceTestLayer->doubleSided() && transformToScreenIsKnown(backfaceTestLayer) && isLayerBackFaceVisible(backfaceTestLayer)) return true; return false; } static inline bool subtreeShouldBeSkipped(LayerImpl* layer) { // The opacity of a layer always applies to its children (either implicitly // via a render surface or explicitly if the parent preserves 3D), so the // entire subtree can be skipped if this layer is fully transparent. return !layer->opacity(); } static inline bool subtreeShouldBeSkipped(Layer* layer) { // If the opacity is being animated then the opacity on the main thread is unreliable // (since the impl thread may be using a different opacity), so it should not be trusted. // In particular, it should not cause the subtree to be skipped. return !layer->opacity() && !layer->opacityIsAnimating(); } // Called on each layer that could be drawn after all information from // calcDrawProperties has been updated on that layer. May have some false // positives (e.g. layers get this called on them but don't actually get drawn). static inline void markLayerAsUpdated(LayerImpl* layer) { layer->didUpdateTransforms(); } static inline void markLayerAsUpdated(Layer* layer) { } template static bool subtreeShouldRenderToSeparateSurface(LayerType* layer, bool axisAlignedWithRespectToParent) { // // A layer and its descendants should render onto a new RenderSurfaceImpl if any of these rules hold: // // The root layer should always have a renderSurface. if (isRootLayer(layer)) return true; // If we force it. if (layer->forceRenderSurface()) return true; // If the layer uses a mask. if (layer->maskLayer()) return true; // 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; int numDescendantsThatDrawContent = layer->drawProperties().num_descendants_that_draw_content; // 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() && numDescendantsThatDrawContent > 0) { TRACE_EVENT_INSTANT0("cc", "LayerTreeHostCommon::requireSurface flattening"); return true; } // If the layer clips its descendants but it is not axis-aligned with respect to its parent. if (layerClipsSubtree(layer) && !axisAlignedWithRespectToParent && numDescendantsThatDrawContent > 0) { 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)); 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) { // 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 // from right-to-left, so Step 1 would be the right-most matrix: // // Step 1. transform from target surface space to the exact space where scrollDelta is actually applied. // -- this is inverse of the matrix in step 3 // Step 2. undo the scrollDelta // -- this is just a translation by scrollDelta. // Step 3. transform back to target surface space. // -- this transform is the "partialLayerOriginTransform" = (parentMatrix * scale(layer->pageScaleDelta())); // // These steps create a matrix that both start and end in targetSurfaceSpace. So this matrix can // pre-multiply any fixed-position layer's drawTransform to undo the scrollDeltas -- as long as // that fixed position layer is fixed onto the same renderTarget as this scrollingLayer. // gfx::Transform partialLayerOriginTransform = parentMatrix; partialLayerOriginTransform.PreconcatTransform(scrollingLayer->implTransform()); gfx::Transform scrollCompensationForThisLayer = partialLayerOriginTransform; // Step 3 scrollCompensationForThisLayer.Translate(scrollingLayer->scrollDelta().x(), scrollingLayer->scrollDelta().y()); // Step 2 gfx::Transform inversePartialLayerOriginTransform(gfx::Transform::kSkipInitialization); if (!partialLayerOriginTransform.GetInverse(&inversePartialLayerOriginTransform)) { // TODO(shawnsingh): Either we need to handle uninvertible transforms // here, or DCHECK that the transform is invertible. } scrollCompensationForThisLayer.PreconcatTransform(inversePartialLayerOriginTransform); // Step 1 return scrollCompensationForThisLayer; } gfx::Transform computeScrollCompensationMatrixForChildren(Layer* currentLayer, const gfx::Transform& currentParentMatrix, const gfx::Transform& currentScrollCompensation) { // The main thread (i.e. Layer) does not need to worry about scroll compensation. // So we can just return an identity matrix here. return gfx::Transform(); } gfx::Transform computeScrollCompensationMatrixForChildren(LayerImpl* layer, const gfx::Transform& parentMatrix, const gfx::Transform& currentScrollCompensationMatrix) { // "Total scroll compensation" is the transform needed to cancel out all scrollDelta translations that // occurred since the nearest container layer, even if there are renderSurfaces in-between. // // There are some edge cases to be aware of, that are not explicit in the code: // - A layer that is both a fixed-position and container should not be its own container, instead, that means // it is fixed to an ancestor, and is a container for any fixed-position descendants. // - A layer that is a fixed-position container and has a renderSurface should behave the same as a container // without a renderSurface, the renderSurface is irrelevant in that case. // - A layer that does not have an explicit container is simply fixed to the viewport. // (i.e. the root renderSurface.) // - If the fixed-position layer has its own renderSurface, then the renderSurface is // the one who gets fixed. // // This function needs to be called AFTER layers create their own renderSurfaces. // // Avoid the overheads (including stack allocation and matrix initialization/copy) if we know that the scroll compensation doesn't need to be reset or adjusted. if (!layer->isContainerForFixedPositionLayers() && layer->scrollDelta().IsZero() && !layer->renderSurface()) return currentScrollCompensationMatrix; // Start as identity matrix. gfx::Transform nextScrollCompensationMatrix; // If this layer is not a container, then it inherits the existing scroll compensations. if (!layer->isContainerForFixedPositionLayers()) nextScrollCompensationMatrix = currentScrollCompensationMatrix; // If the current layer has a non-zero scrollDelta, then we should compute its local scrollCompensation // and accumulate it to the nextScrollCompensationMatrix. if (!layer->scrollDelta().IsZero()) { gfx::Transform scrollCompensationForThisLayer = computeScrollCompensationForThisLayer(layer, parentMatrix); nextScrollCompensationMatrix.PreconcatTransform(scrollCompensationForThisLayer); } // If the layer created its own renderSurface, we have to adjust nextScrollCompensationMatrix. // The adjustment allows us to continue using the scrollCompensation on the next surface. // Step 1 (right-most in the math): transform from the new surface to the original ancestor surface // Step 2: apply the scroll compensation // Step 3: transform back to the new surface. if (layer->renderSurface() && !nextScrollCompensationMatrix.IsIdentity()) { gfx::Transform inverseSurfaceDrawTransform(gfx::Transform::kSkipInitialization); if (!layer->renderSurface()->drawTransform().GetInverse(&inverseSurfaceDrawTransform)) { // TODO(shawnsingh): Either we need to handle uninvertible transforms // here, or DCHECK that the transform is invertible. } nextScrollCompensationMatrix = inverseSurfaceDrawTransform * nextScrollCompensationMatrix * layer->renderSurface()->drawTransform(); } return nextScrollCompensationMatrix; } static inline void updateLayerContentsScale(LayerImpl* layer, const gfx::Transform& combinedTransform, float deviceScaleFactor, float pageScaleFactor, bool animatingTransformToScreen) { } static inline void updateLayerContentsScale(Layer* layer, const gfx::Transform& combinedTransform, float deviceScaleFactor, float pageScaleFactor, bool animatingTransformToScreen) { float rasterScale = layer->rasterScale(); if (!rasterScale) { rasterScale = 1; if (!animatingTransformToScreen && layer->automaticallyComputeRasterScale()) { gfx::Vector2dF transformScale = MathUtil::computeTransform2dScaleComponents(combinedTransform, 0.f); float combinedScale = std::max(transformScale.x(), transformScale.y()); rasterScale = combinedScale / deviceScaleFactor; if (!layer->boundsContainPageScale()) rasterScale /= pageScaleFactor; // Prevent scale factors below 1 from being used or saved. if (rasterScale < 1) rasterScale = 1; else layer->setRasterScale(rasterScale); } } float contentsScale = rasterScale * deviceScaleFactor; if (!layer->boundsContainPageScale()) contentsScale *= pageScaleFactor; layer->calculateContentsScale( contentsScale, &layer->drawProperties().contents_scale_x, &layer->drawProperties().contents_scale_y, &layer->drawProperties().content_bounds); Layer* maskLayer = layer->maskLayer(); if (maskLayer) { maskLayer->calculateContentsScale( contentsScale, &maskLayer->drawProperties().contents_scale_x, &maskLayer->drawProperties().contents_scale_y, &maskLayer->drawProperties().content_bounds); } Layer* replicaMaskLayer = layer->replicaLayer() ? layer->replicaLayer()->maskLayer() : 0; if (replicaMaskLayer) { replicaMaskLayer->calculateContentsScale( contentsScale, &replicaMaskLayer->drawProperties().contents_scale_x, &replicaMaskLayer->drawProperties().contents_scale_y, &replicaMaskLayer->drawProperties().content_bounds); } } template static inline void removeSurfaceForEarlyExit(LayerType* layerToRemove, LayerList& renderSurfaceLayerList) { DCHECK(layerToRemove->renderSurface()); // Technically, we know that the layer we want to remove should be // at the back of the renderSurfaceLayerList. However, we have had // bugs before that added unnecessary layers here // (https://bugs.webkit.org/show_bug.cgi?id=74147), but that causes // things to crash. So here we proactively remove any additional // layers from the end of the list. while (renderSurfaceLayerList.back() != layerToRemove) { renderSurfaceLayerList.back()->clearRenderSurface(); renderSurfaceLayerList.pop_back(); } 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 static void preCalculateMetaInformation(LayerType* layer) { int numDescendantsThatDrawContent = 0; for (size_t i = 0; i < layer->children().size(); ++i) { LayerType* childLayer = layer->children()[i]; preCalculateMetaInformation(childLayer); numDescendantsThatDrawContent += childLayer->drawsContent() ? 1 : 0; numDescendantsThatDrawContent += childLayer->drawProperties().num_descendants_that_draw_content; } layer->drawProperties().num_descendants_that_draw_content = numDescendantsThatDrawContent; } // Recursively walks the layer tree starting at the given node and computes all the // necessary transformations, clipRects, render surfaces, etc. template static void calculateDrawPropertiesInternal(LayerType* layer, const gfx::Transform& parentMatrix, const gfx::Transform& fullHierarchyMatrix, const gfx::Transform& currentScrollCompensationMatrix, const gfx::Rect& clipRectFromAncestor, const gfx::Rect& clipRectFromAncestorInDescendantSpace, bool ancestorClipsSubtree, RenderSurfaceType* nearestAncestorThatMovesPixels, LayerList& renderSurfaceLayerList, LayerList& layerList, LayerSorter* layerSorter, int maxTextureSize, float deviceScaleFactor, float pageScaleFactor, bool subtreeCanUseLCDText, gfx::Rect& drawableContentRectOfSubtree) { // This function computes the new matrix transformations recursively for this // layer and all its descendants. It also computes the appropriate render surfaces. // Some important points to remember: // // 0. Here, transforms are notated in Matrix x Vector order, and in words we describe what // the transform does from left to right. // // 1. In our terminology, the "layer origin" refers to the top-left corner of a layer, and the // positive Y-axis points downwards. This interpretation is valid because the orthographic // projection applied at draw time flips the Y axis appropriately. // // 2. The anchor point, when given as a PointF object, is specified in "unit layer space", // where the bounds of the layer map to [0, 1]. However, as a Transform object, // the transform to the anchor point is specified in "layer space", where the bounds // of the layer map to [bounds.width(), bounds.height()]. // // 3. Definition of various transforms used: // M[parent] is the parent matrix, with respect to the nearest render surface, passed down recursively. // M[root] is the full hierarchy, with respect to the root, passed down recursively. // Tr[origin] is the translation matrix from the parent's origin to this layer's origin. // Tr[origin2anchor] is the translation from the layer's origin to its anchor point // Tr[origin2center] is the translation from the layer's origin to its center // M[layer] is the layer's matrix (applied at the anchor point) // M[sublayer] is the layer's sublayer transform (applied at the layer's center) // S[layer2content] is the ratio of a layer's contentBounds() to its bounds(). // // Some composite transforms can help in understanding the sequence of transforms: // compositeLayerTransform = Tr[origin2anchor] * M[layer] * Tr[origin2anchor].inverse() // compositeSublayerTransform = Tr[origin2center] * M[sublayer] * Tr[origin2center].inverse() // // In words, the layer transform is applied about the anchor point, and the sublayer transform is // applied about the center of the layer. // // 4. When a layer (or render surface) is drawn, it is drawn into a "target render surface". Therefore the draw // transform does not necessarily transform from screen space to local layer space. Instead, the draw transform // is the transform between the "target render surface space" and local layer space. Note that render surfaces, // except for the root, also draw themselves into a different target render surface, and so their draw // transform and origin transforms are also described with respect to the target. // // Using these definitions, then: // // The draw transform for the layer is: // M[draw] = M[parent] * Tr[origin] * compositeLayerTransform * S[layer2content] // = M[parent] * Tr[layer->position() + anchor] * M[layer] * Tr[anchor2origin] * S[layer2content] // // Interpreting the math left-to-right, this transforms from the layer's render surface to the origin of the layer in content space. // // The screen space transform is: // M[screenspace] = M[root] * Tr[origin] * compositeLayerTransform * S[layer2content] // = M[root] * Tr[layer->position() + anchor] * M[layer] * Tr[anchor2origin] * S[layer2content] // // Interpreting the math left-to-right, this transforms from the root render surface's content space to the origin of the layer in content space. // // The transform hierarchy that is passed on to children (i.e. the child's parentMatrix) is: // M[parent]_for_child = M[parent] * Tr[origin] * compositeLayerTransform * compositeSublayerTransform // = M[parent] * Tr[layer->position() + anchor] * M[layer] * Tr[anchor2origin] * compositeSublayerTransform // // and a similar matrix for the full hierarchy with respect to the root. // // Finally, note that the final matrix used by the shader for the layer is P * M[draw] * S . This final product // is computed in drawTexturedQuad(), where: // P is the projection matrix // S is the scale adjustment (to scale up a canonical quad to the layer's size) // // When a render surface has a replica layer, that layer's transform is used to draw a second copy of the surface. // gfx::Transforms named here are relative to the surface, unless they specify they are relative to the replica layer. // // We will denote a scale by device scale S[deviceScale] // // The render surface draw transform to its target surface origin is: // M[surfaceDraw] = M[owningLayer->Draw] // // The render surface origin transform to its the root (screen space) origin is: // M[surface2root] = M[owningLayer->screenspace] * S[deviceScale].inverse() // // The replica draw transform to its target surface origin is: // M[replicaDraw] = S[deviceScale] * M[surfaceDraw] * Tr[replica->position() + replica->anchor()] * Tr[replica] * Tr[origin2anchor].inverse() * S[contentsScale].inverse() // // The replica draw transform to the root (screen space) origin is: // M[replica2root] = M[surface2root] * Tr[replica->position()] * Tr[replica] * Tr[origin2anchor].inverse() // // 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 calcDrawProperties. if (!isRootLayer(layer) && subtreeShouldBeSkipped(layer)) return; // As this function proceeds, these are the properties for the current // layer that actually get computed. To avoid unnecessary copies // (particularly for matrices), we do computations directly on these values // when possible. DrawProperties& layerDrawProperties = layer->drawProperties(); gfx::Rect clipRectForSubtree; bool subtreeShouldBeClipped = false; // This value is cached on the stack so that we don't have to inverse-project // the surface's clipRect redundantly for every layer. This value is the // same as the surface's clipRect, except that instead of being described // in the target surface space (i.e. the ancestor surface space), it is // described in the current surface space. gfx::Rect clipRectForSubtreeInDescendantSpace; float accumulatedDrawOpacity = layer->opacity(); bool animatingOpacityToTarget = layer->opacityIsAnimating(); bool animatingOpacityToScreen = animatingOpacityToTarget; if (layer->parent()) { accumulatedDrawOpacity *= layer->parent()->drawOpacity(); animatingOpacityToTarget |= layer->parent()->drawOpacityIsAnimating(); animatingOpacityToScreen |= layer->parent()->screenSpaceOpacityIsAnimating(); } bool animatingTransformToTarget = layer->transformIsAnimating(); bool animatingTransformToScreen = animatingTransformToTarget; if (layer->parent()) { animatingTransformToTarget |= layer->parent()->drawTransformIsAnimating(); animatingTransformToScreen |= layer->parent()->screenSpaceTransformIsAnimating(); } gfx::Size bounds = layer->bounds(); gfx::PointF anchorPoint = layer->anchorPoint(); gfx::PointF position = layer->position() - layer->scrollDelta(); gfx::Transform combinedTransform = parentMatrix; if (!layer->transform().IsIdentity()) { // LT = Tr[origin] * Tr[origin2anchor] combinedTransform.Translate3d(position.x() + anchorPoint.x() * bounds.width(), position.y() + anchorPoint.y() * bounds.height(), layer->anchorPointZ()); // LT = Tr[origin] * Tr[origin2anchor] * M[layer] combinedTransform.PreconcatTransform(layer->transform()); // LT = Tr[origin] * Tr[origin2anchor] * M[layer] * Tr[anchor2origin] combinedTransform.Translate3d(-anchorPoint.x() * bounds.width(), -anchorPoint.y() * bounds.height(), -layer->anchorPointZ()); } else { combinedTransform.Translate(position.x(), position.y()); } // The layer's contentsSize is determined from the combinedTransform, which then informs the // layer's drawTransform. updateLayerContentsScale(layer, combinedTransform, deviceScaleFactor, pageScaleFactor, animatingTransformToScreen); // If there is a transformation from the impl thread then it should be at // the start of the combinedTransform, but we don't want it to affect the // computation of contentsScale above. // Note carefully: this is Concat, not Preconcat (implTransform * combinedTransform). combinedTransform.ConcatTransform(layer->implTransform()); if (layer->fixedToContainerLayer()) { // Special case: this layer is a composited fixed-position layer; we need to // explicitly compensate for all ancestors' nonzero scrollDeltas to keep this layer // fixed correctly. // Note carefully: this is Concat, not Preconcat (currentScrollCompensation * combinedTransform). combinedTransform.ConcatTransform(currentScrollCompensationMatrix); } // The drawTransform that gets computed below is effectively the layer's drawTransform, unless // the layer itself creates a renderSurface. In that case, the renderSurface re-parents the transforms. layerDrawProperties.target_space_transform = combinedTransform; // M[draw] = M[parent] * LT * S[layer2content] layerDrawProperties.target_space_transform.Scale(1.0 / layer->contentsScaleX(), 1.0 / layer->contentsScaleY()); // layerScreenSpaceTransform represents the transform between root layer's "screen space" and local content space. layerDrawProperties.screen_space_transform = fullHierarchyMatrix; if (!layer->preserves3D()) MathUtil::flattenTransformTo2d(layerDrawProperties.screen_space_transform); layerDrawProperties.screen_space_transform.PreconcatTransform(layerDrawProperties.target_space_transform); // Adjusting text AA method during animation may cause repaints, which in-turn causes jank. bool adjustTextAA = !animatingOpacityToScreen && !animatingTransformToScreen; // To avoid color fringing, LCD text should only be used on opaque layers with just integral translation. bool layerCanUseLCDText = subtreeCanUseLCDText && (accumulatedDrawOpacity == 1.0) && layerDrawProperties.target_space_transform.IsIdentityOrIntegerTranslation(); gfx::RectF contentRect(gfx::PointF(), layer->contentBounds()); // fullHierarchyMatrix is the matrix that transforms objects between screen space (except projection matrix) and the most recent RenderSurfaceImpl's space. // nextHierarchyMatrix will only change if this layer uses a new RenderSurfaceImpl, otherwise remains the same. gfx::Transform nextHierarchyMatrix = fullHierarchyMatrix; gfx::Transform sublayerMatrix; gfx::Vector2dF renderSurfaceSublayerScale = MathUtil::computeTransform2dScaleComponents(combinedTransform, deviceScaleFactor * pageScaleFactor); if (subtreeShouldRenderToSeparateSurface(layer, combinedTransform.IsScaleOrTranslation())) { // 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->clearLayerLists(); // The owning layer's draw transform has a scale from content to layer // space which we do not want; so here we use the combinedTransform // instead of the drawTransform. However, we do need to add a different // scale factor that accounts for the surface's pixel dimensions. combinedTransform.Scale(1 / renderSurfaceSublayerScale.x(), 1 / renderSurfaceSublayerScale.y()); renderSurface->setDrawTransform(combinedTransform); // The owning layer's transform was re-parented by the surface, so the layer's new drawTransform // only needs to scale the layer to surface space. layerDrawProperties.target_space_transform.MakeIdentity(); layerDrawProperties.target_space_transform.Scale(renderSurfaceSublayerScale.x() / layer->contentsScaleX(), renderSurfaceSublayerScale.y() / layer->contentsScaleY()); // Inside the surface's subtree, we scale everything to the owning layer's scale. // The sublayer matrix transforms centered layer rects into target // surface content space. DCHECK(sublayerMatrix.IsIdentity()); sublayerMatrix.Scale(renderSurfaceSublayerScale.x(), renderSurfaceSublayerScale.y()); // The opacity value is moved from the layer to its surface, so that the entire subtree properly inherits opacity. renderSurface->setDrawOpacity(accumulatedDrawOpacity); renderSurface->setDrawOpacityIsAnimating(animatingOpacityToTarget); animatingOpacityToTarget = false; layerDrawProperties.opacity = 1; layerDrawProperties.opacity_is_animating = animatingOpacityToTarget; layerDrawProperties.screen_space_opacity_is_animating = animatingOpacityToScreen; renderSurface->setTargetSurfaceTransformsAreAnimating(animatingTransformToTarget); renderSurface->setScreenSpaceTransformsAreAnimating(animatingTransformToScreen); animatingTransformToTarget = false; layerDrawProperties.target_space_transform_is_animating = animatingTransformToTarget; layerDrawProperties.screen_space_transform_is_animating = animatingTransformToScreen; // Update the aggregate hierarchy matrix to include the transform of the // newly created RenderSurfaceImpl. nextHierarchyMatrix.PreconcatTransform(renderSurface->drawTransform()); // The new renderSurface here will correctly clip the entire subtree. So, we do // not need to continue propagating the clipping state further down the tree. This // way, we can avoid transforming clipRects from ancestor target surface space to // current target surface space that could cause more w < 0 headaches. subtreeShouldBeClipped = false; if (layer->maskLayer()) { DrawProperties& maskLayerDrawProperties = layer->maskLayer()->drawProperties(); maskLayerDrawProperties.render_target = layer; maskLayerDrawProperties.visible_content_rect = gfx::Rect(gfx::Point(), layer->contentBounds()); } if (layer->replicaLayer() && layer->replicaLayer()->maskLayer()) { DrawProperties& replicaMaskDrawProperties = layer->replicaLayer()->maskLayer()->drawProperties(); replicaMaskDrawProperties.render_target = layer; replicaMaskDrawProperties.visible_content_rect = gfx::Rect(gfx::Point(), layer->contentBounds()); } // FIXME: make this smarter for the SkImageFilter case (check for // pixel-moving filters) if (layer->filters().hasFilterThatMovesPixels() || layer->filter()) nearestAncestorThatMovesPixels = renderSurface; // The render surface clipRect is expressed in the space where this surface draws, i.e. the same space as clipRectFromAncestor. renderSurface->setIsClipped(ancestorClipsSubtree); if (ancestorClipsSubtree) { renderSurface->setClipRect(clipRectFromAncestor); gfx::Transform inverseSurfaceDrawTransform(gfx::Transform::kSkipInitialization); if (!renderSurface->drawTransform().GetInverse(&inverseSurfaceDrawTransform)) { // TODO(shawnsingh): Either we need to handle uninvertible transforms // here, or DCHECK that the transform is invertible. } clipRectForSubtreeInDescendantSpace = gfx::ToEnclosingRect(MathUtil::projectClippedRect(inverseSurfaceDrawTransform, renderSurface->clipRect())); } else { renderSurface->setClipRect(gfx::Rect()); clipRectForSubtreeInDescendantSpace = clipRectFromAncestorInDescendantSpace; } renderSurface->setNearestAncestorThatMovesPixels(nearestAncestorThatMovesPixels); // If the new render surface is drawn translucent or with a non-integral translation // then the subtree that gets drawn on this render surface cannot use LCD text. subtreeCanUseLCDText = layerCanUseLCDText; renderSurfaceLayerList.push_back(layer); } else { DCHECK(layer->parent()); // Note: layerDrawProperties.target_space_transform is computed above, // before this if-else statement. layerDrawProperties.target_space_transform_is_animating = animatingTransformToTarget; layerDrawProperties.screen_space_transform_is_animating = animatingTransformToScreen; layerDrawProperties.opacity = accumulatedDrawOpacity; layerDrawProperties.opacity_is_animating = animatingOpacityToTarget; layerDrawProperties.screen_space_opacity_is_animating = animatingOpacityToScreen; sublayerMatrix = combinedTransform; layer->clearRenderSurface(); // Layers without renderSurfaces directly inherit the ancestor's clip status. subtreeShouldBeClipped = ancestorClipsSubtree; if (ancestorClipsSubtree) clipRectForSubtree = clipRectFromAncestor; // The surface's cached clipRect value propagates regardless of what clipping goes on between layers here. clipRectForSubtreeInDescendantSpace = clipRectFromAncestorInDescendantSpace; // Layers that are not their own renderTarget will render into the target of their nearest ancestor. layerDrawProperties.render_target = layer->parent()->renderTarget(); } if (adjustTextAA) layerDrawProperties.can_use_lcd_text = layerCanUseLCDText; gfx::Rect rectInTargetSpace = ToEnclosingRect(MathUtil::mapClippedRect(layer->drawTransform(), contentRect)); if (layerClipsSubtree(layer)) { subtreeShouldBeClipped = true; if (ancestorClipsSubtree && !layer->renderSurface()) { clipRectForSubtree = clipRectFromAncestor; clipRectForSubtree.Intersect(rectInTargetSpace); } else clipRectForSubtree = rectInTargetSpace; } // Flatten to 2D if the layer doesn't preserve 3D. if (!layer->preserves3D()) MathUtil::flattenTransformTo2d(sublayerMatrix); // Apply the sublayer transform at the center of the layer. if (!layer->sublayerTransform().IsIdentity()) { sublayerMatrix.Translate(0.5 * bounds.width(), 0.5 * bounds.height()); sublayerMatrix.PreconcatTransform(layer->sublayerTransform()); sublayerMatrix.Translate(-0.5 * bounds.width(), -0.5 * bounds.height()); } LayerList& descendants = (layer->renderSurface() ? layer->renderSurface()->layerList() : layerList); // Any layers that are appended after this point are in the layer's subtree and should be included in the sorting process. unsigned sortingStartIndex = descendants.size(); if (!layerShouldBeSkipped(layer)) descendants.push_back(layer); gfx::Transform nextScrollCompensationMatrix = computeScrollCompensationMatrixForChildren(layer, parentMatrix, currentScrollCompensationMatrix);; gfx::Rect accumulatedDrawableContentRectOfChildren; for (size_t i = 0; i < layer->children().size(); ++i) { LayerType* child = LayerTreeHostCommon::getChildAsRawPtr(layer->children(), i); gfx::Rect drawableContentRectOfChildSubtree; calculateDrawPropertiesInternal(child, sublayerMatrix, nextHierarchyMatrix, nextScrollCompensationMatrix, clipRectForSubtree, clipRectForSubtreeInDescendantSpace, subtreeShouldBeClipped, nearestAncestorThatMovesPixels, renderSurfaceLayerList, descendants, layerSorter, maxTextureSize, deviceScaleFactor, pageScaleFactor, subtreeCanUseLCDText, drawableContentRectOfChildSubtree); if (!drawableContentRectOfChildSubtree.IsEmpty()) { accumulatedDrawableContentRectOfChildren.Union(drawableContentRectOfChildSubtree); if (child->renderSurface()) descendants.push_back(child); } } if (layer->renderSurface() && !isRootLayer(layer) && !layer->renderSurface()->layerList().size()) { removeSurfaceForEarlyExit(layer, renderSurfaceLayerList); return; } // Compute the total drawableContentRect for this subtree (the rect is in targetSurface space) gfx::Rect localDrawableContentRectOfSubtree = accumulatedDrawableContentRectOfChildren; if (layer->drawsContent()) localDrawableContentRectOfSubtree.Union(rectInTargetSpace); if (subtreeShouldBeClipped) localDrawableContentRectOfSubtree.Intersect(clipRectForSubtree); // Compute the layer's drawable content rect (the rect is in targetSurface space) layerDrawProperties.drawable_content_rect = rectInTargetSpace; if (subtreeShouldBeClipped) layerDrawProperties.drawable_content_rect.Intersect(clipRectForSubtree); // Tell the layer the rect that is clipped by. In theory we could use a // tighter clipRect here (drawableContentRect), but that actually does not // reduce how much would be drawn, and instead it would create unnecessary // changes to scissor state affecting GPU performance. layerDrawProperties.is_clipped = subtreeShouldBeClipped; if (subtreeShouldBeClipped) layerDrawProperties.clip_rect = clipRectForSubtree; else { // Initialize the clipRect to a safe value that will not clip the // layer, just in case clipping is still accidentally used. layerDrawProperties.clip_rect = rectInTargetSpace; } // Compute the layer's visible content rect (the rect is in content space) layerDrawProperties.visible_content_rect = calculateVisibleContentRect(layer, clipRectForSubtreeInDescendantSpace, rectInTargetSpace); // Compute the remaining properties for the render surface, if the layer has one. if (isRootLayer(layer)) { // The root layer's surface's contentRect is always the entire viewport. DCHECK(layer->renderSurface()); layer->renderSurface()->setContentRect(clipRectFromAncestor); } else if (layer->renderSurface() && !isRootLayer(layer)) { RenderSurfaceType* renderSurface = layer->renderSurface(); gfx::Rect clippedContentRect = localDrawableContentRectOfSubtree; // Don't clip if the layer is reflected as the reflection shouldn't be // clipped. If the layer is animating, then the surface's transform to // its target is not known on the main thread, and we should not use it // to clip. if (!layer->replicaLayer() && transformToParentIsKnown(layer)) { // Note, it is correct to use ancestorClipsSubtree here, because we are looking at this layer's renderSurface, not the layer itself. if (ancestorClipsSubtree && !clippedContentRect.IsEmpty()) { gfx::Rect surfaceClipRect = LayerTreeHostCommon::calculateVisibleRect(renderSurface->clipRect(), clippedContentRect, renderSurface->drawTransform()); clippedContentRect.Intersect(surfaceClipRect); } } // The RenderSurfaceImpl backing texture cannot exceed the maximum supported // texture size. clippedContentRect.set_width(std::min(clippedContentRect.width(), maxTextureSize)); clippedContentRect.set_height(std::min(clippedContentRect.height(), maxTextureSize)); if (clippedContentRect.IsEmpty()) { renderSurface->clearLayerLists(); removeSurfaceForEarlyExit(layer, renderSurfaceLayerList); return; } renderSurface->setContentRect(clippedContentRect); // The owning layer's screenSpaceTransform has a scale from content to layer space which we need to undo and // replace with a scale from the surface's subtree into layer space. gfx::Transform screenSpaceTransform = layer->screenSpaceTransform(); screenSpaceTransform.Scale(layer->contentsScaleX() / renderSurfaceSublayerScale.x(), layer->contentsScaleY() / renderSurfaceSublayerScale.y()); renderSurface->setScreenSpaceTransform(screenSpaceTransform); if (layer->replicaLayer()) { gfx::Transform surfaceOriginToReplicaOriginTransform; surfaceOriginToReplicaOriginTransform.Scale(renderSurfaceSublayerScale.x(), renderSurfaceSublayerScale.y()); surfaceOriginToReplicaOriginTransform.Translate(layer->replicaLayer()->position().x() + layer->replicaLayer()->anchorPoint().x() * bounds.width(), layer->replicaLayer()->position().y() + layer->replicaLayer()->anchorPoint().y() * bounds.height()); surfaceOriginToReplicaOriginTransform.PreconcatTransform(layer->replicaLayer()->transform()); surfaceOriginToReplicaOriginTransform.Translate(-layer->replicaLayer()->anchorPoint().x() * bounds.width(), -layer->replicaLayer()->anchorPoint().y() * bounds.height()); surfaceOriginToReplicaOriginTransform.Scale(1 / renderSurfaceSublayerScale.x(), 1 / renderSurfaceSublayerScale.y()); // Compute the replica's "originTransform" that maps from the replica's origin space to the target surface origin space. gfx::Transform replicaOriginTransform = layer->renderSurface()->drawTransform() * surfaceOriginToReplicaOriginTransform; renderSurface->setReplicaDrawTransform(replicaOriginTransform); // Compute the replica's "screenSpaceTransform" that maps from the replica's origin space to the screen's origin space. gfx::Transform replicaScreenSpaceTransform = layer->renderSurface()->screenSpaceTransform() * surfaceOriginToReplicaOriginTransform; renderSurface->setReplicaScreenSpaceTransform(replicaScreenSpaceTransform); } } markLayerAsUpdated(layer); // If neither this layer nor any of its children were added, early out. if (sortingStartIndex == descendants.size()) return; // If preserves-3d then sort all the descendants in 3D so that they can be // 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 (layerSorter && descendants.size() && layer->preserves3D() && (!layer->parent() || !layer->parent()->preserves3D())) sortLayers(descendants.begin() + sortingStartIndex, descendants.end(), layerSorter); if (layer->renderSurface()) drawableContentRectOfSubtree = gfx::ToEnclosingRect(layer->renderSurface()->drawableContentRect()); else drawableContentRectOfSubtree = localDrawableContentRectOfSubtree; if (layer->hasContributingDelegatedRenderPasses()) layer->renderTarget()->renderSurface()->addContributingDelegatedRenderPassLayer(layer); } void LayerTreeHostCommon::calculateDrawProperties(Layer* rootLayer, const gfx::Size& deviceViewportSize, float deviceScaleFactor, float pageScaleFactor, int maxTextureSize, bool canUseLCDText, std::vector >& renderSurfaceLayerList) { gfx::Rect totalDrawableContentRect; gfx::Transform identityMatrix; gfx::Transform deviceScaleTransform; deviceScaleTransform.Scale(deviceScaleFactor, deviceScaleFactor); std::vector > dummyLayerList; // The root layer's renderSurface should receive the deviceViewport as the initial clipRect. bool subtreeShouldBeClipped = true; gfx::Rect deviceViewportRect(gfx::Point(), deviceViewportSize); // This function should have received a root layer. DCHECK(isRootLayer(rootLayer)); preCalculateMetaInformation(rootLayer); calculateDrawPropertiesInternal >, RenderSurface>( rootLayer, deviceScaleTransform, identityMatrix, identityMatrix, deviceViewportRect, deviceViewportRect, subtreeShouldBeClipped, 0, renderSurfaceLayerList, dummyLayerList, 0, maxTextureSize, deviceScaleFactor, pageScaleFactor, canUseLCDText, totalDrawableContentRect); // The dummy layer list should not have been used. DCHECK(dummyLayerList.size() == 0); // A root layer renderSurface should always exist after calculateDrawProperties. DCHECK(rootLayer->renderSurface()); } void LayerTreeHostCommon::calculateDrawProperties(LayerImpl* rootLayer, const gfx::Size& deviceViewportSize, float deviceScaleFactor, float pageScaleFactor, int maxTextureSize, bool canUseLCDText, std::vector& renderSurfaceLayerList) { gfx::Rect totalDrawableContentRect; gfx::Transform identityMatrix; gfx::Transform deviceScaleTransform; deviceScaleTransform.Scale(deviceScaleFactor, deviceScaleFactor); std::vector dummyLayerList; LayerSorter layerSorter; // The root layer's renderSurface should receive the deviceViewport as the initial clipRect. bool subtreeShouldBeClipped = true; gfx::Rect deviceViewportRect(gfx::Point(), deviceViewportSize); // This function should have received a root layer. DCHECK(isRootLayer(rootLayer)); preCalculateMetaInformation(rootLayer); calculateDrawPropertiesInternal, RenderSurfaceImpl>( rootLayer, deviceScaleTransform, identityMatrix, identityMatrix, deviceViewportRect, deviceViewportRect, subtreeShouldBeClipped, 0, renderSurfaceLayerList, dummyLayerList, &layerSorter, maxTextureSize, deviceScaleFactor, pageScaleFactor, canUseLCDText, totalDrawableContentRect); // The dummy layer list should not have been used. DCHECK(dummyLayerList.size() == 0); // A root layer renderSurface should always exist after calculateDrawProperties. DCHECK(rootLayer->renderSurface()); } static bool pointHitsRect(const gfx::PointF& screenSpacePoint, const gfx::Transform& localSpaceToScreenSpaceTransform, gfx::RectF localSpaceRect) { // If the transform is not invertible, then assume that this point doesn't hit this rect. gfx::Transform inverseLocalSpaceToScreenSpace(gfx::Transform::kSkipInitialization); if (!localSpaceToScreenSpaceTransform.GetInverse(&inverseLocalSpaceToScreenSpace)) return false; // Transform the hit test point from screen space to the local space of the given rect. bool clipped = false; gfx::PointF hitTestPointInLocalSpace = MathUtil::projectPoint(inverseLocalSpaceToScreenSpace, screenSpacePoint, clipped); // If projectPoint could not project to a valid value, then we assume that this point doesn't hit this rect. if (clipped) return false; return localSpaceRect.Contains(hitTestPointInLocalSpace); } static bool pointHitsRegion(gfx::PointF screenSpacePoint, const gfx::Transform& screenSpaceTransform, const Region& layerSpaceRegion, float layerContentScaleX, float layerContentScaleY) { // If the transform is not invertible, then assume that this point doesn't hit this region. gfx::Transform inverseScreenSpaceTransform(gfx::Transform::kSkipInitialization); if (!screenSpaceTransform.GetInverse(&inverseScreenSpaceTransform)) return false; // Transform the hit test point from screen space to the local space of the given region. bool clipped = false; gfx::PointF hitTestPointInContentSpace = MathUtil::projectPoint(inverseScreenSpaceTransform, screenSpacePoint, clipped); gfx::PointF hitTestPointInLayerSpace = gfx::ScalePoint(hitTestPointInContentSpace, 1 / layerContentScaleX, 1 / layerContentScaleY); // If projectPoint could not project to a valid value, then we assume that this point doesn't hit this region. if (clipped) return false; return layerSpaceRegion.Contains(gfx::ToRoundedPoint(hitTestPointInLayerSpace)); } static bool pointIsClippedBySurfaceOrClipRect(const gfx::PointF& screenSpacePoint, LayerImpl* layer) { LayerImpl* currentLayer = layer; // Walk up the layer tree and hit-test any renderSurfaces and any layer clipRects that are active. while (currentLayer) { if (currentLayer->renderSurface() && !pointHitsRect(screenSpacePoint, currentLayer->renderSurface()->screenSpaceTransform(), currentLayer->renderSurface()->contentRect())) return true; // Note that drawableContentRects are actually in targetSurface space, so the transform we // have to provide is the target surface's screenSpaceTransform. LayerImpl* renderTarget = currentLayer->renderTarget(); if (layerClipsSubtree(currentLayer) && !pointHitsRect(screenSpacePoint, renderTarget->renderSurface()->screenSpaceTransform(), currentLayer->drawableContentRect())) return true; currentLayer = currentLayer->parent(); } // If we have finished walking all ancestors without having already exited, then the point is not clipped by any ancestors. return false; } LayerImpl* LayerTreeHostCommon::findLayerThatIsHitByPoint(const gfx::PointF& screenSpacePoint, std::vector& renderSurfaceLayerList) { LayerImpl* foundLayer = 0; typedef LayerIterator, RenderSurfaceImpl, LayerIteratorActions::FrontToBack> LayerIteratorType; LayerIteratorType end = LayerIteratorType::end(&renderSurfaceLayerList); for (LayerIteratorType it = LayerIteratorType::begin(&renderSurfaceLayerList); it != end; ++it) { // We don't want to consider renderSurfaces for hit testing. if (!it.representsItself()) continue; LayerImpl* currentLayer = (*it); gfx::RectF contentRect(gfx::PointF(), currentLayer->contentBounds()); if (!pointHitsRect(screenSpacePoint, currentLayer->screenSpaceTransform(), contentRect)) continue; // At this point, we think the point does hit 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, currentLayer)) continue; 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; } LayerImpl* LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(const gfx::PointF& screenSpacePoint, std::vector& renderSurfaceLayerList) { LayerImpl* foundLayer = 0; typedef LayerIterator, RenderSurfaceImpl, LayerIteratorActions::FrontToBack> LayerIteratorType; LayerIteratorType end = LayerIteratorType::end(&renderSurfaceLayerList); for (LayerIteratorType it = LayerIteratorType::begin(&renderSurfaceLayerList); it != end; ++it) { // We don't want to consider renderSurfaces for hit testing. if (!it.representsItself()) continue; LayerImpl* currentLayer = (*it); if (!layerHasTouchEventHandlersAt(screenSpacePoint, currentLayer)) continue; 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; } bool LayerTreeHostCommon::layerHasTouchEventHandlersAt(const gfx::PointF& screenSpacePoint, LayerImpl* layerImpl) { if (layerImpl->touchEventHandlerRegion().IsEmpty()) return false; if (!pointHitsRegion(screenSpacePoint, layerImpl->screenSpaceTransform(), layerImpl->touchEventHandlerRegion(), layerImpl->contentsScaleX(), layerImpl->contentsScaleY())) return false;; // 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