cc: Add property tree verification for compositor thread

cc/trees/layer_tree_host_common.cc

 // 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"
@@ skipping 2580 matching lines @@
       const float tolerance =
           col == 3 && row < 3 ? translation_tolerance : component_tolerance;
       if (delta > tolerance)
         return false;
     }
   }
 
   return true;
 }
 
+template <typename LayerType>
+void VerifyPropertyTreeValuesForLayer(LayerType* current_layer,
+                                      PropertyTrees* property_trees) {
+  const bool visible_rects_match =
+      ApproximatelyEqual(current_layer->visible_content_rect(),
+                         current_layer->visible_rect_from_property_trees());
+  CHECK(visible_rects_match)
+      << "expected: " << current_layer->visible_content_rect().ToString()
+      << " actual: "
+      << current_layer->visible_rect_from_property_trees().ToString();
+
+  const bool draw_transforms_match =
+      ApproximatelyEqual(current_layer->draw_transform(),
+                         DrawTransformFromPropertyTrees(
+                             current_layer, property_trees->transform_tree));
+  CHECK(draw_transforms_match)
+      << "expected: " << current_layer->draw_transform().ToString()
+      << " actual: "
+      << DrawTransformFromPropertyTrees(
+             current_layer, property_trees->transform_tree).ToString();
+
+  const bool draw_opacities_match =
+      current_layer->draw_opacity() ==
+      DrawOpacityFromPropertyTrees(current_layer, property_trees->opacity_tree);
+  CHECK(draw_opacities_match)
+      << "expected: " << current_layer->draw_opacity()
+      << " actual: " << DrawOpacityFromPropertyTrees(
+                            current_layer, property_trees->opacity_tree);
+}
+
 void VerifyPropertyTreeValues(
     LayerTreeHostCommon::CalcDrawPropsMainInputs* inputs) {
   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)
-        << "expected: " << current_layer->visible_content_rect().ToString()
-        << " actual: "
-        << current_layer->visible_rect_from_property_trees().ToString();
-
-    const bool draw_transforms_match = ApproximatelyEqual(
-        current_layer->draw_transform(),
-        DrawTransformFromPropertyTrees(current_layer,
-                                       inputs->property_trees->transform_tree));
-    CHECK(draw_transforms_match)
-        << "expected: " << current_layer->draw_transform().ToString()
-        << " actual: "
-        << DrawTransformFromPropertyTrees(
-               current_layer, inputs->property_trees->transform_tree)
-               .ToString();
-
-    const bool draw_opacities_match =
-        current_layer->draw_opacity() ==
-        DrawOpacityFromPropertyTrees(current_layer,
-                                     inputs->property_trees->opacity_tree);
-    CHECK(draw_opacities_match)
-        << "expected: " << current_layer->draw_opacity() << " actual: "
-        << DrawOpacityFromPropertyTrees(current_layer,
-                                        inputs->property_trees->opacity_tree);
+    VerifyPropertyTreeValuesForLayer(current_layer, inputs->property_trees);
   }
 }
 
 void VerifyPropertyTreeValues(
     LayerTreeHostCommon::CalcDrawPropsImplInputs* inputs) {
-  // TODO(enne): need to synchronize compositor thread changes
-  // for animation and scrolling to the property trees before these
-  // can be correct.
+  LayerIterator<LayerImpl> it, end;
+  for (it = LayerIterator<LayerImpl>::Begin(inputs->render_surface_layer_list),
+      end = LayerIterator<LayerImpl>::End(inputs->render_surface_layer_list);
+       it != end; ++it) {
+    LayerImpl* current_layer = *it;
+    if (!it.represents_itself() || !current_layer->DrawsContent())
+      continue;
+    VerifyPropertyTreeValuesForLayer(current_layer, inputs->property_trees);
+  }
 }
 
 enum PropertyTreeOption {
   BUILD_PROPERTY_TREES_IF_NEEDED,
   DONT_BUILD_PROPERTY_TREES
 };
 
 template <typename LayerType, typename RenderSurfaceLayerListType>
 void CalculateDrawPropertiesAndVerify(LayerTreeHostCommon::CalcDrawPropsInputs<
                                           LayerType,
@@ skipping 101 matching lines @@
                                 PropertyTrees* trees_from_inputs) {
   return layer->layer_tree_host()->property_trees();
 }
 
 PropertyTrees* GetPropertyTrees(LayerImpl* layer,
                                 PropertyTrees* trees_from_inputs) {
   return trees_from_inputs;
 }
 
 }  // namespace cc