Add a hide_layer_and_subtree() flag to cc::Layer

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/debug/trace_event.h"
 #include "cc/base/math_util.h"
@@ skipping 214 matching lines @@
   // back of the layer is known to be facing the screen.
   if (!backface_test_layer->double_sided() &&
       TransformToScreenIsKnown(backface_test_layer) &&
       IsLayerBackFaceVisible(backface_test_layer))
     return true;
 
   return false;
 }
 
 static inline bool SubtreeShouldBeSkipped(LayerImpl* layer) {
+  // The embedder can request to hide the entire layer's subtree.
+  if (layer->hide_layer_and_subtree())
+    return true;
+
   // If layer is on the pending tree and opacity is being animated then
   // this subtree can't be skipped as we need to create, prioritize and
   // include tiles for this layer when deciding if tree can be activated.
   if (layer->layer_tree_impl()->IsPendingTree() && layer->OpacityIsAnimating())
     return false;
 
   // The opacity of a layer always applies to its children (either implicitly
   // via a render surface or explicitly if the parent preserves 3D), so the
   // entire subtree can be skipped if this layer is fully transparent.
   return !layer->opacity();
 }
 
 static inline bool SubtreeShouldBeSkipped(Layer* layer) {
+  // The embedder can request to hide the entire layer's subtree.
+  if (layer->hide_layer_and_subtree())
+    return true;
+
   // If the opacity is being animated then the opacity on the main thread is
   // unreliable (since the impl thread may be using a different opacity), so it
   // should not be trusted.
   // In particular, it should not cause the subtree to be skipped.
   // Similarly, for layers that might animate opacity using an impl-only
   // animation, their subtree should also not be skipped.
   return !layer->opacity() && !layer->OpacityIsAnimating() &&
          !layer->OpacityCanAnimateOnImplThread();
 }
 
@@ skipping 1228 matching lines @@
           layer->render_surface()->screen_space_transform() *
           surface_origin_to_replica_origin_transform;
       render_surface->SetReplicaScreenSpaceTransform(
           replica_screen_space_transform);
     }
   }
 
   UpdateTilePrioritiesForLayer(layer);
 
   // If neither this layer nor any of its children were added, early out.
-  if (sorting_start_index == descendants.size())
+  if (!IsRootLayer(layer) && sorting_start_index == descendants.size())

[enne (OOO), 2013/06/20 00:17:47]

If the root layer doesn't draw, why does it need to save paint properties?

[danakj, 2013/06/20 00:20:04]

Because otherwise the impl layer doesn't get the real values pushed. Right now
that's just bounds, so the impl root layer always has bounds 0x0 even though we
have a bounds on the main thread. That seems wrong, though not hugely
problematic in practice.

     return;
 
   // If preserves-3d then sort all the descendants in 3D so that they can be
   // drawn from back to front. If the preserves-3d property is also set on the
   // parent then skip the sorting as the parent will sort all the descendants
   // anyway.
   if (layer_sorter && descendants.size() && layer->preserves_3d() &&
       (!layer->parent() || !layer->parent()->preserves_3d())) {
     SortLayers(descendants.begin() + sorting_start_index,
                descendants.end(),
@@ skipping 315 matching lines @@
   // At this point, we think the point does hit the touch event handler region
   // on the layer, but we need to walk up the parents to ensure that the layer
   // was not clipped in such a way that the hit point actually should not hit
   // the layer.
   if (PointIsClippedBySurfaceOrClipRect(screen_space_point, layer_impl))
     return false;
 
   return true;
 }
 }  // namespace cc