cc: Derive draw opacity from property trees

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 2502 matching lines @@
   DCHECK_EQ(0u, dummy_layer_list.size());
   // A root layer render_surface should always exist after
   // CalculateDrawProperties.
   DCHECK(inputs->root_layer->render_surface());
 
   if (inputs->verify_property_trees) {
     // 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;
     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);
+        &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_transforms_match = ApproximatelyEqual(
           current_layer->draw_transform(),
           current_layer->draw_transform_from_property_trees(transform_tree));
       CHECK(draw_transforms_match);
+
+      const bool draw_opacities_match =
+          current_layer->draw_opacity() ==
+          current_layer->DrawOpacityFromPropertyTrees(opacity_tree);
+      CHECK(draw_opacities_match);
     }
   }
 }
 
 void LayerTreeHostCommon::CalculateDrawProperties(
     CalcDrawPropsImplInputs* inputs) {
   LayerImplList dummy_layer_list;
   SubtreeGlobals<LayerImpl> globals;
   DataForRecursion<LayerImpl> data_for_recursion;
   ProcessCalcDrawPropsInputs(*inputs, &globals, &data_for_recursion);
@@ skipping 14 matching lines @@
       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