cc: Make property trees support resourceless draw mode

cc/trees/property_tree_builder.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/property_tree_builder.h"
 
 #include <map>
 #include <set>
 
 #include "cc/base/math_util.h"
@@ skipping 120 matching lines @@
     // Without a new render surface, layer clipping state from ancestors needs
     // to continue to propagate.
     data_for_children->target_is_clipped = data_from_ancestor.target_is_clipped;
     layers_are_clipped = ancestor_clips_subtree;
   }
 
   bool layer_clips_subtree = LayerClipsSubtree(layer);
   if (layer_clips_subtree)
     layers_are_clipped = true;
 
+  // Without surfaces, all non-viewport clips have to be applied using layer
+  // clipping.
+  bool layers_are_clipped_when_surfaces_disabled =
+      layer_clips_subtree ||
+      parent->data.layers_are_clipped_when_surfaces_disabled;
+
   bool applies_clip =
       AppliesClip(layer, data_from_ancestor, ancestor_clips_subtree);
   bool parent_applies_clip =
       !parent->data.resets_clip || parent->data.applies_local_clip;
 
   // When we have an unclipped surface, all ancestor clips no longer apply.
   // However, if our parent already clears ancestor clips and applies no clip of
   // its own, there aren't any ancestor clips that need clearing.
   bool needs_to_clear_ancestor_clips =
       has_unclipped_surface && parent_applies_clip;
   bool requires_node = applies_clip || needs_to_clear_ancestor_clips;
 
   if (!requires_node) {

[jaydasika, 2015/10/16 21:27:09]

In the resourceless draw mode case, can we not just create clip nodes when
layer_clips_subtree = true as we don't have to bother about render surfaces?

[ajuma, 2015/10/16 22:40:41]

It's true that these are the only clips we have to apply in resourceless mode.
But when we're building trees, we need trees that can support both modes without
requiring a rebuild when the mode changes (since the mode can change arbitrarily
on the compositor thread). So, for example, a single set of trees built on the
main thread and then committed to the compositor thread might be used for a
resourceless draw, then a regular draw, and then another resourceless draw.

     data_for_children->clip_tree_parent = parent_id;
     DCHECK_EQ(layers_are_clipped, parent->data.layers_are_clipped);
+    DCHECK_EQ(layers_are_clipped_when_surfaces_disabled,
+              parent->data.layers_are_clipped_when_surfaces_disabled);
   } else {
     LayerType* transform_parent = data_for_children->transform_tree_parent;
     if (layer->position_constraint().is_fixed_position() &&
         !created_transform_node) {
       transform_parent = data_for_children->transform_fixed_parent;
     }
     ClipNode node;
     node.data.clip =
         gfx::RectF(gfx::PointF() + layer->offset_to_transform_parent(),
                    gfx::SizeF(layer->bounds()));
@@ skipping 27 matching lines @@
       // Otherwise, we're either unclipped, or exist only in order to apply our
       // parent's clips in our space.
       node.data.applies_local_clip = false;
       node.data.layer_clipping_uses_only_local_clip = false;
       node.data.layer_visibility_uses_only_local_clip = false;
     }
 
     node.data.resets_clip = has_unclipped_surface || !parent_applies_clip;
     node.data.target_is_clipped = data_for_children->target_is_clipped;
     node.data.layers_are_clipped = layers_are_clipped;
+    node.data.layers_are_clipped_when_surfaces_disabled =
+        layers_are_clipped_when_surfaces_disabled;
 
     data_for_children->clip_tree_parent =
         data_for_children->clip_tree->Insert(node, parent_id);
   }
 
   layer->SetClipTreeIndex(data_for_children->clip_tree_parent);
 
   // TODO(awoloszyn): Right now when we hit a node with a replica, we reset the
   // clip for all children since we may need to draw. We need to figure out a
   // better way, since we will need both the clipped and unclipped versions.
@@ skipping 406 matching lines @@
     const gfx::Rect& viewport,
     const gfx::Transform& device_transform,
     PropertyTrees* property_trees) {
   BuildPropertyTreesTopLevelInternal(
       root_layer, page_scale_layer, inner_viewport_scroll_layer,
       outer_viewport_scroll_layer, page_scale_factor, device_scale_factor,
       viewport, device_transform, property_trees);
 }
 
 }  // namespace cc