Update from https://crrev.com/308996

cc/trees/draw_property_utils.cc

+// Copyright 2014 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/draw_property_utils.h"
+
+#include <vector>
+
+#include "cc/base/math_util.h"
+#include "cc/layers/layer.h"
+#include "cc/trees/property_tree.h"
+#include "cc/trees/property_tree_builder.h"
+#include "ui/gfx/geometry/rect_conversions.h"
+
+namespace cc {
+
+namespace {
+
+void CalculateVisibleRects(
+    const std::vector<Layer*>& layers_that_need_visible_rects,
+    const ClipTree& clip_tree,
+    const TransformTree& transform_tree) {
+  for (size_t i = 0; i < layers_that_need_visible_rects.size(); ++i) {
+    Layer* layer = layers_that_need_visible_rects[i];
+
+    // TODO(ajuma): Compute content_scale rather than using it. Note that for
+    // PictureLayer and PictureImageLayers, content_bounds == bounds and
+    // content_scale_x == content_scale_y == 1.0, so once impl painting is on
+    // everywhere, this code will be unnecessary.
+    gfx::Size layer_content_bounds = layer->content_bounds();
+    float contents_scale_x = layer->contents_scale_x();
+    float contents_scale_y = layer->contents_scale_y();
+    const bool has_clip = layer->clip_tree_index() > 0;
+    const TransformNode* transform_node =
+        transform_tree.Node(layer->transform_tree_index());
+    if (has_clip) {
+      const ClipNode* clip_node = clip_tree.Node(layer->clip_tree_index());
+      const TransformNode* clip_transform_node =
+          transform_tree.Node(clip_node->data.transform_id);
+      const TransformNode* target_node =
+          transform_tree.Node(layer->render_target()->transform_tree_index());
+
+      gfx::Transform clip_to_target;
+      gfx::Transform content_to_target;
+      gfx::Transform target_to_content;
+      gfx::Transform target_to_layer;
+
+      bool success =
+          transform_tree.ComputeTransform(clip_transform_node->id,
+                                          target_node->id, &clip_to_target) &&
+          transform_tree.ComputeTransform(transform_node->id, target_node->id,
+                                          &content_to_target) &&
+          transform_tree.ComputeTransform(target_node->id, transform_node->id,
+                                          &target_to_layer);
+
+      // This should only fail if we somehow got here with a singular ancestor.
+      DCHECK(success);
+
+      target_to_content.Scale(contents_scale_x, contents_scale_y);
+      target_to_content.Translate(-layer->offset_to_transform_parent().x(),
+                                  -layer->offset_to_transform_parent().y());
+      target_to_content.PreconcatTransform(target_to_layer);
+
+      content_to_target.Translate(layer->offset_to_transform_parent().x(),
+                                  layer->offset_to_transform_parent().y());
+      content_to_target.Scale(1.0 / contents_scale_x, 1.0 / contents_scale_y);
+
+      gfx::Rect layer_content_rect = gfx::Rect(layer_content_bounds);
+      gfx::RectF layer_content_bounds_in_target_space =
+          MathUtil::MapClippedRect(content_to_target, layer_content_rect);
+      gfx::RectF clip_rect_in_target_space;
+      if (target_node->id > clip_node->id) {
+        clip_rect_in_target_space = MathUtil::ProjectClippedRect(
+            clip_to_target, clip_node->data.combined_clip);
+      } else {
+        clip_rect_in_target_space = MathUtil::MapClippedRect(
+            clip_to_target, clip_node->data.combined_clip);
+      }
+
+      clip_rect_in_target_space.Intersect(layer_content_bounds_in_target_space);
+
+      gfx::Rect visible_rect =
+          gfx::ToEnclosingRect(MathUtil::ProjectClippedRect(
+              target_to_content, clip_rect_in_target_space));
+
+      visible_rect.Intersect(gfx::Rect(layer_content_bounds));
+
+      layer->set_visible_rect_from_property_trees(visible_rect);
+    } else {
+      layer->set_visible_rect_from_property_trees(
+          gfx::Rect(layer_content_bounds));
+    }
+  }
+}
+
+static bool IsRootLayerOfNewRenderingContext(Layer* layer) {
+  if (layer->parent())
+    return !layer->parent()->Is3dSorted() && layer->Is3dSorted();
+  return layer->Is3dSorted();
+}
+
+static inline bool LayerIsInExisting3DRenderingContext(Layer* layer) {
+  return layer->Is3dSorted() && layer->parent() &&
+         layer->parent()->Is3dSorted();
+}
+
+static bool TransformToScreenIsKnown(Layer* layer, const TransformTree& tree) {
+  const TransformNode* node = tree.Node(layer->transform_tree_index());
+  return !node->data.to_screen_is_animated;
+}
+
+static bool IsLayerBackFaceExposed(Layer* layer, const TransformTree& tree) {
+  if (!TransformToScreenIsKnown(layer, tree))
+    return false;
+  if (LayerIsInExisting3DRenderingContext(layer))
+    return layer->draw_transform_from_property_trees(tree).IsBackFaceVisible();
+  return layer->transform().IsBackFaceVisible();
+}
+
+static bool IsSurfaceBackFaceExposed(Layer* layer,
+                                     const TransformTree& tree) {
+  if (!TransformToScreenIsKnown(layer, tree))
+    return false;
+  if (LayerIsInExisting3DRenderingContext(layer))
+    return layer->draw_transform_from_property_trees(tree).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;
+}
+
+static bool HasSingularTransform(Layer* layer, const TransformTree& tree) {
+  const TransformNode* node = tree.Node(layer->transform_tree_index());
+  return !node->data.is_invertible || !node->data.ancestors_are_invertible;
+}
+
+static bool IsBackFaceInvisible(Layer* layer, const TransformTree& tree) {
+  Layer* 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();
+  }
+  return !backface_test_layer->double_sided() &&
+         IsLayerBackFaceExposed(backface_test_layer, tree);
+}
+
+static bool IsInvisibleDueToTransform(Layer* layer, const TransformTree& tree) {
+  return HasSingularTransform(layer, tree) || IsBackFaceInvisible(layer, tree);
+}
+
+void FindLayersThatNeedVisibleRects(Layer* layer,
+                                    const TransformTree& tree,
+                                    bool subtree_is_visible_from_ancestor,
+                                    std::vector<Layer*>* layers_to_update) {
+  const bool subtree_is_invisble =
+      layer->opacity() == 0.0f ||
+      (layer->has_render_surface() && !layer->double_sided() &&
+       IsSurfaceBackFaceExposed(layer, tree));
+
+  if (subtree_is_invisble)
+    return;
+
+  bool layer_is_drawn =
+      layer->HasCopyRequest() ||
+      (subtree_is_visible_from_ancestor && !layer->hide_layer_and_subtree());
+
+  if (layer_is_drawn && layer->DrawsContent()) {
+    const bool visible = !IsInvisibleDueToTransform(layer, tree);
+    if (visible)
+      layers_to_update->push_back(layer);
+  }
+
+  for (size_t i = 0; i < layer->children().size(); ++i) {
+    FindLayersThatNeedVisibleRects(layer->children()[i].get(),
+                                   tree,
+                                   layer_is_drawn,
+                                   layers_to_update);
+  }
+}
+
+}  // namespace
+
+void ComputeClips(ClipTree* clip_tree, const TransformTree& transform_tree) {
+  for (int i = 0; i < static_cast<int>(clip_tree->size()); ++i) {
+    ClipNode* clip_node = clip_tree->Node(i);
+
+    // Only descendants of a real clipping layer (i.e., not 0) may have their
+    // clip adjusted due to intersecting with an ancestor clip.
+    const bool is_clipped = clip_node->parent_id > 0;
+    if (!is_clipped) {
+      clip_node->data.combined_clip = clip_node->data.clip;
+      continue;
+    }
+
+    ClipNode* parent_clip_node = clip_tree->parent(clip_node);
+    const TransformNode* parent_transform_node =
+        transform_tree.Node(parent_clip_node->data.transform_id);
+    const TransformNode* transform_node =
+        transform_tree.Node(clip_node->data.transform_id);
+
+    // Clips must be combined in target space. We cannot, for example, combine
+    // clips in the space of the child clip. The reason is non-affine
+    // transforms. Say we have the following tree T->A->B->C, and B clips C, but
+    // draw into target T. It may be the case that A applies a perspective
+    // transform, and B and C are at different z positions. When projected into
+    // target space, the relative sizes and positions of B and C can shift.
+    // Since it's the relationship in target space that matters, that's where we
+    // must combine clips.
+    gfx::Transform parent_to_target;
+    gfx::Transform clip_to_target;
+    gfx::Transform target_to_clip;
+
+    bool success =
+        transform_tree.ComputeTransform(parent_transform_node->id,
+                                        clip_node->data.target_id,
+                                        &parent_to_target) &&
+        transform_tree.ComputeTransform(
+            transform_node->id, clip_node->data.target_id, &clip_to_target) &&
+        transform_tree.ComputeTransform(clip_node->data.target_id,
+                                        transform_node->id, &target_to_clip);
+
+    // If we can't compute a transform, it's because we had to use the inverse
+    // of a singular transform. We won't draw in this case, so there's no need
+    // to compute clips.
+    if (!success)
+      continue;
+
+    // In order to intersect with as small a rect as possible, we do a
+    // preliminary clip in target space so that when we project back, there's
+    // less likelihood of intersecting the view plane.
+    gfx::RectF inherited_clip_in_target_space = MathUtil::MapClippedRect(
+        parent_to_target, parent_clip_node->data.combined_clip);
+
+    gfx::RectF clip_in_target_space =
+        MathUtil::MapClippedRect(clip_to_target, clip_node->data.clip);
+
+    gfx::RectF intersected_in_target_space = gfx::IntersectRects(
+        inherited_clip_in_target_space, clip_in_target_space);
+
+    clip_node->data.combined_clip = MathUtil::ProjectClippedRect(
+        target_to_clip, intersected_in_target_space);
+
+    clip_node->data.combined_clip.Intersect(clip_node->data.clip);
+  }
+}
+
+void ComputeTransforms(TransformTree* transform_tree) {
+  for (int i = 0; i < static_cast<int>(transform_tree->size()); ++i)
+    transform_tree->UpdateScreenSpaceTransform(i);
+}
+
+void ComputeVisibleRectsUsingPropertyTrees(
+    Layer* root_layer,
+    const Layer* page_scale_layer,
+    float page_scale_factor,
+    float device_scale_factor,
+    const gfx::Rect& viewport,
+    const gfx::Transform& device_transform,
+    TransformTree* transform_tree,
+    ClipTree* clip_tree) {
+  PropertyTreeBuilder::BuildPropertyTrees(
+      root_layer, page_scale_layer, page_scale_factor, device_scale_factor,
+      viewport, device_transform, transform_tree, clip_tree);
+  ComputeTransforms(transform_tree);
+  ComputeClips(clip_tree, *transform_tree);
+
+  std::vector<Layer*> layers_to_update;
+  const bool subtree_is_visible_from_ancestor = true;
+  FindLayersThatNeedVisibleRects(root_layer, *transform_tree,
+                                 subtree_is_visible_from_ancestor,
+                                 &layers_to_update);
+  CalculateVisibleRects(layers_to_update, *clip_tree, *transform_tree);
+}
+
+}  // namespace cc