cc: Add verify transform tree calculations to LayerTreeSettings

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 <stddef.h>
 
 #include <vector>
 
@@ skipping 870 matching lines @@
         << " layer: " << layer->id() << " clip id: " << layer->clip_tree_index()
         << " layer clip: " << layer->clip_rect().ToString() << " v.s. "
         << gfx::ToEnclosingRect(accumulated_clip).ToString()
         << " and clip node clip: "
         << gfx::ToEnclosingRect(clip_tree->Node(layer->clip_tree_index())
                                     ->data.clip_in_target_space)
                .ToString();
   }
 }
 
+static int FindTargetTransformTreeIndexFromEffectTree(
+    const EffectTree& effect_tree,
+    const int effect_tree_index) {
+  const EffectNode* node = effect_tree.Node(effect_tree_index);
+  if (node->data.has_render_surface)
+    return node->data.transform_id;
+  node = effect_tree.Node(node->data.target_id);
+  return node->data.transform_id;
+}
+
+static void VerifyDrawTransformsMatch(LayerImpl* layer,
+                                      PropertyTrees* property_trees) {
+  const int source_id = layer->transform_tree_index();
+  int destination_id = FindTargetTransformTreeIndexFromEffectTree(
+      property_trees->effect_tree, layer->effect_tree_index());
+  if (destination_id == 0 || destination_id == 1)

[ajuma, 2016/06/30 23:59:28]

Please leave a TODO here about sorting out these cases.

+    return;
+  gfx::Transform draw_transform;
+  property_trees->transform_tree.ComputeTransform(source_id, destination_id,
+                                                  &draw_transform);
+  TransformNode* target_node =
+      property_trees->transform_tree.Node(destination_id);
+  draw_transform.matrix().postScale(target_node->data.sublayer_scale.x(),
+                                    target_node->data.sublayer_scale.y(), 1.f);
+  if (layer->should_flatten_transform_from_property_tree())
+    draw_transform.FlattenTo2d();
+  draw_transform.Translate(layer->offset_to_transform_parent().x(),
+                           layer->offset_to_transform_parent().y());
+  DCHECK(draw_transform.ApproximatelyEqual(
+      DrawTransform(layer, property_trees->transform_tree)))
+      << " layer: " << layer->id() << " source transform id: " << source_id
+      << " destination transform id: " << destination_id
+      << " draw transform from transform tree: "
+      << DrawTransform(layer, property_trees->transform_tree).ToString()
+      << " v.s." << draw_transform.ToString();
+}
+
 static void ComputeVisibleRectsInternal(
     LayerImpl* root_layer,
     PropertyTrees* property_trees,
     bool can_render_to_separate_surface,
     std::vector<LayerImpl*>* visible_layer_list) {
   if (property_trees->non_root_surfaces_enabled !=
       can_render_to_separate_surface) {
     property_trees->non_root_surfaces_enabled = can_render_to_separate_surface;
     property_trees->transform_tree.set_needs_update(true);
   }
@@ skipping 72 matching lines @@
 
 void VerifyClipTreeCalculations(const LayerImplList& layer_list,
                                 PropertyTrees* property_trees) {
   if (property_trees->non_root_surfaces_enabled) {
     ComputeClipsWithEffectTree(property_trees);
   }
   for (auto layer : layer_list)
     ComputeLayerClipRect(property_trees, layer);
 }
 
+void VerifyTransformTreeCalculations(const LayerImplList& layer_list,
+                                     PropertyTrees* property_trees) {
+  for (auto layer : layer_list)
+    VerifyDrawTransformsMatch(layer, property_trees);
+}
+
 void ComputeVisibleRects(LayerImpl* root_layer,
                          PropertyTrees* property_trees,
                          bool can_render_to_separate_surface,
                          LayerImplList* visible_layer_list) {
   for (auto* layer : *root_layer->layer_tree_impl()) {
     UpdateRenderSurfaceForLayer(&property_trees->effect_tree,
                                 can_render_to_separate_surface, layer);
     EffectNode* node =
         property_trees->effect_tree.Node(layer->effect_tree_index());
     if (node->owner_id == layer->id())
@@ skipping 379 matching lines @@
 void UpdateElasticOverscroll(PropertyTrees* property_trees,
                              const Layer* overscroll_elasticity_layer,
                              const gfx::Vector2dF& elastic_overscroll) {
   UpdateElasticOverscrollInternal(property_trees, overscroll_elasticity_layer,
                                   elastic_overscroll);
 }
 
 }  // namespace draw_property_utils
 
 }  // namespace cc