| Index: cc/trees/layer_tree_host_common.cc
|
| diff --git a/cc/trees/layer_tree_host_common.cc b/cc/trees/layer_tree_host_common.cc
|
| deleted file mode 100644
|
| index aa115f722648acc87a848bae40f36ff35eee9116..0000000000000000000000000000000000000000
|
| --- a/cc/trees/layer_tree_host_common.cc
|
| +++ /dev/null
|
| @@ -1,2566 +0,0 @@
|
| -// 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/trees/layer_tree_host_common.h"
|
| -
|
| -#include <algorithm>
|
| -
|
| -#include "base/trace_event/trace_event.h"
|
| -#include "cc/base/math_util.h"
|
| -#include "cc/layers/heads_up_display_layer_impl.h"
|
| -#include "cc/layers/layer.h"
|
| -#include "cc/layers/layer_impl.h"
|
| -#include "cc/layers/layer_iterator.h"
|
| -#include "cc/layers/render_surface.h"
|
| -#include "cc/layers/render_surface_impl.h"
|
| -#include "cc/trees/draw_property_utils.h"
|
| -#include "cc/trees/layer_tree_host.h"
|
| -#include "cc/trees/layer_tree_impl.h"
|
| -#include "ui/gfx/geometry/rect_conversions.h"
|
| -#include "ui/gfx/geometry/vector2d_conversions.h"
|
| -#include "ui/gfx/transform.h"
|
| -#include "ui/gfx/transform_util.h"
|
| -
|
| -namespace cc {
|
| -
|
| -ScrollAndScaleSet::ScrollAndScaleSet()
|
| - : page_scale_delta(1.f), top_controls_delta(0.f) {
|
| -}
|
| -
|
| -ScrollAndScaleSet::~ScrollAndScaleSet() {}
|
| -
|
| -template <typename LayerType>
|
| -static gfx::Vector2dF GetEffectiveScrollDelta(LayerType* layer) {
|
| - // Layer's scroll offset can have an integer part and fractional part.
|
| - // Due to Blink's limitation, it only counter-scrolls the position-fixed
|
| - // layer using the integer part of Layer's scroll offset.
|
| - // CC scrolls the layer using the full scroll offset, so we have to
|
| - // add the ScrollCompensationAdjustment (fractional part of the scroll
|
| - // offset) to the effective scroll delta which is used to counter-scroll
|
| - // the position-fixed layer.
|
| - gfx::Vector2dF scroll_delta =
|
| - layer->ScrollDelta() + layer->ScrollCompensationAdjustment();
|
| - // The scroll parent's scroll delta is the amount we've scrolled on the
|
| - // compositor thread since the commit for this layer tree's source frame.
|
| - // we last reported to the main thread. I.e., it's the discrepancy between
|
| - // a scroll parent's scroll delta and offset, so we must add it here.
|
| - if (layer->scroll_parent())
|
| - scroll_delta += layer->scroll_parent()->ScrollDelta() +
|
| - layer->ScrollCompensationAdjustment();
|
| - return scroll_delta;
|
| -}
|
| -
|
| -template <typename LayerType>
|
| -static gfx::ScrollOffset GetEffectiveCurrentScrollOffset(LayerType* layer) {
|
| - gfx::ScrollOffset offset = layer->CurrentScrollOffset();
|
| - // The scroll parent's total scroll offset (scroll offset + scroll delta)
|
| - // can't be used because its scroll offset has already been applied to the
|
| - // scroll children's positions by the main thread layer positioning code.
|
| - if (layer->scroll_parent())
|
| - offset += gfx::ScrollOffset(layer->scroll_parent()->ScrollDelta());
|
| - return offset;
|
| -}
|
| -
|
| -inline gfx::Rect CalculateVisibleRectWithCachedLayerRect(
|
| - const gfx::Rect& target_surface_rect,
|
| - const gfx::Rect& layer_bound_rect,
|
| - const gfx::Rect& layer_rect_in_target_space,
|
| - const gfx::Transform& transform) {
|
| - if (layer_rect_in_target_space.IsEmpty())
|
| - return gfx::Rect();
|
| -
|
| - // Is this layer fully contained within the target surface?
|
| - if (target_surface_rect.Contains(layer_rect_in_target_space))
|
| - return layer_bound_rect;
|
| -
|
| - // 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 minimal_surface_rect = target_surface_rect;
|
| - minimal_surface_rect.Intersect(layer_rect_in_target_space);
|
| -
|
| - if (minimal_surface_rect.IsEmpty())
|
| - return gfx::Rect();
|
| -
|
| - // 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 surface_to_layer(gfx::Transform::kSkipInitialization);
|
| - if (!transform.GetInverse(&surface_to_layer)) {
|
| - // Because we cannot use the surface bounds to determine what portion of
|
| - // the layer is visible, we must conservatively assume the full layer is
|
| - // visible.
|
| - return layer_bound_rect;
|
| - }
|
| -
|
| - gfx::Rect layer_rect = MathUtil::ProjectEnclosingClippedRect(
|
| - surface_to_layer, minimal_surface_rect);
|
| - layer_rect.Intersect(layer_bound_rect);
|
| - return layer_rect;
|
| -}
|
| -
|
| -gfx::Rect LayerTreeHostCommon::CalculateVisibleRect(
|
| - const gfx::Rect& target_surface_rect,
|
| - const gfx::Rect& layer_bound_rect,
|
| - const gfx::Transform& transform) {
|
| - gfx::Rect layer_in_surface_space =
|
| - MathUtil::MapEnclosingClippedRect(transform, layer_bound_rect);
|
| - return CalculateVisibleRectWithCachedLayerRect(
|
| - target_surface_rect, layer_bound_rect, layer_in_surface_space, transform);
|
| -}
|
| -
|
| -template <typename LayerType>
|
| -static LayerType* NextTargetSurface(LayerType* layer) {
|
| - return layer->parent() ? layer->parent()->render_target() : 0;
|
| -}
|
| -
|
| -// Given two layers, this function finds their respective render targets and,
|
| -// computes a change of basis translation. It does this by accumulating the
|
| -// translation components of the draw transforms of each target between the
|
| -// ancestor and descendant. These transforms must be 2D translations, and this
|
| -// requirement is enforced at every step.
|
| -template <typename LayerType>
|
| -static gfx::Vector2dF ComputeChangeOfBasisTranslation(
|
| - const LayerType& ancestor_layer,
|
| - const LayerType& descendant_layer) {
|
| - DCHECK(descendant_layer.HasAncestor(&ancestor_layer));
|
| - const LayerType* descendant_target = descendant_layer.render_target();
|
| - DCHECK(descendant_target);
|
| - const LayerType* ancestor_target = ancestor_layer.render_target();
|
| - DCHECK(ancestor_target);
|
| -
|
| - gfx::Vector2dF translation;
|
| - for (const LayerType* target = descendant_target; target != ancestor_target;
|
| - target = NextTargetSurface(target)) {
|
| - const gfx::Transform& trans = target->render_surface()->draw_transform();
|
| - // Ensure that this translation is truly 2d.
|
| - DCHECK(trans.IsIdentityOrTranslation());
|
| - DCHECK_EQ(0.f, trans.matrix().get(2, 3));
|
| - translation += trans.To2dTranslation();
|
| - }
|
| -
|
| - return translation;
|
| -}
|
| -
|
| -enum TranslateRectDirection {
|
| - TRANSLATE_RECT_DIRECTION_TO_ANCESTOR,
|
| - TRANSLATE_RECT_DIRECTION_TO_DESCENDANT
|
| -};
|
| -
|
| -template <typename LayerType>
|
| -static gfx::Rect TranslateRectToTargetSpace(const LayerType& ancestor_layer,
|
| - const LayerType& descendant_layer,
|
| - const gfx::Rect& rect,
|
| - TranslateRectDirection direction) {
|
| - gfx::Vector2dF translation = ComputeChangeOfBasisTranslation<LayerType>(
|
| - ancestor_layer, descendant_layer);
|
| - if (direction == TRANSLATE_RECT_DIRECTION_TO_DESCENDANT)
|
| - translation.Scale(-1.f);
|
| - return gfx::ToEnclosingRect(
|
| - gfx::RectF(rect.origin() + translation, rect.size()));
|
| -}
|
| -
|
| -// Attempts to update the clip rects for the given layer. If the layer has a
|
| -// clip_parent, it may not inherit its immediate ancestor's clip.
|
| -template <typename LayerType>
|
| -static void UpdateClipRectsForClipChild(
|
| - const LayerType* layer,
|
| - gfx::Rect* clip_rect_in_parent_target_space,
|
| - bool* subtree_should_be_clipped) {
|
| - // If the layer has no clip_parent, or the ancestor is the same as its actual
|
| - // parent, then we don't need special clip rects. Bail now and leave the out
|
| - // parameters untouched.
|
| - const LayerType* clip_parent = layer->scroll_parent();
|
| -
|
| - if (!clip_parent)
|
| - clip_parent = layer->clip_parent();
|
| -
|
| - if (!clip_parent || clip_parent == layer->parent())
|
| - return;
|
| -
|
| - // The root layer is never a clip child.
|
| - DCHECK(layer->parent());
|
| -
|
| - // Grab the cached values.
|
| - *clip_rect_in_parent_target_space = clip_parent->clip_rect();
|
| - *subtree_should_be_clipped = clip_parent->is_clipped();
|
| -
|
| - // We may have to project the clip rect into our parent's target space. Note,
|
| - // it must be our parent's target space, not ours. For one, we haven't
|
| - // computed our transforms, so we couldn't put it in our space yet even if we
|
| - // wanted to. But more importantly, this matches the expectations of
|
| - // CalculateDrawPropertiesInternal. If we, say, create a render surface, these
|
| - // clip rects will want to be in its target space, not ours.
|
| - if (clip_parent == layer->clip_parent()) {
|
| - *clip_rect_in_parent_target_space = TranslateRectToTargetSpace<LayerType>(
|
| - *clip_parent, *layer->parent(), *clip_rect_in_parent_target_space,
|
| - TRANSLATE_RECT_DIRECTION_TO_DESCENDANT);
|
| - } else {
|
| - // If we're being clipped by our scroll parent, we must translate through
|
| - // our common ancestor. This happens to be our parent, so it is sufficent to
|
| - // translate from our clip parent's space to the space of its ancestor (our
|
| - // parent).
|
| - *clip_rect_in_parent_target_space = TranslateRectToTargetSpace<LayerType>(
|
| - *layer->parent(), *clip_parent, *clip_rect_in_parent_target_space,
|
| - TRANSLATE_RECT_DIRECTION_TO_ANCESTOR);
|
| - }
|
| -}
|
| -
|
| -// We collect an accumulated drawable content rect per render surface.
|
| -// Typically, a layer will contribute to only one surface, the surface
|
| -// associated with its render target. Clip children, however, may affect
|
| -// several surfaces since there may be several surfaces between the clip child
|
| -// and its parent.
|
| -//
|
| -// NB: we accumulate the layer's *clipped* drawable content rect.
|
| -template <typename LayerType>
|
| -struct AccumulatedSurfaceState {
|
| - explicit AccumulatedSurfaceState(LayerType* render_target)
|
| - : render_target(render_target) {}
|
| -
|
| - // The accumulated drawable content rect for the surface associated with the
|
| - // given |render_target|.
|
| - gfx::Rect drawable_content_rect;
|
| -
|
| - // The target owning the surface. (We hang onto the target rather than the
|
| - // surface so that we can DCHECK that the surface's draw transform is simply
|
| - // a translation when |render_target| reports that it has no unclipped
|
| - // descendants).
|
| - LayerType* render_target;
|
| -};
|
| -
|
| -template <typename LayerType>
|
| -void UpdateAccumulatedSurfaceState(
|
| - LayerType* layer,
|
| - const gfx::Rect& drawable_content_rect,
|
| - std::vector<AccumulatedSurfaceState<LayerType>>*
|
| - accumulated_surface_state) {
|
| - if (IsRootLayer(layer))
|
| - return;
|
| -
|
| - // We will apply our drawable content rect to the accumulated rects for all
|
| - // surfaces between us and |render_target| (inclusive). This is either our
|
| - // clip parent's target if we are a clip child, or else simply our parent's
|
| - // target. We use our parent's target because we're either the owner of a
|
| - // render surface and we'll want to add our rect to our *surface's* target, or
|
| - // we're not and our target is the same as our parent's. In both cases, the
|
| - // parent's target gives us what we want.
|
| - LayerType* render_target = layer->clip_parent()
|
| - ? layer->clip_parent()->render_target()
|
| - : layer->parent()->render_target();
|
| -
|
| - // If the layer owns a surface, then the content rect is in the wrong space.
|
| - // Instead, we will use the surface's DrawableContentRect which is in target
|
| - // space as required.
|
| - gfx::Rect target_rect = drawable_content_rect;
|
| - if (layer->render_surface()) {
|
| - target_rect =
|
| - gfx::ToEnclosedRect(layer->render_surface()->DrawableContentRect());
|
| - }
|
| -
|
| - if (render_target->is_clipped()) {
|
| - gfx::Rect clip_rect = render_target->clip_rect();
|
| - // If the layer has a clip parent, the clip rect may be in the wrong space,
|
| - // so we'll need to transform it before it is applied.
|
| - if (layer->clip_parent()) {
|
| - clip_rect = TranslateRectToTargetSpace<LayerType>(
|
| - *layer->clip_parent(), *layer, clip_rect,
|
| - TRANSLATE_RECT_DIRECTION_TO_DESCENDANT);
|
| - }
|
| - target_rect.Intersect(clip_rect);
|
| - }
|
| -
|
| - // We must have at least one entry in the vector for the root.
|
| - DCHECK_LT(0ul, accumulated_surface_state->size());
|
| -
|
| - typedef typename std::vector<AccumulatedSurfaceState<LayerType>>
|
| - AccumulatedSurfaceStateVector;
|
| - typedef typename AccumulatedSurfaceStateVector::reverse_iterator
|
| - AccumulatedSurfaceStateIterator;
|
| - AccumulatedSurfaceStateIterator current_state =
|
| - accumulated_surface_state->rbegin();
|
| -
|
| - // Add this rect to the accumulated content rect for all surfaces until we
|
| - // reach the target surface.
|
| - bool found_render_target = false;
|
| - for (; current_state != accumulated_surface_state->rend(); ++current_state) {
|
| - current_state->drawable_content_rect.Union(target_rect);
|
| -
|
| - // If we've reached |render_target| our work is done and we can bail.
|
| - if (current_state->render_target == render_target) {
|
| - found_render_target = true;
|
| - break;
|
| - }
|
| -
|
| - // Transform rect from the current target's space to the next.
|
| - LayerType* current_target = current_state->render_target;
|
| - DCHECK(current_target->render_surface());
|
| - const gfx::Transform& current_draw_transform =
|
| - current_target->render_surface()->draw_transform();
|
| -
|
| - // If we have unclipped descendants, the draw transform is a translation.
|
| - DCHECK(current_target->num_unclipped_descendants() == 0 ||
|
| - current_draw_transform.IsIdentityOrTranslation());
|
| -
|
| - target_rect = gfx::ToEnclosingRect(
|
| - MathUtil::MapClippedRect(current_draw_transform, target_rect));
|
| - }
|
| -
|
| - // It is an error to not reach |render_target|. If this happens, it means that
|
| - // either the clip parent is not an ancestor of the clip child or the surface
|
| - // state vector is empty, both of which should be impossible.
|
| - DCHECK(found_render_target);
|
| -}
|
| -
|
| -template <typename LayerType> static inline bool IsRootLayer(LayerType* layer) {
|
| - return !layer->parent();
|
| -}
|
| -
|
| -template <typename LayerType>
|
| -static inline bool LayerIsInExisting3DRenderingContext(LayerType* layer) {
|
| - return layer->Is3dSorted() && layer->parent() &&
|
| - layer->parent()->Is3dSorted() &&
|
| - (layer->parent()->sorting_context_id() == layer->sorting_context_id());
|
| -}
|
| -
|
| -template <typename LayerType>
|
| -static bool IsRootLayerOfNewRenderingContext(LayerType* layer) {
|
| - if (layer->parent())
|
| - return !layer->parent()->Is3dSorted() && layer->Is3dSorted();
|
| -
|
| - return layer->Is3dSorted();
|
| -}
|
| -
|
| -template <typename LayerType>
|
| -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->draw_transform().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 <typename LayerType>
|
| -static bool IsSurfaceBackFaceVisible(LayerType* layer,
|
| - const gfx::Transform& draw_transform) {
|
| - if (LayerIsInExisting3DRenderingContext(layer))
|
| - return draw_transform.IsBackFaceVisible();
|
| -
|
| - if (IsRootLayerOfNewRenderingContext(layer))
|
| - return layer->transform().IsBackFaceVisible();
|
| -
|
| - // If the render_surface 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->masks_to_bounds() || layer->mask_layer();
|
| -}
|
| -
|
| -template <typename LayerType>
|
| -static gfx::Rect CalculateVisibleContentRect(
|
| - LayerType* layer,
|
| - const gfx::Rect& clip_rect_of_target_surface_in_target_space,
|
| - const gfx::Rect& layer_rect_in_target_space) {
|
| - DCHECK(layer->render_target());
|
| -
|
| - // Nothing is visible if the layer bounds are empty.
|
| - if (!layer->DrawsContent() || layer->content_bounds().IsEmpty() ||
|
| - layer->drawable_content_rect().IsEmpty())
|
| - return gfx::Rect();
|
| -
|
| - // Compute visible bounds in target surface space.
|
| - gfx::Rect visible_rect_in_target_surface_space =
|
| - layer->drawable_content_rect();
|
| -
|
| - if (layer->render_target()->render_surface()->is_clipped()) {
|
| - // The |layer| L has a target T which owns a surface Ts. The surface Ts
|
| - // has a target TsT.
|
| - //
|
| - // In this case the target surface Ts does clip the layer L that contributes
|
| - // to it. So, we have to convert the clip rect of Ts from the target space
|
| - // of Ts (that is the space of TsT), to the current render target's space
|
| - // (that is the space of T). This conversion is done outside this function
|
| - // so that it can be cached instead of computing it redundantly for every
|
| - // layer.
|
| - visible_rect_in_target_surface_space.Intersect(
|
| - clip_rect_of_target_surface_in_target_space);
|
| - }
|
| -
|
| - if (visible_rect_in_target_surface_space.IsEmpty())
|
| - return gfx::Rect();
|
| -
|
| - return CalculateVisibleRectWithCachedLayerRect(
|
| - visible_rect_in_target_surface_space,
|
| - gfx::Rect(layer->content_bounds()),
|
| - layer_rect_in_target_space,
|
| - layer->draw_transform());
|
| -}
|
| -
|
| -static inline bool TransformToParentIsKnown(LayerImpl* layer) { return true; }
|
| -
|
| -static inline bool TransformToParentIsKnown(Layer* layer) {
|
| - return !layer->TransformIsAnimating();
|
| -}
|
| -
|
| -static inline bool TransformToScreenIsKnown(LayerImpl* layer) { return true; }
|
| -
|
| -static inline bool TransformToScreenIsKnown(Layer* layer) {
|
| - return !layer->screen_space_transform_is_animating();
|
| -}
|
| -
|
| -template <typename LayerType>
|
| -static bool LayerShouldBeSkipped(LayerType* layer, bool layer_is_drawn) {
|
| - // Layers can be skipped if any of these conditions are met.
|
| - // - is not drawn due to it or one of its ancestors being hidden (or having
|
| - // no copy requests).
|
| - // - 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 clip_rect is empty
|
| - // - the visible_content_rect 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_is_drawn)
|
| - return true;
|
| -
|
| - if (!layer->DrawsContent() || layer->bounds().IsEmpty())
|
| - return true;
|
| -
|
| - LayerType* backface_test_layer = layer;
|
| - if (layer->use_parent_backface_visibility()) {
|
| - DCHECK(layer->parent());
|
| - DCHECK(!layer->parent()->use_parent_backface_visibility());
|
| - backface_test_layer = 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 (!backface_test_layer->double_sided() &&
|
| - TransformToScreenIsKnown(backface_test_layer) &&
|
| - IsLayerBackFaceVisible(backface_test_layer))
|
| - return true;
|
| -
|
| - return false;
|
| -}
|
| -
|
| -template <typename LayerType>
|
| -static bool HasInvertibleOrAnimatedTransform(LayerType* layer) {
|
| - return layer->transform_is_invertible() || layer->TransformIsAnimating();
|
| -}
|
| -
|
| -static inline bool SubtreeShouldBeSkipped(LayerImpl* layer,
|
| - bool layer_is_drawn) {
|
| - // If the layer transform is not invertible, it should not be drawn.
|
| - // TODO(ajuma): Correctly process subtrees with singular transform for the
|
| - // case where we may animate to a non-singular transform and wish to
|
| - // pre-raster.
|
| - if (!HasInvertibleOrAnimatedTransform(layer))
|
| - return true;
|
| -
|
| - // When we need to do a readback/copy of a layer's output, we can not skip
|
| - // it or any of its ancestors.
|
| - if (layer->draw_properties().layer_or_descendant_has_copy_request)
|
| - return false;
|
| -
|
| - // We cannot skip the the subtree if a descendant has a wheel or touch handler
|
| - // or the hit testing code will break (it requires fresh transforms, etc).
|
| - if (layer->draw_properties().layer_or_descendant_has_input_handler)
|
| - return false;
|
| -
|
| - // If the layer is not drawn, then skip it and its subtree.
|
| - if (!layer_is_drawn)
|
| - return true;
|
| -
|
| - // If layer is on the pending tree and opacity is being animated then
|
| - // this subtree can't be skipped as we need to create, prioritize and
|
| - // include tiles for this layer when deciding if tree can be activated.
|
| - if (layer->layer_tree_impl()->IsPendingTree() && layer->OpacityIsAnimating())
|
| - return false;
|
| -
|
| - // 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, bool layer_is_drawn) {
|
| - // If the layer transform is not invertible, it should not be drawn.
|
| - if (!layer->transform_is_invertible() && !layer->TransformIsAnimating())
|
| - return true;
|
| -
|
| - // When we need to do a readback/copy of a layer's output, we can not skip
|
| - // it or any of its ancestors.
|
| - if (layer->draw_properties().layer_or_descendant_has_copy_request)
|
| - return false;
|
| -
|
| - // We cannot skip the the subtree if a descendant has a wheel or touch handler
|
| - // or the hit testing code will break (it requires fresh transforms, etc).
|
| - if (layer->draw_properties().layer_or_descendant_has_input_handler)
|
| - return false;
|
| -
|
| - // If the layer is not drawn, then skip it and its subtree.
|
| - if (!layer_is_drawn)
|
| - return true;
|
| -
|
| - // 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.
|
| - // Similarly, for layers that might animate opacity using an impl-only
|
| - // animation, their subtree should also not be skipped.
|
| - return !layer->opacity() && !layer->OpacityIsAnimating() &&
|
| - !layer->OpacityCanAnimateOnImplThread();
|
| -}
|
| -
|
| -static inline void SavePaintPropertiesLayer(LayerImpl* layer) {}
|
| -
|
| -static inline void SavePaintPropertiesLayer(Layer* layer) {
|
| - layer->SavePaintProperties();
|
| -
|
| - if (layer->mask_layer())
|
| - layer->mask_layer()->SavePaintProperties();
|
| - if (layer->replica_layer() && layer->replica_layer()->mask_layer())
|
| - layer->replica_layer()->mask_layer()->SavePaintProperties();
|
| -}
|
| -
|
| -static bool SubtreeShouldRenderToSeparateSurface(
|
| - Layer* layer,
|
| - bool axis_aligned_with_respect_to_parent) {
|
| - //
|
| - // A layer and its descendants should render onto a new RenderSurfaceImpl if
|
| - // any of these rules hold:
|
| - //
|
| -
|
| - // The root layer owns a render surface, but it never acts as a contributing
|
| - // surface to another render target. Compositor features that are applied via
|
| - // a contributing surface can not be applied to the root layer. In order to
|
| - // use these effects, another child of the root would need to be introduced
|
| - // in order to act as a contributing surface to the root layer's surface.
|
| - bool is_root = IsRootLayer(layer);
|
| -
|
| - // If the layer uses a mask.
|
| - if (layer->mask_layer()) {
|
| - DCHECK(!is_root);
|
| - return true;
|
| - }
|
| -
|
| - // If the layer has a reflection.
|
| - if (layer->replica_layer()) {
|
| - DCHECK(!is_root);
|
| - return true;
|
| - }
|
| -
|
| - // If the layer uses a CSS filter.
|
| - if (!layer->filters().IsEmpty() || !layer->background_filters().IsEmpty()) {
|
| - DCHECK(!is_root);
|
| - return true;
|
| - }
|
| -
|
| - // If the layer will use a CSS filter. In this case, the animation
|
| - // will start and add a filter to this layer, so it needs a surface.
|
| - if (layer->FilterIsAnimating()) {
|
| - DCHECK(!is_root);
|
| - return true;
|
| - }
|
| -
|
| - int num_descendants_that_draw_content =
|
| - layer->NumDescendantsThatDrawContent();
|
| -
|
| - // If the layer flattens its subtree, but it is treated as a 3D object by its
|
| - // parent (i.e. parent participates in a 3D rendering context).
|
| - if (LayerIsInExisting3DRenderingContext(layer) &&
|
| - layer->should_flatten_transform() &&
|
| - num_descendants_that_draw_content > 0) {
|
| - TRACE_EVENT_INSTANT0(
|
| - "cc",
|
| - "LayerTreeHostCommon::SubtreeShouldRenderToSeparateSurface flattening",
|
| - TRACE_EVENT_SCOPE_THREAD);
|
| - DCHECK(!is_root);
|
| - return true;
|
| - }
|
| -
|
| - // If the layer has blending.
|
| - // TODO(rosca): this is temporary, until blending is implemented for other
|
| - // types of quads than RenderPassDrawQuad. Layers having descendants that draw
|
| - // content will still create a separate rendering surface.
|
| - if (!layer->uses_default_blend_mode()) {
|
| - TRACE_EVENT_INSTANT0(
|
| - "cc",
|
| - "LayerTreeHostCommon::SubtreeShouldRenderToSeparateSurface blending",
|
| - TRACE_EVENT_SCOPE_THREAD);
|
| - DCHECK(!is_root);
|
| - return true;
|
| - }
|
| -
|
| - // If the layer clips its descendants but it is not axis-aligned with respect
|
| - // to its parent.
|
| - bool layer_clips_external_content =
|
| - LayerClipsSubtree(layer) || layer->HasDelegatedContent();
|
| - if (layer_clips_external_content && !axis_aligned_with_respect_to_parent &&
|
| - num_descendants_that_draw_content > 0) {
|
| - TRACE_EVENT_INSTANT0(
|
| - "cc",
|
| - "LayerTreeHostCommon::SubtreeShouldRenderToSeparateSurface clipping",
|
| - TRACE_EVENT_SCOPE_THREAD);
|
| - DCHECK(!is_root);
|
| - 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 at_least_two_layers_in_subtree_draw_content =
|
| - num_descendants_that_draw_content > 0 &&
|
| - (layer->DrawsContent() || num_descendants_that_draw_content > 1);
|
| -
|
| - if (layer->opacity() != 1.f && layer->should_flatten_transform() &&
|
| - at_least_two_layers_in_subtree_draw_content) {
|
| - TRACE_EVENT_INSTANT0(
|
| - "cc",
|
| - "LayerTreeHostCommon::SubtreeShouldRenderToSeparateSurface opacity",
|
| - TRACE_EVENT_SCOPE_THREAD);
|
| - DCHECK(!is_root);
|
| - return true;
|
| - }
|
| -
|
| - // The root layer should always have a render_surface.
|
| - if (is_root)
|
| - return true;
|
| -
|
| - //
|
| - // These are allowed on the root surface, as they don't require the surface to
|
| - // be used as a contributing surface in order to apply correctly.
|
| - //
|
| -
|
| - // If the layer has isolation.
|
| - // TODO(rosca): to be optimized - create separate rendering surface only when
|
| - // the blending descendants might have access to the content behind this layer
|
| - // (layer has transparent background or descendants overflow).
|
| - // https://code.google.com/p/chromium/issues/detail?id=301738
|
| - if (layer->is_root_for_isolated_group()) {
|
| - TRACE_EVENT_INSTANT0(
|
| - "cc",
|
| - "LayerTreeHostCommon::SubtreeShouldRenderToSeparateSurface isolation",
|
| - TRACE_EVENT_SCOPE_THREAD);
|
| - return true;
|
| - }
|
| -
|
| - // If we force it.
|
| - if (layer->force_render_surface())
|
| - return true;
|
| -
|
| - // If we'll make a copy of the layer's contents.
|
| - if (layer->HasCopyRequest())
|
| - return true;
|
| -
|
| - return false;
|
| -}
|
| -
|
| -// This function returns a translation matrix that can be applied on a vector
|
| -// that's in the layer's target surface coordinate, while the position offset is
|
| -// specified in some ancestor layer's coordinate.
|
| -template <typename LayerType>
|
| -gfx::Transform ComputeSizeDeltaCompensation(
|
| - LayerType* layer,
|
| - LayerType* container,
|
| - const gfx::Vector2dF& position_offset) {
|
| - gfx::Transform result_transform;
|
| -
|
| - // To apply a translate in the container's layer space,
|
| - // the following steps need to be done:
|
| - // Step 1a. transform from target surface space to the container's target
|
| - // surface space
|
| - // Step 1b. transform from container's target surface space to the
|
| - // container's layer space
|
| - // Step 2. apply the compensation
|
| - // Step 3. transform back to target surface space
|
| -
|
| - gfx::Transform target_surface_space_to_container_layer_space;
|
| - // Calculate step 1a
|
| - LayerType* container_target_surface = container->render_target();
|
| - for (LayerType* current_target_surface = NextTargetSurface(layer);
|
| - current_target_surface &&
|
| - current_target_surface != container_target_surface;
|
| - current_target_surface = NextTargetSurface(current_target_surface)) {
|
| - // Note: Concat is used here to convert the result coordinate space from
|
| - // current render surface to the next render surface.
|
| - target_surface_space_to_container_layer_space.ConcatTransform(
|
| - current_target_surface->render_surface()->draw_transform());
|
| - }
|
| - // Calculate step 1b
|
| - gfx::Transform container_layer_space_to_container_target_surface_space =
|
| - container->draw_transform();
|
| - container_layer_space_to_container_target_surface_space.Scale(
|
| - container->contents_scale_x(), container->contents_scale_y());
|
| -
|
| - gfx::Transform container_target_surface_space_to_container_layer_space;
|
| - if (container_layer_space_to_container_target_surface_space.GetInverse(
|
| - &container_target_surface_space_to_container_layer_space)) {
|
| - // Note: Again, Concat is used to conver the result coordinate space from
|
| - // the container render surface to the container layer.
|
| - target_surface_space_to_container_layer_space.ConcatTransform(
|
| - container_target_surface_space_to_container_layer_space);
|
| - }
|
| -
|
| - // Apply step 3
|
| - gfx::Transform container_layer_space_to_target_surface_space;
|
| - if (target_surface_space_to_container_layer_space.GetInverse(
|
| - &container_layer_space_to_target_surface_space)) {
|
| - result_transform.PreconcatTransform(
|
| - container_layer_space_to_target_surface_space);
|
| - } else {
|
| - // TODO(shawnsingh): A non-invertible matrix could still make meaningful
|
| - // projection. For example ScaleZ(0) is non-invertible but the layer is
|
| - // still visible.
|
| - return gfx::Transform();
|
| - }
|
| -
|
| - // Apply step 2
|
| - result_transform.Translate(position_offset.x(), position_offset.y());
|
| -
|
| - // Apply step 1
|
| - result_transform.PreconcatTransform(
|
| - target_surface_space_to_container_layer_space);
|
| -
|
| - return result_transform;
|
| -}
|
| -
|
| -template <typename LayerType>
|
| -void ApplyPositionAdjustment(
|
| - LayerType* layer,
|
| - LayerType* container,
|
| - const gfx::Transform& scroll_compensation,
|
| - gfx::Transform* combined_transform) {
|
| - if (!layer->position_constraint().is_fixed_position())
|
| - return;
|
| -
|
| - // Special case: this layer is a composited fixed-position layer; we need to
|
| - // explicitly compensate for all ancestors' nonzero scroll_deltas to keep
|
| - // this layer fixed correctly.
|
| - // Note carefully: this is Concat, not Preconcat
|
| - // (current_scroll_compensation * combined_transform).
|
| - combined_transform->ConcatTransform(scroll_compensation);
|
| -
|
| - // For right-edge or bottom-edge anchored fixed position layers,
|
| - // the layer should relocate itself if the container changes its size.
|
| - bool fixed_to_right_edge =
|
| - layer->position_constraint().is_fixed_to_right_edge();
|
| - bool fixed_to_bottom_edge =
|
| - layer->position_constraint().is_fixed_to_bottom_edge();
|
| - gfx::Vector2dF position_offset = container->FixedContainerSizeDelta();
|
| - position_offset.set_x(fixed_to_right_edge ? position_offset.x() : 0);
|
| - position_offset.set_y(fixed_to_bottom_edge ? position_offset.y() : 0);
|
| - if (position_offset.IsZero())
|
| - return;
|
| -
|
| - // Note: Again, this is Concat. The compensation matrix will be applied on
|
| - // the vector in target surface space.
|
| - combined_transform->ConcatTransform(
|
| - ComputeSizeDeltaCompensation(layer, container, position_offset));
|
| -}
|
| -
|
| -template <typename LayerType>
|
| -gfx::Transform ComputeScrollCompensationForThisLayer(
|
| - LayerType* scrolling_layer,
|
| - const gfx::Transform& parent_matrix,
|
| - const gfx::Vector2dF& scroll_delta) {
|
| - // For every layer that has non-zero scroll_delta, we have to compute a
|
| - // transform that can undo the scroll_delta translation. In particular, we
|
| - // want this matrix to premultiply a fixed-position layer's parent_matrix, 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
|
| - // scroll_delta is actually applied.
|
| - // -- this is inverse of parent_matrix
|
| - // Step 2. undo the scroll_delta
|
| - // -- this is just a translation by scroll_delta.
|
| - // Step 3. transform back to target surface space.
|
| - // -- this transform is the parent_matrix
|
| - //
|
| - // These steps create a matrix that both start and end in target surface
|
| - // space. So this matrix can pre-multiply any fixed-position layer's
|
| - // draw_transform to undo the scroll_deltas -- as long as that fixed position
|
| - // layer is fixed onto the same render_target as this scrolling_layer.
|
| - //
|
| -
|
| - gfx::Transform scroll_compensation_for_this_layer = parent_matrix; // Step 3
|
| - scroll_compensation_for_this_layer.Translate(
|
| - scroll_delta.x(),
|
| - scroll_delta.y()); // Step 2
|
| -
|
| - gfx::Transform inverse_parent_matrix(gfx::Transform::kSkipInitialization);
|
| - if (!parent_matrix.GetInverse(&inverse_parent_matrix)) {
|
| - // TODO(shawnsingh): Either we need to handle uninvertible transforms
|
| - // here, or DCHECK that the transform is invertible.
|
| - }
|
| - scroll_compensation_for_this_layer.PreconcatTransform(
|
| - inverse_parent_matrix); // Step 1
|
| - return scroll_compensation_for_this_layer;
|
| -}
|
| -
|
| -template <typename LayerType>
|
| -gfx::Transform ComputeScrollCompensationMatrixForChildren(
|
| - LayerType* layer,
|
| - const gfx::Transform& parent_matrix,
|
| - const gfx::Transform& current_scroll_compensation_matrix,
|
| - const gfx::Vector2dF& scroll_delta) {
|
| - // "Total scroll compensation" is the transform needed to cancel out all
|
| - // scroll_delta translations that occurred since the nearest container layer,
|
| - // even if there are render_surfaces 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 render_surface
|
| - // should behave the same as a container without a render_surface, the
|
| - // render_surface is irrelevant in that case.
|
| - // - A layer that does not have an explicit container is simply fixed to the
|
| - // viewport. (i.e. the root render_surface.)
|
| - // - If the fixed-position layer has its own render_surface, then the
|
| - // render_surface is the one who gets fixed.
|
| - //
|
| - // This function needs to be called AFTER layers create their own
|
| - // render_surfaces.
|
| - //
|
| -
|
| - // Scroll compensation restarts from identity under two possible conditions:
|
| - // - the current layer is a container for fixed-position descendants
|
| - // - the current layer is fixed-position itself, so any fixed-position
|
| - // descendants are positioned with respect to this layer. Thus, any
|
| - // fixed position descendants only need to compensate for scrollDeltas
|
| - // that occur below this layer.
|
| - bool current_layer_resets_scroll_compensation_for_descendants =
|
| - layer->IsContainerForFixedPositionLayers() ||
|
| - layer->position_constraint().is_fixed_position();
|
| -
|
| - // 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 (!current_layer_resets_scroll_compensation_for_descendants &&
|
| - scroll_delta.IsZero() && !layer->render_surface())
|
| - return current_scroll_compensation_matrix;
|
| -
|
| - // Start as identity matrix.
|
| - gfx::Transform next_scroll_compensation_matrix;
|
| -
|
| - // If this layer does not reset scroll compensation, then it inherits the
|
| - // existing scroll compensations.
|
| - if (!current_layer_resets_scroll_compensation_for_descendants)
|
| - next_scroll_compensation_matrix = current_scroll_compensation_matrix;
|
| -
|
| - // If the current layer has a non-zero scroll_delta, then we should compute
|
| - // its local scroll compensation and accumulate it to the
|
| - // next_scroll_compensation_matrix.
|
| - if (!scroll_delta.IsZero()) {
|
| - gfx::Transform scroll_compensation_for_this_layer =
|
| - ComputeScrollCompensationForThisLayer(
|
| - layer, parent_matrix, scroll_delta);
|
| - next_scroll_compensation_matrix.PreconcatTransform(
|
| - scroll_compensation_for_this_layer);
|
| - }
|
| -
|
| - // If the layer created its own render_surface, we have to adjust
|
| - // next_scroll_compensation_matrix. The adjustment allows us to continue
|
| - // using the scroll compensation 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->render_surface() &&
|
| - !next_scroll_compensation_matrix.IsIdentity()) {
|
| - gfx::Transform inverse_surface_draw_transform(
|
| - gfx::Transform::kSkipInitialization);
|
| - if (!layer->render_surface()->draw_transform().GetInverse(
|
| - &inverse_surface_draw_transform)) {
|
| - // TODO(shawnsingh): Either we need to handle uninvertible transforms
|
| - // here, or DCHECK that the transform is invertible.
|
| - }
|
| - next_scroll_compensation_matrix =
|
| - inverse_surface_draw_transform * next_scroll_compensation_matrix *
|
| - layer->render_surface()->draw_transform();
|
| - }
|
| -
|
| - return next_scroll_compensation_matrix;
|
| -}
|
| -
|
| -template <typename LayerType>
|
| -static inline void UpdateLayerScaleDrawProperties(
|
| - LayerType* layer,
|
| - float ideal_contents_scale,
|
| - float maximum_animation_contents_scale,
|
| - float page_scale_factor,
|
| - float device_scale_factor) {
|
| - layer->draw_properties().ideal_contents_scale = ideal_contents_scale;
|
| - layer->draw_properties().maximum_animation_contents_scale =
|
| - maximum_animation_contents_scale;
|
| - layer->draw_properties().page_scale_factor = page_scale_factor;
|
| - layer->draw_properties().device_scale_factor = device_scale_factor;
|
| -}
|
| -
|
| -static inline void CalculateContentsScale(LayerImpl* layer,
|
| - float contents_scale) {
|
| - // LayerImpl has all of its content scales and bounds pushed from the Main
|
| - // thread during commit and just uses those values as-is.
|
| -}
|
| -
|
| -static inline void CalculateContentsScale(Layer* layer, float contents_scale) {
|
| - layer->CalculateContentsScale(contents_scale,
|
| - &layer->draw_properties().contents_scale_x,
|
| - &layer->draw_properties().contents_scale_y,
|
| - &layer->draw_properties().content_bounds);
|
| -
|
| - Layer* mask_layer = layer->mask_layer();
|
| - if (mask_layer) {
|
| - mask_layer->CalculateContentsScale(
|
| - contents_scale,
|
| - &mask_layer->draw_properties().contents_scale_x,
|
| - &mask_layer->draw_properties().contents_scale_y,
|
| - &mask_layer->draw_properties().content_bounds);
|
| - }
|
| -
|
| - Layer* replica_mask_layer =
|
| - layer->replica_layer() ? layer->replica_layer()->mask_layer() : NULL;
|
| - if (replica_mask_layer) {
|
| - replica_mask_layer->CalculateContentsScale(
|
| - contents_scale,
|
| - &replica_mask_layer->draw_properties().contents_scale_x,
|
| - &replica_mask_layer->draw_properties().contents_scale_y,
|
| - &replica_mask_layer->draw_properties().content_bounds);
|
| - }
|
| -}
|
| -
|
| -static inline void UpdateLayerContentsScale(
|
| - LayerImpl* layer,
|
| - bool can_adjust_raster_scale,
|
| - float ideal_contents_scale,
|
| - float device_scale_factor,
|
| - float page_scale_factor,
|
| - bool animating_transform_to_screen) {
|
| - CalculateContentsScale(layer, ideal_contents_scale);
|
| -}
|
| -
|
| -static inline void UpdateLayerContentsScale(
|
| - Layer* layer,
|
| - bool can_adjust_raster_scale,
|
| - float ideal_contents_scale,
|
| - float device_scale_factor,
|
| - float page_scale_factor,
|
| - bool animating_transform_to_screen) {
|
| - if (can_adjust_raster_scale) {
|
| - float ideal_raster_scale =
|
| - ideal_contents_scale / (device_scale_factor * page_scale_factor);
|
| -
|
| - bool need_to_set_raster_scale = layer->raster_scale_is_unknown();
|
| -
|
| - // If we've previously saved a raster_scale but the ideal changes, things
|
| - // are unpredictable and we should just use 1.
|
| - if (!need_to_set_raster_scale && layer->raster_scale() != 1.f &&
|
| - ideal_raster_scale != layer->raster_scale()) {
|
| - ideal_raster_scale = 1.f;
|
| - need_to_set_raster_scale = true;
|
| - }
|
| -
|
| - if (need_to_set_raster_scale) {
|
| - bool use_and_save_ideal_scale =
|
| - ideal_raster_scale >= 1.f && !animating_transform_to_screen;
|
| - if (use_and_save_ideal_scale)
|
| - layer->set_raster_scale(ideal_raster_scale);
|
| - }
|
| - }
|
| -
|
| - float raster_scale = 1.f;
|
| - if (!layer->raster_scale_is_unknown())
|
| - raster_scale = layer->raster_scale();
|
| -
|
| - gfx::Size old_content_bounds = layer->content_bounds();
|
| - float old_contents_scale_x = layer->contents_scale_x();
|
| - float old_contents_scale_y = layer->contents_scale_y();
|
| -
|
| - float contents_scale = raster_scale * device_scale_factor * page_scale_factor;
|
| - CalculateContentsScale(layer, contents_scale);
|
| -
|
| - if (layer->content_bounds() != old_content_bounds ||
|
| - layer->contents_scale_x() != old_contents_scale_x ||
|
| - layer->contents_scale_y() != old_contents_scale_y)
|
| - layer->SetNeedsPushProperties();
|
| -}
|
| -
|
| -static inline void CalculateAnimationContentsScale(
|
| - Layer* layer,
|
| - bool ancestor_is_animating_scale,
|
| - float ancestor_maximum_animation_contents_scale,
|
| - const gfx::Transform& parent_transform,
|
| - const gfx::Transform& combined_transform,
|
| - bool* combined_is_animating_scale,
|
| - float* combined_maximum_animation_contents_scale) {
|
| - *combined_is_animating_scale = false;
|
| - *combined_maximum_animation_contents_scale = 0.f;
|
| -}
|
| -
|
| -static inline void CalculateAnimationContentsScale(
|
| - LayerImpl* layer,
|
| - bool ancestor_is_animating_scale,
|
| - float ancestor_maximum_animation_contents_scale,
|
| - const gfx::Transform& ancestor_transform,
|
| - const gfx::Transform& combined_transform,
|
| - bool* combined_is_animating_scale,
|
| - float* combined_maximum_animation_contents_scale) {
|
| - if (ancestor_is_animating_scale &&
|
| - ancestor_maximum_animation_contents_scale == 0.f) {
|
| - // We've already failed to compute a maximum animated scale at an
|
| - // ancestor, so we'll continue to fail.
|
| - *combined_maximum_animation_contents_scale = 0.f;
|
| - *combined_is_animating_scale = true;
|
| - return;
|
| - }
|
| -
|
| - if (!combined_transform.IsScaleOrTranslation()) {
|
| - // Computing maximum animated scale in the presence of
|
| - // non-scale/translation transforms isn't supported.
|
| - *combined_maximum_animation_contents_scale = 0.f;
|
| - *combined_is_animating_scale = true;
|
| - return;
|
| - }
|
| -
|
| - // We currently only support computing maximum scale for combinations of
|
| - // scales and translations. We treat all non-translations as potentially
|
| - // affecting scale. Animations that include non-translation/scale components
|
| - // will cause the computation of MaximumScale below to fail.
|
| - bool layer_is_animating_scale =
|
| - !layer->layer_animation_controller()->HasOnlyTranslationTransforms();
|
| -
|
| - if (!layer_is_animating_scale && !ancestor_is_animating_scale) {
|
| - *combined_maximum_animation_contents_scale = 0.f;
|
| - *combined_is_animating_scale = false;
|
| - return;
|
| - }
|
| -
|
| - // We don't attempt to accumulate animation scale from multiple nodes,
|
| - // because of the risk of significant overestimation. For example, one node
|
| - // may be increasing scale from 1 to 10 at the same time as a descendant is
|
| - // decreasing scale from 10 to 1. Naively combining these scales would produce
|
| - // a scale of 100.
|
| - if (layer_is_animating_scale && ancestor_is_animating_scale) {
|
| - *combined_maximum_animation_contents_scale = 0.f;
|
| - *combined_is_animating_scale = true;
|
| - return;
|
| - }
|
| -
|
| - // At this point, we know either the layer or an ancestor, but not both,
|
| - // is animating scale.
|
| - *combined_is_animating_scale = true;
|
| - if (!layer_is_animating_scale) {
|
| - gfx::Vector2dF layer_transform_scales =
|
| - MathUtil::ComputeTransform2dScaleComponents(layer->transform(), 0.f);
|
| - *combined_maximum_animation_contents_scale =
|
| - ancestor_maximum_animation_contents_scale *
|
| - std::max(layer_transform_scales.x(), layer_transform_scales.y());
|
| - return;
|
| - }
|
| -
|
| - float layer_maximum_animated_scale = 0.f;
|
| - if (!layer->layer_animation_controller()->MaximumTargetScale(
|
| - &layer_maximum_animated_scale)) {
|
| - *combined_maximum_animation_contents_scale = 0.f;
|
| - return;
|
| - }
|
| - gfx::Vector2dF ancestor_transform_scales =
|
| - MathUtil::ComputeTransform2dScaleComponents(ancestor_transform, 0.f);
|
| - *combined_maximum_animation_contents_scale =
|
| - layer_maximum_animated_scale *
|
| - std::max(ancestor_transform_scales.x(), ancestor_transform_scales.y());
|
| -}
|
| -
|
| -template <typename LayerTypePtr>
|
| -static inline void MarkLayerWithRenderSurfaceLayerListId(
|
| - LayerTypePtr layer,
|
| - int current_render_surface_layer_list_id) {
|
| - layer->draw_properties().last_drawn_render_surface_layer_list_id =
|
| - current_render_surface_layer_list_id;
|
| - layer->draw_properties().layer_or_descendant_is_drawn =
|
| - !!current_render_surface_layer_list_id;
|
| -}
|
| -
|
| -template <typename LayerTypePtr>
|
| -static inline void MarkMasksWithRenderSurfaceLayerListId(
|
| - LayerTypePtr layer,
|
| - int current_render_surface_layer_list_id) {
|
| - if (layer->mask_layer()) {
|
| - MarkLayerWithRenderSurfaceLayerListId(layer->mask_layer(),
|
| - current_render_surface_layer_list_id);
|
| - }
|
| - if (layer->replica_layer() && layer->replica_layer()->mask_layer()) {
|
| - MarkLayerWithRenderSurfaceLayerListId(layer->replica_layer()->mask_layer(),
|
| - current_render_surface_layer_list_id);
|
| - }
|
| -}
|
| -
|
| -template <typename LayerListType>
|
| -static inline void MarkLayerListWithRenderSurfaceLayerListId(
|
| - LayerListType* layer_list,
|
| - int current_render_surface_layer_list_id) {
|
| - for (typename LayerListType::iterator it = layer_list->begin();
|
| - it != layer_list->end();
|
| - ++it) {
|
| - MarkLayerWithRenderSurfaceLayerListId(*it,
|
| - current_render_surface_layer_list_id);
|
| - MarkMasksWithRenderSurfaceLayerListId(*it,
|
| - current_render_surface_layer_list_id);
|
| - }
|
| -}
|
| -
|
| -template <typename LayerType>
|
| -static inline void RemoveSurfaceForEarlyExit(
|
| - LayerType* layer_to_remove,
|
| - typename LayerType::RenderSurfaceListType* render_surface_layer_list) {
|
| - DCHECK(layer_to_remove->render_surface());
|
| - // Technically, we know that the layer we want to remove should be
|
| - // at the back of the render_surface_layer_list. 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 (render_surface_layer_list->back() != layer_to_remove) {
|
| - MarkLayerListWithRenderSurfaceLayerListId(
|
| - &render_surface_layer_list->back()->render_surface()->layer_list(), 0);
|
| - MarkLayerWithRenderSurfaceLayerListId(render_surface_layer_list->back(), 0);
|
| -
|
| - render_surface_layer_list->back()->ClearRenderSurfaceLayerList();
|
| - render_surface_layer_list->pop_back();
|
| - }
|
| - DCHECK_EQ(render_surface_layer_list->back(), layer_to_remove);
|
| - MarkLayerListWithRenderSurfaceLayerListId(
|
| - &layer_to_remove->render_surface()->layer_list(), 0);
|
| - MarkLayerWithRenderSurfaceLayerListId(layer_to_remove, 0);
|
| - render_surface_layer_list->pop_back();
|
| - layer_to_remove->ClearRenderSurfaceLayerList();
|
| -}
|
| -
|
| -struct PreCalculateMetaInformationRecursiveData {
|
| - bool layer_or_descendant_has_copy_request;
|
| - bool layer_or_descendant_has_input_handler;
|
| - int num_unclipped_descendants;
|
| -
|
| - PreCalculateMetaInformationRecursiveData()
|
| - : layer_or_descendant_has_copy_request(false),
|
| - layer_or_descendant_has_input_handler(false),
|
| - num_unclipped_descendants(0) {}
|
| -
|
| - void Merge(const PreCalculateMetaInformationRecursiveData& data) {
|
| - layer_or_descendant_has_copy_request |=
|
| - data.layer_or_descendant_has_copy_request;
|
| - layer_or_descendant_has_input_handler |=
|
| - data.layer_or_descendant_has_input_handler;
|
| - num_unclipped_descendants += data.num_unclipped_descendants;
|
| - }
|
| -};
|
| -
|
| -static void ValidateRenderSurface(LayerImpl* layer) {
|
| - // This test verifies that there are no cases where a LayerImpl needs
|
| - // a render surface, but doesn't have one.
|
| - if (layer->render_surface())
|
| - return;
|
| -
|
| - DCHECK(layer->filters().IsEmpty()) << "layer: " << layer->id();
|
| - DCHECK(layer->background_filters().IsEmpty()) << "layer: " << layer->id();
|
| - DCHECK(!layer->mask_layer()) << "layer: " << layer->id();
|
| - DCHECK(!layer->replica_layer()) << "layer: " << layer->id();
|
| - DCHECK(!IsRootLayer(layer)) << "layer: " << layer->id();
|
| - DCHECK(!layer->is_root_for_isolated_group()) << "layer: " << layer->id();
|
| - DCHECK(!layer->HasCopyRequest()) << "layer: " << layer->id();
|
| -}
|
| -
|
| -static void ValidateRenderSurface(Layer* layer) {
|
| -}
|
| -
|
| -// 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,
|
| - PreCalculateMetaInformationRecursiveData* recursive_data) {
|
| - ValidateRenderSurface(layer);
|
| -
|
| - layer->draw_properties().sorted_for_recursion = false;
|
| - layer->draw_properties().has_child_with_a_scroll_parent = false;
|
| - layer->draw_properties().layer_or_descendant_is_drawn = false;
|
| - layer->draw_properties().visited = false;
|
| -
|
| - if (!HasInvertibleOrAnimatedTransform(layer)) {
|
| - // Layers with singular transforms should not be drawn, the whole subtree
|
| - // can be skipped.
|
| - return;
|
| - }
|
| -
|
| - if (layer->clip_parent())
|
| - recursive_data->num_unclipped_descendants++;
|
| -
|
| - for (size_t i = 0; i < layer->children().size(); ++i) {
|
| - LayerType* child_layer =
|
| - LayerTreeHostCommon::get_layer_as_raw_ptr(layer->children(), i);
|
| -
|
| - PreCalculateMetaInformationRecursiveData data_for_child;
|
| - PreCalculateMetaInformation(child_layer, &data_for_child);
|
| -
|
| - if (child_layer->scroll_parent())
|
| - layer->draw_properties().has_child_with_a_scroll_parent = true;
|
| - recursive_data->Merge(data_for_child);
|
| - }
|
| -
|
| - if (layer->clip_children()) {
|
| - int num_clip_children = layer->clip_children()->size();
|
| - DCHECK_GE(recursive_data->num_unclipped_descendants, num_clip_children);
|
| - recursive_data->num_unclipped_descendants -= num_clip_children;
|
| - }
|
| -
|
| - if (layer->HasCopyRequest())
|
| - recursive_data->layer_or_descendant_has_copy_request = true;
|
| -
|
| - if (!layer->touch_event_handler_region().IsEmpty() ||
|
| - layer->have_wheel_event_handlers())
|
| - recursive_data->layer_or_descendant_has_input_handler = true;
|
| -
|
| - layer->draw_properties().num_unclipped_descendants =
|
| - recursive_data->num_unclipped_descendants;
|
| - layer->draw_properties().layer_or_descendant_has_copy_request =
|
| - recursive_data->layer_or_descendant_has_copy_request;
|
| - layer->draw_properties().layer_or_descendant_has_input_handler =
|
| - recursive_data->layer_or_descendant_has_input_handler;
|
| -}
|
| -
|
| -template <typename LayerType>
|
| -struct SubtreeGlobals {
|
| - int max_texture_size;
|
| - float device_scale_factor;
|
| - float page_scale_factor;
|
| - const LayerType* page_scale_application_layer;
|
| - gfx::Vector2dF elastic_overscroll;
|
| - const LayerType* elastic_overscroll_application_layer;
|
| - bool can_adjust_raster_scales;
|
| - bool can_render_to_separate_surface;
|
| - bool layers_always_allowed_lcd_text;
|
| -};
|
| -
|
| -template<typename LayerType>
|
| -struct DataForRecursion {
|
| - // The accumulated sequence of transforms a layer will use to determine its
|
| - // own draw transform.
|
| - gfx::Transform parent_matrix;
|
| -
|
| - // The accumulated sequence of transforms a layer will use to determine its
|
| - // own screen-space transform.
|
| - gfx::Transform full_hierarchy_matrix;
|
| -
|
| - // The transform that removes all scrolling that may have occurred between a
|
| - // fixed-position layer and its container, so that the layer actually does
|
| - // remain fixed.
|
| - gfx::Transform scroll_compensation_matrix;
|
| -
|
| - // The ancestor that would be the container for any fixed-position / sticky
|
| - // layers.
|
| - LayerType* fixed_container;
|
| -
|
| - // This is the normal clip rect that is propagated from parent to child.
|
| - gfx::Rect clip_rect_in_target_space;
|
| -
|
| - // When the layer's children want to compute their visible content rect, they
|
| - // want to know what their target surface's clip rect will be. BUT - they
|
| - // want to know this clip rect represented in their own target space. This
|
| - // requires inverse-projecting the surface's clip rect from the surface's
|
| - // render target space down to the surface's own space. Instead of computing
|
| - // this value redundantly for each child layer, it is computed only once
|
| - // while dealing with the parent layer, and then this precomputed value is
|
| - // passed down the recursion to the children that actually use it.
|
| - gfx::Rect clip_rect_of_target_surface_in_target_space;
|
| -
|
| - // The maximum amount by which this layer will be scaled during the lifetime
|
| - // of currently running animations.
|
| - float maximum_animation_contents_scale;
|
| -
|
| - bool ancestor_is_animating_scale;
|
| - bool ancestor_clips_subtree;
|
| - typename LayerType::RenderSurfaceType*
|
| - nearest_occlusion_immune_ancestor_surface;
|
| - bool in_subtree_of_page_scale_application_layer;
|
| - bool subtree_can_use_lcd_text;
|
| - bool subtree_is_visible_from_ancestor;
|
| -};
|
| -
|
| -template <typename LayerType>
|
| -static LayerType* GetChildContainingLayer(const LayerType& parent,
|
| - LayerType* layer) {
|
| - for (LayerType* ancestor = layer; ancestor; ancestor = ancestor->parent()) {
|
| - if (ancestor->parent() == &parent)
|
| - return ancestor;
|
| - }
|
| - NOTREACHED();
|
| - return 0;
|
| -}
|
| -
|
| -template <typename LayerType>
|
| -static void AddScrollParentChain(std::vector<LayerType*>* out,
|
| - const LayerType& parent,
|
| - LayerType* layer) {
|
| - // At a high level, this function walks up the chain of scroll parents
|
| - // recursively, and once we reach the end of the chain, we add the child
|
| - // of |parent| containing each scroll ancestor as we unwind. The result is
|
| - // an ordering of parent's children that ensures that scroll parents are
|
| - // visited before their descendants.
|
| - // Take for example this layer tree:
|
| - //
|
| - // + stacking_context
|
| - // + scroll_child (1)
|
| - // + scroll_parent_graphics_layer (*)
|
| - // | + scroll_parent_scrolling_layer
|
| - // | + scroll_parent_scrolling_content_layer (2)
|
| - // + scroll_grandparent_graphics_layer (**)
|
| - // + scroll_grandparent_scrolling_layer
|
| - // + scroll_grandparent_scrolling_content_layer (3)
|
| - //
|
| - // The scroll child is (1), its scroll parent is (2) and its scroll
|
| - // grandparent is (3). Note, this doesn't mean that (2)'s scroll parent is
|
| - // (3), it means that (*)'s scroll parent is (3). We don't want our list to
|
| - // look like [ (3), (2), (1) ], even though that does have the ancestor chain
|
| - // in the right order. Instead, we want [ (**), (*), (1) ]. That is, only want
|
| - // (1)'s siblings in the list, but we want them to appear in such an order
|
| - // that the scroll ancestors get visited in the correct order.
|
| - //
|
| - // So our first task at this step of the recursion is to determine the layer
|
| - // that we will potentionally add to the list. That is, the child of parent
|
| - // containing |layer|.
|
| - LayerType* child = GetChildContainingLayer(parent, layer);
|
| - if (child->draw_properties().sorted_for_recursion)
|
| - return;
|
| -
|
| - if (LayerType* scroll_parent = child->scroll_parent())
|
| - AddScrollParentChain(out, parent, scroll_parent);
|
| -
|
| - out->push_back(child);
|
| - child->draw_properties().sorted_for_recursion = true;
|
| -}
|
| -
|
| -template <typename LayerType>
|
| -static bool SortChildrenForRecursion(std::vector<LayerType*>* out,
|
| - const LayerType& parent) {
|
| - out->reserve(parent.children().size());
|
| - bool order_changed = false;
|
| - for (size_t i = 0; i < parent.children().size(); ++i) {
|
| - LayerType* current =
|
| - LayerTreeHostCommon::get_layer_as_raw_ptr(parent.children(), i);
|
| -
|
| - if (current->draw_properties().sorted_for_recursion) {
|
| - order_changed = true;
|
| - continue;
|
| - }
|
| -
|
| - AddScrollParentChain(out, parent, current);
|
| - }
|
| -
|
| - DCHECK_EQ(parent.children().size(), out->size());
|
| - return order_changed;
|
| -}
|
| -
|
| -template <typename LayerType>
|
| -static void GetNewDescendantsStartIndexAndCount(LayerType* layer,
|
| - size_t* start_index,
|
| - size_t* count) {
|
| - *start_index = layer->draw_properties().index_of_first_descendants_addition;
|
| - *count = layer->draw_properties().num_descendants_added;
|
| -}
|
| -
|
| -template <typename LayerType>
|
| -static void GetNewRenderSurfacesStartIndexAndCount(LayerType* layer,
|
| - size_t* start_index,
|
| - size_t* count) {
|
| - *start_index = layer->draw_properties()
|
| - .index_of_first_render_surface_layer_list_addition;
|
| - *count = layer->draw_properties().num_render_surfaces_added;
|
| -}
|
| -
|
| -// We need to extract a list from the the two flavors of RenderSurfaceListType
|
| -// for use in the sorting function below.
|
| -static LayerList* GetLayerListForSorting(RenderSurfaceLayerList* rsll) {
|
| - return &rsll->AsLayerList();
|
| -}
|
| -
|
| -static LayerImplList* GetLayerListForSorting(LayerImplList* layer_list) {
|
| - return layer_list;
|
| -}
|
| -
|
| -static inline gfx::Vector2d BoundsDelta(Layer* layer) {
|
| - return gfx::Vector2d();
|
| -}
|
| -
|
| -static inline gfx::Vector2d BoundsDelta(LayerImpl* layer) {
|
| - return gfx::ToCeiledVector2d(layer->bounds_delta());
|
| -}
|
| -
|
| -template <typename LayerType, typename GetIndexAndCountType>
|
| -static void SortLayerListContributions(
|
| - const LayerType& parent,
|
| - typename LayerType::LayerListType* unsorted,
|
| - size_t start_index_for_all_contributions,
|
| - GetIndexAndCountType get_index_and_count) {
|
| - typename LayerType::LayerListType buffer;
|
| - for (size_t i = 0; i < parent.children().size(); ++i) {
|
| - LayerType* child =
|
| - LayerTreeHostCommon::get_layer_as_raw_ptr(parent.children(), i);
|
| -
|
| - size_t start_index = 0;
|
| - size_t count = 0;
|
| - get_index_and_count(child, &start_index, &count);
|
| - for (size_t j = start_index; j < start_index + count; ++j)
|
| - buffer.push_back(unsorted->at(j));
|
| - }
|
| -
|
| - DCHECK_EQ(buffer.size(),
|
| - unsorted->size() - start_index_for_all_contributions);
|
| -
|
| - for (size_t i = 0; i < buffer.size(); ++i)
|
| - (*unsorted)[i + start_index_for_all_contributions] = buffer[i];
|
| -}
|
| -
|
| -// Recursively walks the layer tree starting at the given node and computes all
|
| -// the necessary transformations, clip rects, render surfaces, etc.
|
| -template <typename LayerType>
|
| -static void CalculateDrawPropertiesInternal(
|
| - LayerType* layer,
|
| - const SubtreeGlobals<LayerType>& globals,
|
| - const DataForRecursion<LayerType>& data_from_ancestor,
|
| - typename LayerType::RenderSurfaceListType* render_surface_layer_list,
|
| - typename LayerType::LayerListType* layer_list,
|
| - std::vector<AccumulatedSurfaceState<LayerType>>* accumulated_surface_state,
|
| - int current_render_surface_layer_list_id) {
|
| - // 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)
|
| - //
|
| - // S[layer2content] is the ratio of a layer's content_bounds() to its
|
| - // Bounds().
|
| - //
|
| - // Some composite transforms can help in understanding the sequence of
|
| - // transforms:
|
| - // composite_layer_transform = Tr[origin2anchor] * M[layer] *
|
| - // Tr[origin2anchor].inverse()
|
| - //
|
| - // 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] * composite_layer_transform *
|
| - // 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] * composite_layer_transform *
|
| - // 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
|
| - // parent_matrix) is:
|
| - // M[parent]_for_child = M[parent] * Tr[origin] *
|
| - // composite_layer_transform
|
| - // = M[parent] * Tr[layer->position() + anchor] *
|
| - // M[layer] * Tr[anchor2origin]
|
| - //
|
| - // 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[contents_scale].inverse()
|
| - //
|
| - // The replica draw transform to the root (screen space) origin is:
|
| - // M[replica2root] = M[surface2root] * Tr[replica->position()] *
|
| - // Tr[replica] * Tr[origin2anchor].inverse()
|
| - //
|
| -
|
| - // It makes no sense to have a non-unit page_scale_factor without specifying
|
| - // which layer roots the subtree the scale is applied to.
|
| - DCHECK(globals.page_scale_application_layer ||
|
| - (globals.page_scale_factor == 1.f));
|
| -
|
| - CHECK(!layer->draw_properties().visited);
|
| - layer->draw_properties().visited = true;
|
| -
|
| - DataForRecursion<LayerType> data_for_children;
|
| - typename LayerType::RenderSurfaceType*
|
| - nearest_occlusion_immune_ancestor_surface =
|
| - data_from_ancestor.nearest_occlusion_immune_ancestor_surface;
|
| - data_for_children.in_subtree_of_page_scale_application_layer =
|
| - data_from_ancestor.in_subtree_of_page_scale_application_layer;
|
| - data_for_children.subtree_can_use_lcd_text =
|
| - data_from_ancestor.subtree_can_use_lcd_text;
|
| -
|
| - // Layers that are marked as hidden will hide themselves and their subtree.
|
| - // Exception: Layers with copy requests, whether hidden or not, must be drawn
|
| - // anyway. In this case, we will inform their subtree they are visible to get
|
| - // the right results.
|
| - const bool layer_is_visible =
|
| - data_from_ancestor.subtree_is_visible_from_ancestor &&
|
| - !layer->hide_layer_and_subtree();
|
| - const bool layer_is_drawn = layer_is_visible || layer->HasCopyRequest();
|
| -
|
| - // The root layer cannot skip CalcDrawProperties.
|
| - if (!IsRootLayer(layer) && SubtreeShouldBeSkipped(layer, layer_is_drawn)) {
|
| - if (layer->render_surface())
|
| - layer->ClearRenderSurfaceLayerList();
|
| - layer->draw_properties().render_target = nullptr;
|
| - return;
|
| - }
|
| -
|
| - // We need to circumvent the normal recursive flow of information for clip
|
| - // children (they don't inherit their direct ancestor's clip information).
|
| - // This is unfortunate, and would be unnecessary if we were to formally
|
| - // separate the clipping hierarchy from the layer hierarchy.
|
| - bool ancestor_clips_subtree = data_from_ancestor.ancestor_clips_subtree;
|
| - gfx::Rect ancestor_clip_rect_in_target_space =
|
| - data_from_ancestor.clip_rect_in_target_space;
|
| -
|
| - // Update our clipping state. If we have a clip parent we will need to pull
|
| - // from the clip state cache rather than using the clip state passed from our
|
| - // immediate ancestor.
|
| - UpdateClipRectsForClipChild<LayerType>(
|
| - layer, &ancestor_clip_rect_in_target_space, &ancestor_clips_subtree);
|
| -
|
| - // 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<LayerType>& layer_draw_properties = layer->draw_properties();
|
| -
|
| - gfx::Rect clip_rect_in_target_space;
|
| - bool layer_or_ancestor_clips_descendants = false;
|
| -
|
| - // This value is cached on the stack so that we don't have to inverse-project
|
| - // the surface's clip rect redundantly for every layer. This value is the
|
| - // same as the target surface's clip rect, except that instead of being
|
| - // described in the target surface's target's space, it is described in the
|
| - // current render target's space.
|
| - gfx::Rect clip_rect_of_target_surface_in_target_space;
|
| -
|
| - float accumulated_draw_opacity = layer->opacity();
|
| - bool animating_opacity_to_target = layer->OpacityIsAnimating();
|
| - bool animating_opacity_to_screen = animating_opacity_to_target;
|
| - if (layer->parent()) {
|
| - accumulated_draw_opacity *= layer->parent()->draw_opacity();
|
| - animating_opacity_to_target |= layer->parent()->draw_opacity_is_animating();
|
| - animating_opacity_to_screen |=
|
| - layer->parent()->screen_space_opacity_is_animating();
|
| - }
|
| -
|
| - bool animating_transform_to_target = layer->TransformIsAnimating();
|
| - bool animating_transform_to_screen = animating_transform_to_target;
|
| - if (layer->parent()) {
|
| - animating_transform_to_target |=
|
| - layer->parent()->draw_transform_is_animating();
|
| - animating_transform_to_screen |=
|
| - layer->parent()->screen_space_transform_is_animating();
|
| - }
|
| - gfx::Point3F transform_origin = layer->transform_origin();
|
| - gfx::ScrollOffset scroll_offset = GetEffectiveCurrentScrollOffset(layer);
|
| - gfx::PointF position =
|
| - layer->position() - ScrollOffsetToVector2dF(scroll_offset);
|
| - gfx::Transform combined_transform = data_from_ancestor.parent_matrix;
|
| - if (!layer->transform().IsIdentity()) {
|
| - // LT = Tr[origin] * Tr[origin2transformOrigin]
|
| - combined_transform.Translate3d(position.x() + transform_origin.x(),
|
| - position.y() + transform_origin.y(),
|
| - transform_origin.z());
|
| - // LT = Tr[origin] * Tr[origin2origin] * M[layer]
|
| - combined_transform.PreconcatTransform(layer->transform());
|
| - // LT = Tr[origin] * Tr[origin2origin] * M[layer] *
|
| - // Tr[transformOrigin2origin]
|
| - combined_transform.Translate3d(
|
| - -transform_origin.x(), -transform_origin.y(), -transform_origin.z());
|
| - } else {
|
| - combined_transform.Translate(position.x(), position.y());
|
| - }
|
| -
|
| - gfx::Vector2dF effective_scroll_delta = GetEffectiveScrollDelta(layer);
|
| - if (!animating_transform_to_target && layer->scrollable() &&
|
| - combined_transform.IsScaleOrTranslation()) {
|
| - // Align the scrollable layer's position to screen space pixels to avoid
|
| - // blurriness. To avoid side-effects, do this only if the transform is
|
| - // simple.
|
| - gfx::Vector2dF previous_translation = combined_transform.To2dTranslation();
|
| - combined_transform.RoundTranslationComponents();
|
| - gfx::Vector2dF current_translation = combined_transform.To2dTranslation();
|
| -
|
| - // This rounding changes the scroll delta, and so must be included
|
| - // in the scroll compensation matrix. The scaling converts from physical
|
| - // coordinates to the scroll delta's CSS coordinates (using the parent
|
| - // matrix instead of combined transform since scrolling is applied before
|
| - // the layer's transform). For example, if we have a total scale factor of
|
| - // 3.0, then 1 physical pixel is only 1/3 of a CSS pixel.
|
| - gfx::Vector2dF parent_scales = MathUtil::ComputeTransform2dScaleComponents(
|
| - data_from_ancestor.parent_matrix, 1.f);
|
| - effective_scroll_delta -=
|
| - gfx::ScaleVector2d(current_translation - previous_translation,
|
| - 1.f / parent_scales.x(),
|
| - 1.f / parent_scales.y());
|
| - }
|
| -
|
| - // Apply adjustment from position constraints.
|
| - ApplyPositionAdjustment(layer, data_from_ancestor.fixed_container,
|
| - data_from_ancestor.scroll_compensation_matrix, &combined_transform);
|
| -
|
| - bool combined_is_animating_scale = false;
|
| - float combined_maximum_animation_contents_scale = 0.f;
|
| - if (globals.can_adjust_raster_scales) {
|
| - CalculateAnimationContentsScale(
|
| - layer,
|
| - data_from_ancestor.ancestor_is_animating_scale,
|
| - data_from_ancestor.maximum_animation_contents_scale,
|
| - data_from_ancestor.parent_matrix,
|
| - combined_transform,
|
| - &combined_is_animating_scale,
|
| - &combined_maximum_animation_contents_scale);
|
| - }
|
| - data_for_children.ancestor_is_animating_scale = combined_is_animating_scale;
|
| - data_for_children.maximum_animation_contents_scale =
|
| - combined_maximum_animation_contents_scale;
|
| -
|
| - // Compute the 2d scale components of the transform hierarchy up to the target
|
| - // surface. From there, we can decide on a contents scale for the layer.
|
| - float layer_scale_factors = globals.device_scale_factor;
|
| - if (data_from_ancestor.in_subtree_of_page_scale_application_layer)
|
| - layer_scale_factors *= globals.page_scale_factor;
|
| - gfx::Vector2dF combined_transform_scales =
|
| - MathUtil::ComputeTransform2dScaleComponents(
|
| - combined_transform,
|
| - layer_scale_factors);
|
| -
|
| - float ideal_contents_scale =
|
| - globals.can_adjust_raster_scales
|
| - ? std::max(combined_transform_scales.x(),
|
| - combined_transform_scales.y())
|
| - : layer_scale_factors;
|
| - UpdateLayerContentsScale(
|
| - layer,
|
| - globals.can_adjust_raster_scales,
|
| - ideal_contents_scale,
|
| - globals.device_scale_factor,
|
| - data_from_ancestor.in_subtree_of_page_scale_application_layer
|
| - ? globals.page_scale_factor
|
| - : 1.f,
|
| - animating_transform_to_screen);
|
| -
|
| - UpdateLayerScaleDrawProperties(
|
| - layer,
|
| - ideal_contents_scale,
|
| - combined_maximum_animation_contents_scale,
|
| - data_from_ancestor.in_subtree_of_page_scale_application_layer
|
| - ? globals.page_scale_factor
|
| - : 1.f,
|
| - globals.device_scale_factor);
|
| -
|
| - LayerType* mask_layer = layer->mask_layer();
|
| - if (mask_layer) {
|
| - UpdateLayerScaleDrawProperties(
|
| - mask_layer,
|
| - ideal_contents_scale,
|
| - combined_maximum_animation_contents_scale,
|
| - data_from_ancestor.in_subtree_of_page_scale_application_layer
|
| - ? globals.page_scale_factor
|
| - : 1.f,
|
| - globals.device_scale_factor);
|
| - }
|
| -
|
| - LayerType* replica_mask_layer =
|
| - layer->replica_layer() ? layer->replica_layer()->mask_layer() : NULL;
|
| - if (replica_mask_layer) {
|
| - UpdateLayerScaleDrawProperties(
|
| - replica_mask_layer,
|
| - ideal_contents_scale,
|
| - combined_maximum_animation_contents_scale,
|
| - data_from_ancestor.in_subtree_of_page_scale_application_layer
|
| - ? globals.page_scale_factor
|
| - : 1.f,
|
| - globals.device_scale_factor);
|
| - }
|
| -
|
| - // The draw_transform that gets computed below is effectively the layer's
|
| - // draw_transform, unless the layer itself creates a render_surface. In that
|
| - // case, the render_surface re-parents the transforms.
|
| - layer_draw_properties.target_space_transform = combined_transform;
|
| - // M[draw] = M[parent] * LT * S[layer2content]
|
| - layer_draw_properties.target_space_transform.Scale(
|
| - SK_MScalar1 / layer->contents_scale_x(),
|
| - SK_MScalar1 / layer->contents_scale_y());
|
| -
|
| - // The layer's screen_space_transform represents the transform between root
|
| - // layer's "screen space" and local content space.
|
| - layer_draw_properties.screen_space_transform =
|
| - data_from_ancestor.full_hierarchy_matrix;
|
| - layer_draw_properties.screen_space_transform.PreconcatTransform
|
| - (layer_draw_properties.target_space_transform);
|
| -
|
| - // Adjusting text AA method during animation may cause repaints, which in-turn
|
| - // causes jank.
|
| - bool adjust_text_aa =
|
| - !animating_opacity_to_screen && !animating_transform_to_screen;
|
| - bool layer_can_use_lcd_text = true;
|
| - bool subtree_can_use_lcd_text = true;
|
| - if (!globals.layers_always_allowed_lcd_text) {
|
| - // To avoid color fringing, LCD text should only be used on opaque layers
|
| - // with just integral translation.
|
| - subtree_can_use_lcd_text = data_from_ancestor.subtree_can_use_lcd_text &&
|
| - accumulated_draw_opacity == 1.f &&
|
| - layer_draw_properties.target_space_transform
|
| - .IsIdentityOrIntegerTranslation();
|
| - // Also disable LCD text locally for non-opaque content.
|
| - layer_can_use_lcd_text = subtree_can_use_lcd_text &&
|
| - layer->contents_opaque();
|
| - }
|
| -
|
| - // full_hierarchy_matrix is the matrix that transforms objects between screen
|
| - // space (except projection matrix) and the most recent RenderSurfaceImpl's
|
| - // space. next_hierarchy_matrix will only change if this layer uses a new
|
| - // RenderSurfaceImpl, otherwise remains the same.
|
| - data_for_children.full_hierarchy_matrix =
|
| - data_from_ancestor.full_hierarchy_matrix;
|
| -
|
| - bool render_to_separate_surface =
|
| - IsRootLayer(layer) ||
|
| - (globals.can_render_to_separate_surface && layer->render_surface());
|
| -
|
| - if (render_to_separate_surface) {
|
| - DCHECK(layer->render_surface());
|
| - // Check back-face visibility before continuing with this surface and its
|
| - // subtree
|
| - if (!layer->double_sided() && TransformToParentIsKnown(layer) &&
|
| - IsSurfaceBackFaceVisible(layer, combined_transform)) {
|
| - layer->ClearRenderSurfaceLayerList();
|
| - layer->draw_properties().render_target = nullptr;
|
| - return;
|
| - }
|
| -
|
| - typename LayerType::RenderSurfaceType* render_surface =
|
| - layer->render_surface();
|
| - layer->ClearRenderSurfaceLayerList();
|
| -
|
| - layer_draw_properties.render_target = layer;
|
| - if (IsRootLayer(layer)) {
|
| - // The root layer's render surface size is predetermined and so the root
|
| - // layer can't directly support non-identity transforms. It should just
|
| - // forward top-level transforms to the rest of the tree.
|
| - data_for_children.parent_matrix = combined_transform;
|
| -
|
| - // The root surface does not contribute to any other surface, it has no
|
| - // target.
|
| - layer->render_surface()->set_contributes_to_drawn_surface(false);
|
| - } else {
|
| - // The owning layer's draw transform has a scale from content to layer
|
| - // space which we do not want; so here we use the combined_transform
|
| - // instead of the draw_transform. However, we do need to add a different
|
| - // scale factor that accounts for the surface's pixel dimensions.
|
| - // Remove the combined_transform scale from the draw transform.
|
| - gfx::Transform draw_transform = combined_transform;
|
| - draw_transform.Scale(1.0 / combined_transform_scales.x(),
|
| - 1.0 / combined_transform_scales.y());
|
| - render_surface->SetDrawTransform(draw_transform);
|
| -
|
| - // The owning layer's transform was re-parented by the surface, so the
|
| - // layer's new draw_transform only needs to scale the layer to surface
|
| - // space.
|
| - layer_draw_properties.target_space_transform.MakeIdentity();
|
| - layer_draw_properties.target_space_transform.Scale(
|
| - combined_transform_scales.x() / layer->contents_scale_x(),
|
| - combined_transform_scales.y() / layer->contents_scale_y());
|
| -
|
| - // Inside the surface's subtree, we scale everything to the owning layer's
|
| - // scale. The sublayer matrix transforms layer rects into target surface
|
| - // content space. Conceptually, all layers in the subtree inherit the
|
| - // scale at the point of the render surface in the transform hierarchy,
|
| - // but we apply it explicitly to the owning layer and the remainder of the
|
| - // subtree independently.
|
| - DCHECK(data_for_children.parent_matrix.IsIdentity());
|
| - data_for_children.parent_matrix.Scale(combined_transform_scales.x(),
|
| - combined_transform_scales.y());
|
| -
|
| - // Even if the |layer_is_drawn|, it only contributes to a drawn surface
|
| - // when the |layer_is_visible|.
|
| - layer->render_surface()->set_contributes_to_drawn_surface(
|
| - layer_is_visible);
|
| - }
|
| -
|
| - // The opacity value is moved from the layer to its surface, so that the
|
| - // entire subtree properly inherits opacity.
|
| - render_surface->SetDrawOpacity(accumulated_draw_opacity);
|
| - render_surface->SetDrawOpacityIsAnimating(animating_opacity_to_target);
|
| - animating_opacity_to_target = false;
|
| - layer_draw_properties.opacity = 1.f;
|
| - layer_draw_properties.blend_mode = SkXfermode::kSrcOver_Mode;
|
| - layer_draw_properties.opacity_is_animating = animating_opacity_to_target;
|
| - layer_draw_properties.screen_space_opacity_is_animating =
|
| - animating_opacity_to_screen;
|
| -
|
| - render_surface->SetTargetSurfaceTransformsAreAnimating(
|
| - animating_transform_to_target);
|
| - render_surface->SetScreenSpaceTransformsAreAnimating(
|
| - animating_transform_to_screen);
|
| - animating_transform_to_target = false;
|
| - layer_draw_properties.target_space_transform_is_animating =
|
| - animating_transform_to_target;
|
| - layer_draw_properties.screen_space_transform_is_animating =
|
| - animating_transform_to_screen;
|
| -
|
| - // Update the aggregate hierarchy matrix to include the transform of the
|
| - // newly created RenderSurfaceImpl.
|
| - data_for_children.full_hierarchy_matrix.PreconcatTransform(
|
| - render_surface->draw_transform());
|
| -
|
| - // A render surface inherently acts as a flattening point for the content of
|
| - // its descendants.
|
| - data_for_children.full_hierarchy_matrix.FlattenTo2d();
|
| -
|
| - if (layer->mask_layer()) {
|
| - DrawProperties<LayerType>& mask_layer_draw_properties =
|
| - layer->mask_layer()->draw_properties();
|
| - mask_layer_draw_properties.render_target = layer;
|
| - mask_layer_draw_properties.visible_content_rect =
|
| - gfx::Rect(layer->content_bounds());
|
| - }
|
| -
|
| - if (layer->replica_layer() && layer->replica_layer()->mask_layer()) {
|
| - DrawProperties<LayerType>& replica_mask_draw_properties =
|
| - layer->replica_layer()->mask_layer()->draw_properties();
|
| - replica_mask_draw_properties.render_target = layer;
|
| - replica_mask_draw_properties.visible_content_rect =
|
| - gfx::Rect(layer->content_bounds());
|
| - }
|
| -
|
| - // Ignore occlusion from outside the surface when surface contents need to
|
| - // be fully drawn. Layers with copy-request need to be complete.
|
| - // We could be smarter about layers with replica and exclude regions
|
| - // where both layer and the replica are occluded, but this seems like an
|
| - // overkill. The same is true for layers with filters that move pixels.
|
| - // TODO(senorblanco): make this smarter for the SkImageFilter case (check
|
| - // for pixel-moving filters)
|
| - if (layer->HasCopyRequest() ||
|
| - layer->has_replica() ||
|
| - layer->filters().HasReferenceFilter() ||
|
| - layer->filters().HasFilterThatMovesPixels()) {
|
| - nearest_occlusion_immune_ancestor_surface = render_surface;
|
| - }
|
| - render_surface->SetNearestOcclusionImmuneAncestor(
|
| - nearest_occlusion_immune_ancestor_surface);
|
| -
|
| - layer_or_ancestor_clips_descendants = false;
|
| - bool subtree_is_clipped_by_surface_bounds = false;
|
| - if (ancestor_clips_subtree) {
|
| - // It may be the layer or the surface doing the clipping of the subtree,
|
| - // but in either case, we'll be clipping to the projected clip rect of our
|
| - // ancestor.
|
| - gfx::Transform inverse_surface_draw_transform(
|
| - gfx::Transform::kSkipInitialization);
|
| - if (!render_surface->draw_transform().GetInverse(
|
| - &inverse_surface_draw_transform)) {
|
| - // TODO(shawnsingh): Either we need to handle uninvertible transforms
|
| - // here, or DCHECK that the transform is invertible.
|
| - }
|
| -
|
| - gfx::Rect surface_clip_rect_in_target_space = gfx::IntersectRects(
|
| - data_from_ancestor.clip_rect_of_target_surface_in_target_space,
|
| - ancestor_clip_rect_in_target_space);
|
| - gfx::Rect projected_surface_rect = MathUtil::ProjectEnclosingClippedRect(
|
| - inverse_surface_draw_transform, surface_clip_rect_in_target_space);
|
| -
|
| - if (layer_draw_properties.num_unclipped_descendants > 0) {
|
| - // If we have unclipped descendants, we cannot count on the render
|
| - // surface's bounds clipping our subtree: the unclipped descendants
|
| - // could cause us to expand our bounds. In this case, we must rely on
|
| - // layer clipping for correctess. NB: since we can only encounter
|
| - // translations between a clip child and its clip parent, clipping is
|
| - // guaranteed to be exact in this case.
|
| - layer_or_ancestor_clips_descendants = true;
|
| - clip_rect_in_target_space = projected_surface_rect;
|
| - } else {
|
| - // The new render_surface 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 clip rects from
|
| - // ancestor target surface space to current target surface space that
|
| - // could cause more w < 0 headaches. The render surface clip rect is
|
| - // expressed in the space where this surface draws, i.e. the same space
|
| - // as clip_rect_from_ancestor_in_ancestor_target_space.
|
| - render_surface->SetClipRect(ancestor_clip_rect_in_target_space);
|
| - clip_rect_of_target_surface_in_target_space = projected_surface_rect;
|
| - subtree_is_clipped_by_surface_bounds = true;
|
| - }
|
| - }
|
| -
|
| - DCHECK(layer->render_surface());
|
| - DCHECK(!layer->parent() || layer->parent()->render_target() ==
|
| - accumulated_surface_state->back().render_target);
|
| -
|
| - accumulated_surface_state->push_back(
|
| - AccumulatedSurfaceState<LayerType>(layer));
|
| -
|
| - render_surface->SetIsClipped(subtree_is_clipped_by_surface_bounds);
|
| - if (!subtree_is_clipped_by_surface_bounds) {
|
| - render_surface->SetClipRect(gfx::Rect());
|
| - clip_rect_of_target_surface_in_target_space =
|
| - data_from_ancestor.clip_rect_of_target_surface_in_target_space;
|
| - }
|
| -
|
| - // 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.
|
| - data_for_children.subtree_can_use_lcd_text = subtree_can_use_lcd_text;
|
| -
|
| - render_surface_layer_list->push_back(layer);
|
| - } else {
|
| - DCHECK(layer->parent());
|
| -
|
| - // Note: layer_draw_properties.target_space_transform is computed above,
|
| - // before this if-else statement.
|
| - layer_draw_properties.target_space_transform_is_animating =
|
| - animating_transform_to_target;
|
| - layer_draw_properties.screen_space_transform_is_animating =
|
| - animating_transform_to_screen;
|
| - layer_draw_properties.opacity = accumulated_draw_opacity;
|
| - layer_draw_properties.blend_mode = layer->blend_mode();
|
| - layer_draw_properties.opacity_is_animating = animating_opacity_to_target;
|
| - layer_draw_properties.screen_space_opacity_is_animating =
|
| - animating_opacity_to_screen;
|
| - data_for_children.parent_matrix = combined_transform;
|
| -
|
| - // Layers without render_surfaces directly inherit the ancestor's clip
|
| - // status.
|
| - layer_or_ancestor_clips_descendants = ancestor_clips_subtree;
|
| - if (ancestor_clips_subtree) {
|
| - clip_rect_in_target_space =
|
| - ancestor_clip_rect_in_target_space;
|
| - }
|
| -
|
| - // The surface's cached clip rect value propagates regardless of what
|
| - // clipping goes on between layers here.
|
| - clip_rect_of_target_surface_in_target_space =
|
| - data_from_ancestor.clip_rect_of_target_surface_in_target_space;
|
| -
|
| - // Layers that are not their own render_target will render into the target
|
| - // of their nearest ancestor.
|
| - layer_draw_properties.render_target = layer->parent()->render_target();
|
| - }
|
| -
|
| - if (adjust_text_aa)
|
| - layer_draw_properties.can_use_lcd_text = layer_can_use_lcd_text;
|
| -
|
| - gfx::Size content_size_affected_by_delta(layer->content_bounds());
|
| -
|
| - // Non-zero BoundsDelta imply the contents_scale of 1.0
|
| - // because BoundsDela is only set on Android where
|
| - // ContentScalingLayer is never used.
|
| - DCHECK_IMPLIES(!BoundsDelta(layer).IsZero(),
|
| - (layer->contents_scale_x() == 1.0 &&
|
| - layer->contents_scale_y() == 1.0));
|
| -
|
| - // Thus we can omit contents scale in the following calculation.
|
| - gfx::Vector2d bounds_delta = BoundsDelta(layer);
|
| - content_size_affected_by_delta.Enlarge(bounds_delta.x(), bounds_delta.y());
|
| -
|
| - gfx::Rect rect_in_target_space = MathUtil::MapEnclosingClippedRect(
|
| - layer->draw_transform(),
|
| - gfx::Rect(content_size_affected_by_delta));
|
| -
|
| - if (LayerClipsSubtree(layer)) {
|
| - layer_or_ancestor_clips_descendants = true;
|
| - if (ancestor_clips_subtree && !render_to_separate_surface) {
|
| - // A layer without render surface shares the same target as its ancestor.
|
| - clip_rect_in_target_space =
|
| - ancestor_clip_rect_in_target_space;
|
| - clip_rect_in_target_space.Intersect(rect_in_target_space);
|
| - } else {
|
| - clip_rect_in_target_space = rect_in_target_space;
|
| - }
|
| - }
|
| -
|
| - // Tell the layer the rect that it's clipped by. In theory we could use a
|
| - // tighter clip rect here (drawable_content_rect), but that actually does not
|
| - // reduce how much would be drawn, and instead it would create unnecessary
|
| - // changes to scissor state affecting GPU performance. Our clip information
|
| - // is used in the recursion below, so we must set it beforehand.
|
| - layer_draw_properties.is_clipped = layer_or_ancestor_clips_descendants;
|
| - if (layer_or_ancestor_clips_descendants) {
|
| - layer_draw_properties.clip_rect = clip_rect_in_target_space;
|
| - } else {
|
| - // Initialize the clip rect to a safe value that will not clip the
|
| - // layer, just in case clipping is still accidentally used.
|
| - layer_draw_properties.clip_rect = rect_in_target_space;
|
| - }
|
| -
|
| - typename LayerType::LayerListType& descendants =
|
| - (render_to_separate_surface ? layer->render_surface()->layer_list()
|
| - : *layer_list);
|
| -
|
| - // Any layers that are appended after this point are in the layer's subtree
|
| - // and should be included in the sorting process.
|
| - size_t sorting_start_index = descendants.size();
|
| -
|
| - if (!LayerShouldBeSkipped(layer, layer_is_drawn)) {
|
| - MarkLayerWithRenderSurfaceLayerListId(layer,
|
| - current_render_surface_layer_list_id);
|
| - descendants.push_back(layer);
|
| - }
|
| -
|
| - // Any layers that are appended after this point may need to be sorted if we
|
| - // visit the children out of order.
|
| - size_t render_surface_layer_list_child_sorting_start_index =
|
| - render_surface_layer_list->size();
|
| - size_t layer_list_child_sorting_start_index = descendants.size();
|
| -
|
| - if (!layer->children().empty()) {
|
| - if (layer == globals.page_scale_application_layer) {
|
| - data_for_children.parent_matrix.Scale(
|
| - globals.page_scale_factor,
|
| - globals.page_scale_factor);
|
| - data_for_children.in_subtree_of_page_scale_application_layer = true;
|
| - }
|
| - if (layer == globals.elastic_overscroll_application_layer) {
|
| - data_for_children.parent_matrix.Translate(
|
| - -globals.elastic_overscroll.x(), -globals.elastic_overscroll.y());
|
| - }
|
| -
|
| - // Flatten to 2D if the layer doesn't preserve 3D.
|
| - if (layer->should_flatten_transform())
|
| - data_for_children.parent_matrix.FlattenTo2d();
|
| -
|
| - data_for_children.scroll_compensation_matrix =
|
| - ComputeScrollCompensationMatrixForChildren(
|
| - layer,
|
| - data_from_ancestor.parent_matrix,
|
| - data_from_ancestor.scroll_compensation_matrix,
|
| - effective_scroll_delta);
|
| - data_for_children.fixed_container =
|
| - layer->IsContainerForFixedPositionLayers() ?
|
| - layer : data_from_ancestor.fixed_container;
|
| -
|
| - data_for_children.clip_rect_in_target_space = clip_rect_in_target_space;
|
| - data_for_children.clip_rect_of_target_surface_in_target_space =
|
| - clip_rect_of_target_surface_in_target_space;
|
| - data_for_children.ancestor_clips_subtree =
|
| - layer_or_ancestor_clips_descendants;
|
| - data_for_children.nearest_occlusion_immune_ancestor_surface =
|
| - nearest_occlusion_immune_ancestor_surface;
|
| - data_for_children.subtree_is_visible_from_ancestor = layer_is_drawn;
|
| - }
|
| -
|
| - std::vector<LayerType*> sorted_children;
|
| - bool child_order_changed = false;
|
| - if (layer_draw_properties.has_child_with_a_scroll_parent)
|
| - child_order_changed = SortChildrenForRecursion(&sorted_children, *layer);
|
| -
|
| - for (size_t i = 0; i < layer->children().size(); ++i) {
|
| - // If one of layer's children has a scroll parent, then we may have to
|
| - // visit the children out of order. The new order is stored in
|
| - // sorted_children. Otherwise, we'll grab the child directly from the
|
| - // layer's list of children.
|
| - LayerType* child =
|
| - layer_draw_properties.has_child_with_a_scroll_parent
|
| - ? sorted_children[i]
|
| - : LayerTreeHostCommon::get_layer_as_raw_ptr(layer->children(), i);
|
| -
|
| - child->draw_properties().index_of_first_descendants_addition =
|
| - descendants.size();
|
| - child->draw_properties().index_of_first_render_surface_layer_list_addition =
|
| - render_surface_layer_list->size();
|
| -
|
| - CalculateDrawPropertiesInternal<LayerType>(
|
| - child,
|
| - globals,
|
| - data_for_children,
|
| - render_surface_layer_list,
|
| - &descendants,
|
| - accumulated_surface_state,
|
| - current_render_surface_layer_list_id);
|
| - // If the child is its own render target, then it has a render surface.
|
| - if (child->render_target() == child &&
|
| - !child->render_surface()->layer_list().empty() &&
|
| - !child->render_surface()->content_rect().IsEmpty()) {
|
| - // This child will contribute its render surface, which means
|
| - // we need to mark just the mask layer (and replica mask layer)
|
| - // with the id.
|
| - MarkMasksWithRenderSurfaceLayerListId(
|
| - child, current_render_surface_layer_list_id);
|
| - descendants.push_back(child);
|
| - }
|
| -
|
| - child->draw_properties().num_descendants_added =
|
| - descendants.size() -
|
| - child->draw_properties().index_of_first_descendants_addition;
|
| - child->draw_properties().num_render_surfaces_added =
|
| - render_surface_layer_list->size() -
|
| - child->draw_properties()
|
| - .index_of_first_render_surface_layer_list_addition;
|
| - layer_draw_properties.layer_or_descendant_is_drawn |=
|
| - child->draw_properties().layer_or_descendant_is_drawn;
|
| - }
|
| -
|
| - // Add the unsorted layer list contributions, if necessary.
|
| - if (child_order_changed) {
|
| - SortLayerListContributions(
|
| - *layer,
|
| - GetLayerListForSorting(render_surface_layer_list),
|
| - render_surface_layer_list_child_sorting_start_index,
|
| - &GetNewRenderSurfacesStartIndexAndCount<LayerType>);
|
| -
|
| - SortLayerListContributions(
|
| - *layer,
|
| - &descendants,
|
| - layer_list_child_sorting_start_index,
|
| - &GetNewDescendantsStartIndexAndCount<LayerType>);
|
| - }
|
| -
|
| - // Compute the total drawable_content_rect for this subtree (the rect is in
|
| - // target surface space).
|
| - gfx::Rect local_drawable_content_rect_of_subtree =
|
| - accumulated_surface_state->back().drawable_content_rect;
|
| - if (render_to_separate_surface) {
|
| - DCHECK(accumulated_surface_state->back().render_target == layer);
|
| - accumulated_surface_state->pop_back();
|
| - }
|
| -
|
| - if (render_to_separate_surface && !IsRootLayer(layer) &&
|
| - layer->render_surface()->layer_list().empty()) {
|
| - RemoveSurfaceForEarlyExit(layer, render_surface_layer_list);
|
| - return;
|
| - }
|
| -
|
| - // Compute the layer's drawable content rect (the rect is in target surface
|
| - // space).
|
| - layer_draw_properties.drawable_content_rect = rect_in_target_space;
|
| - if (layer_or_ancestor_clips_descendants) {
|
| - layer_draw_properties.drawable_content_rect.Intersect(
|
| - clip_rect_in_target_space);
|
| - }
|
| - if (layer->DrawsContent()) {
|
| - local_drawable_content_rect_of_subtree.Union(
|
| - layer_draw_properties.drawable_content_rect);
|
| - }
|
| -
|
| - // Compute the layer's visible content rect (the rect is in content space).
|
| - layer_draw_properties.visible_content_rect = CalculateVisibleContentRect(
|
| - layer, clip_rect_of_target_surface_in_target_space, rect_in_target_space);
|
| -
|
| - // Compute the remaining properties for the render surface, if the layer has
|
| - // one.
|
| - if (IsRootLayer(layer)) {
|
| - // The root layer's surface's content_rect is always the entire viewport.
|
| - DCHECK(render_to_separate_surface);
|
| - layer->render_surface()->SetContentRect(
|
| - ancestor_clip_rect_in_target_space);
|
| - } else if (render_to_separate_surface) {
|
| - typename LayerType::RenderSurfaceType* render_surface =
|
| - layer->render_surface();
|
| - gfx::Rect clipped_content_rect = local_drawable_content_rect_of_subtree;
|
| -
|
| - // 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->replica_layer() && TransformToParentIsKnown(layer)) {
|
| - // Note, it is correct to use data_from_ancestor.ancestor_clips_subtree
|
| - // here, because we are looking at this layer's render_surface, not the
|
| - // layer itself.
|
| - if (render_surface->is_clipped() && !clipped_content_rect.IsEmpty()) {
|
| - gfx::Rect surface_clip_rect = LayerTreeHostCommon::CalculateVisibleRect(
|
| - render_surface->clip_rect(),
|
| - clipped_content_rect,
|
| - render_surface->draw_transform());
|
| - clipped_content_rect.Intersect(surface_clip_rect);
|
| - }
|
| - }
|
| -
|
| - // The RenderSurfaceImpl backing texture cannot exceed the maximum supported
|
| - // texture size.
|
| - clipped_content_rect.set_width(
|
| - std::min(clipped_content_rect.width(), globals.max_texture_size));
|
| - clipped_content_rect.set_height(
|
| - std::min(clipped_content_rect.height(), globals.max_texture_size));
|
| -
|
| - if (clipped_content_rect.IsEmpty()) {
|
| - RemoveSurfaceForEarlyExit(layer, render_surface_layer_list);
|
| - return;
|
| - }
|
| -
|
| - // Layers having a non-default blend mode will blend with the content
|
| - // inside its parent's render target. This render target should be
|
| - // either root_for_isolated_group, or the root of the layer tree.
|
| - // Otherwise, this layer will use an incomplete backdrop, limited to its
|
| - // render target and the blending result will be incorrect.
|
| - DCHECK(layer->uses_default_blend_mode() || IsRootLayer(layer) ||
|
| - !layer->parent()->render_target() ||
|
| - IsRootLayer(layer->parent()->render_target()) ||
|
| - layer->parent()->render_target()->is_root_for_isolated_group());
|
| -
|
| - render_surface->SetContentRect(clipped_content_rect);
|
| -
|
| - // The owning layer's screen_space_transform 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 screen_space_transform = layer->screen_space_transform();
|
| - screen_space_transform.Scale(
|
| - layer->contents_scale_x() / combined_transform_scales.x(),
|
| - layer->contents_scale_y() / combined_transform_scales.y());
|
| - render_surface->SetScreenSpaceTransform(screen_space_transform);
|
| -
|
| - if (layer->replica_layer()) {
|
| - gfx::Transform surface_origin_to_replica_origin_transform;
|
| - surface_origin_to_replica_origin_transform.Scale(
|
| - combined_transform_scales.x(), combined_transform_scales.y());
|
| - surface_origin_to_replica_origin_transform.Translate(
|
| - layer->replica_layer()->position().x() +
|
| - layer->replica_layer()->transform_origin().x(),
|
| - layer->replica_layer()->position().y() +
|
| - layer->replica_layer()->transform_origin().y());
|
| - surface_origin_to_replica_origin_transform.PreconcatTransform(
|
| - layer->replica_layer()->transform());
|
| - surface_origin_to_replica_origin_transform.Translate(
|
| - -layer->replica_layer()->transform_origin().x(),
|
| - -layer->replica_layer()->transform_origin().y());
|
| - surface_origin_to_replica_origin_transform.Scale(
|
| - 1.0 / combined_transform_scales.x(),
|
| - 1.0 / combined_transform_scales.y());
|
| -
|
| - // Compute the replica's "originTransform" that maps from the replica's
|
| - // origin space to the target surface origin space.
|
| - gfx::Transform replica_origin_transform =
|
| - layer->render_surface()->draw_transform() *
|
| - surface_origin_to_replica_origin_transform;
|
| - render_surface->SetReplicaDrawTransform(replica_origin_transform);
|
| -
|
| - // Compute the replica's "screen_space_transform" that maps from the
|
| - // replica's origin space to the screen's origin space.
|
| - gfx::Transform replica_screen_space_transform =
|
| - layer->render_surface()->screen_space_transform() *
|
| - surface_origin_to_replica_origin_transform;
|
| - render_surface->SetReplicaScreenSpaceTransform(
|
| - replica_screen_space_transform);
|
| - }
|
| - }
|
| -
|
| - SavePaintPropertiesLayer(layer);
|
| -
|
| - // If neither this layer nor any of its children were added, early out.
|
| - if (sorting_start_index == descendants.size()) {
|
| - DCHECK(!render_to_separate_surface || IsRootLayer(layer));
|
| - return;
|
| - }
|
| -
|
| - UpdateAccumulatedSurfaceState<LayerType>(
|
| - layer, local_drawable_content_rect_of_subtree, accumulated_surface_state);
|
| -
|
| - if (layer->HasContributingDelegatedRenderPasses()) {
|
| - layer->render_target()->render_surface()->
|
| - AddContributingDelegatedRenderPassLayer(layer);
|
| - }
|
| -} // NOLINT(readability/fn_size)
|
| -
|
| -template <typename LayerType, typename RenderSurfaceLayerListType>
|
| -static void ProcessCalcDrawPropsInputs(
|
| - const LayerTreeHostCommon::CalcDrawPropsInputs<LayerType,
|
| - RenderSurfaceLayerListType>&
|
| - inputs,
|
| - SubtreeGlobals<LayerType>* globals,
|
| - DataForRecursion<LayerType>* data_for_recursion) {
|
| - DCHECK(inputs.root_layer);
|
| - DCHECK(IsRootLayer(inputs.root_layer));
|
| - DCHECK(inputs.render_surface_layer_list);
|
| -
|
| - gfx::Transform identity_matrix;
|
| -
|
| - // The root layer's render_surface should receive the device viewport as the
|
| - // initial clip rect.
|
| - gfx::Rect device_viewport_rect(inputs.device_viewport_size);
|
| -
|
| - gfx::Vector2dF device_transform_scale_components =
|
| - MathUtil::ComputeTransform2dScaleComponents(inputs.device_transform, 1.f);
|
| - // Not handling the rare case of different x and y device scale.
|
| - float device_transform_scale =
|
| - std::max(device_transform_scale_components.x(),
|
| - device_transform_scale_components.y());
|
| -
|
| - gfx::Transform scaled_device_transform = inputs.device_transform;
|
| - scaled_device_transform.Scale(inputs.device_scale_factor,
|
| - inputs.device_scale_factor);
|
| -
|
| - globals->max_texture_size = inputs.max_texture_size;
|
| - globals->device_scale_factor =
|
| - inputs.device_scale_factor * device_transform_scale;
|
| - globals->page_scale_factor = inputs.page_scale_factor;
|
| - globals->page_scale_application_layer = inputs.page_scale_application_layer;
|
| - globals->elastic_overscroll = inputs.elastic_overscroll;
|
| - globals->elastic_overscroll_application_layer =
|
| - inputs.elastic_overscroll_application_layer;
|
| - globals->can_render_to_separate_surface =
|
| - inputs.can_render_to_separate_surface;
|
| - globals->can_adjust_raster_scales = inputs.can_adjust_raster_scales;
|
| - globals->layers_always_allowed_lcd_text =
|
| - inputs.layers_always_allowed_lcd_text;
|
| -
|
| - data_for_recursion->parent_matrix = scaled_device_transform;
|
| - data_for_recursion->full_hierarchy_matrix = identity_matrix;
|
| - data_for_recursion->scroll_compensation_matrix = identity_matrix;
|
| - data_for_recursion->fixed_container = inputs.root_layer;
|
| - data_for_recursion->clip_rect_in_target_space = device_viewport_rect;
|
| - data_for_recursion->clip_rect_of_target_surface_in_target_space =
|
| - device_viewport_rect;
|
| - data_for_recursion->maximum_animation_contents_scale = 0.f;
|
| - data_for_recursion->ancestor_is_animating_scale = false;
|
| - data_for_recursion->ancestor_clips_subtree = true;
|
| - data_for_recursion->nearest_occlusion_immune_ancestor_surface = NULL;
|
| - data_for_recursion->in_subtree_of_page_scale_application_layer = false;
|
| - data_for_recursion->subtree_can_use_lcd_text = inputs.can_use_lcd_text;
|
| - data_for_recursion->subtree_is_visible_from_ancestor = true;
|
| -}
|
| -
|
| -void LayerTreeHostCommon::UpdateRenderSurface(
|
| - Layer* layer,
|
| - bool can_render_to_separate_surface,
|
| - gfx::Transform* transform,
|
| - bool* draw_transform_is_axis_aligned) {
|
| - bool preserves_2d_axis_alignment =
|
| - transform->Preserves2dAxisAlignment() && *draw_transform_is_axis_aligned;
|
| - if (IsRootLayer(layer) || (can_render_to_separate_surface &&
|
| - SubtreeShouldRenderToSeparateSurface(
|
| - layer, preserves_2d_axis_alignment))) {
|
| - // We reset the transform here so that any axis-changing transforms
|
| - // will now be relative to this RenderSurface.
|
| - transform->MakeIdentity();
|
| - *draw_transform_is_axis_aligned = true;
|
| - if (!layer->render_surface()) {
|
| - layer->CreateRenderSurface();
|
| - }
|
| - layer->SetHasRenderSurface(true);
|
| - return;
|
| - }
|
| - layer->SetHasRenderSurface(false);
|
| - if (layer->render_surface())
|
| - layer->ClearRenderSurface();
|
| -}
|
| -
|
| -void LayerTreeHostCommon::UpdateRenderSurfaces(
|
| - Layer* layer,
|
| - bool can_render_to_separate_surface,
|
| - const gfx::Transform& parent_transform,
|
| - bool draw_transform_is_axis_aligned) {
|
| - gfx::Transform transform_for_children = layer->transform();
|
| - transform_for_children *= parent_transform;
|
| - draw_transform_is_axis_aligned &= layer->AnimationsPreserveAxisAlignment();
|
| - UpdateRenderSurface(layer, can_render_to_separate_surface,
|
| - &transform_for_children, &draw_transform_is_axis_aligned);
|
| -
|
| - for (size_t i = 0; i < layer->children().size(); ++i) {
|
| - UpdateRenderSurfaces(layer->children()[i].get(),
|
| - can_render_to_separate_surface, transform_for_children,
|
| - draw_transform_is_axis_aligned);
|
| - }
|
| -}
|
| -
|
| -static bool ApproximatelyEqual(const gfx::Rect& r1, const gfx::Rect& r2) {
|
| - static const int tolerance = 1;
|
| - return std::abs(r1.x() - r2.x()) <= tolerance &&
|
| - std::abs(r1.y() - r2.y()) <= tolerance &&
|
| - std::abs(r1.width() - r2.width()) <= tolerance &&
|
| - std::abs(r1.height() - r2.height()) <= tolerance;
|
| -}
|
| -
|
| -void LayerTreeHostCommon::CalculateDrawProperties(
|
| - CalcDrawPropsMainInputs* inputs) {
|
| - UpdateRenderSurfaces(inputs->root_layer,
|
| - inputs->can_render_to_separate_surface, gfx::Transform(),
|
| - false);
|
| - LayerList dummy_layer_list;
|
| - SubtreeGlobals<Layer> globals;
|
| - DataForRecursion<Layer> data_for_recursion;
|
| - ProcessCalcDrawPropsInputs(*inputs, &globals, &data_for_recursion);
|
| -
|
| - PreCalculateMetaInformationRecursiveData recursive_data;
|
| -
|
| - if (!inputs->verify_property_trees) {
|
| - PreCalculateMetaInformation(inputs->root_layer, &recursive_data);
|
| - std::vector<AccumulatedSurfaceState<Layer>> accumulated_surface_state;
|
| - CalculateDrawPropertiesInternal<Layer>(
|
| - inputs->root_layer, globals, data_for_recursion,
|
| - inputs->render_surface_layer_list, &dummy_layer_list,
|
| - &accumulated_surface_state,
|
| - inputs->current_render_surface_layer_list_id);
|
| - } else {
|
| - {
|
| - TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug.cdp-perf"),
|
| - "LayerTreeHostCommon::CalculateDrawProperties");
|
| - PreCalculateMetaInformation(inputs->root_layer, &recursive_data);
|
| - std::vector<AccumulatedSurfaceState<Layer>> accumulated_surface_state;
|
| - CalculateDrawPropertiesInternal<Layer>(
|
| - inputs->root_layer, globals, data_for_recursion,
|
| - inputs->render_surface_layer_list, &dummy_layer_list,
|
| - &accumulated_surface_state,
|
| - inputs->current_render_surface_layer_list_id);
|
| - }
|
| -
|
| - // The translation from layer to property trees is an intermediate state. We
|
| - // will eventually get these data passed directly to the compositor.
|
| - TransformTree transform_tree;
|
| - ClipTree clip_tree;
|
| - OpacityTree opacity_tree;
|
| - {
|
| - TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug.cdp-perf"),
|
| - "LayerTreeHostCommon::ComputeVisibleRectsWithPropertyTrees");
|
| - ComputeVisibleRectsUsingPropertyTrees(
|
| - inputs->root_layer, inputs->page_scale_application_layer,
|
| - inputs->page_scale_factor, inputs->device_scale_factor,
|
| - gfx::Rect(inputs->device_viewport_size), inputs->device_transform,
|
| - &transform_tree, &clip_tree, &opacity_tree);
|
| - }
|
| -
|
| - LayerIterator<Layer> it, end;
|
| - for (it = LayerIterator<Layer>::Begin(inputs->render_surface_layer_list),
|
| - end = LayerIterator<Layer>::End(inputs->render_surface_layer_list);
|
| - it != end; ++it) {
|
| - Layer* current_layer = *it;
|
| - if (!it.represents_itself() || !current_layer->DrawsContent())
|
| - continue;
|
| -
|
| - const bool visible_rects_match =
|
| - ApproximatelyEqual(current_layer->visible_content_rect(),
|
| - current_layer->visible_rect_from_property_trees());
|
| - CHECK(visible_rects_match);
|
| -
|
| - const bool draw_opacities_match =
|
| - current_layer->draw_opacity() ==
|
| - current_layer->DrawOpacityFromPropertyTrees(opacity_tree);
|
| - CHECK(draw_opacities_match);
|
| - }
|
| - }
|
| -
|
| - // The dummy layer list should not have been used.
|
| - DCHECK_EQ(0u, dummy_layer_list.size());
|
| - // A root layer render_surface should always exist after
|
| - // CalculateDrawProperties.
|
| - DCHECK(inputs->root_layer->render_surface());
|
| -}
|
| -
|
| -void LayerTreeHostCommon::CalculateDrawProperties(
|
| - CalcDrawPropsImplInputs* inputs) {
|
| - LayerImplList dummy_layer_list;
|
| - SubtreeGlobals<LayerImpl> globals;
|
| - DataForRecursion<LayerImpl> data_for_recursion;
|
| - ProcessCalcDrawPropsInputs(*inputs, &globals, &data_for_recursion);
|
| -
|
| - PreCalculateMetaInformationRecursiveData recursive_data;
|
| - PreCalculateMetaInformation(inputs->root_layer, &recursive_data);
|
| - std::vector<AccumulatedSurfaceState<LayerImpl>> accumulated_surface_state;
|
| - CalculateDrawPropertiesInternal<LayerImpl>(
|
| - inputs->root_layer,
|
| - globals,
|
| - data_for_recursion,
|
| - inputs->render_surface_layer_list,
|
| - &dummy_layer_list,
|
| - &accumulated_surface_state,
|
| - inputs->current_render_surface_layer_list_id);
|
| -
|
| - // The dummy layer list should not have been used.
|
| - DCHECK_EQ(0u, dummy_layer_list.size());
|
| - // A root layer render_surface should always exist after
|
| - // CalculateDrawProperties.
|
| - DCHECK(inputs->root_layer->render_surface());
|
| -}
|
| -
|
| -} // namespace cc
|
|
|
Chromium Code Reviews
Issue 1057283003:
Remove parts of //cc we aren't using (Closed)
Base URL: git@github.com:domokit/mojo.git@master