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 1226 matching lines @@
       // replica's origin space to the screen's origin space.
       gfx::Transform replica_screen_space_transform =
           layer->render_surface()->screen_space_transform() *
           surface_origin_to_replica_origin_transform;
       render_surface->SetReplicaScreenSpaceTransform(
           replica_screen_space_transform);
     }
   }
 
   UpdateTilePrioritiesForLayer(layer);
+  SavePaintPropertiesLayer(layer);
 
   // If neither this layer nor any of its children were added, early out.
   if (sorting_start_index == descendants.size())
     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(),
                layer_sorter);
   }
 
   if (layer->render_surface()) {
     *drawable_content_rect_of_subtree =
         gfx::ToEnclosingRect(layer->render_surface()->DrawableContentRect());
   } else {
     *drawable_content_rect_of_subtree = local_drawable_content_rect_of_subtree;
   }
 
   if (layer->HasContributingDelegatedRenderPasses()) {
     layer->render_target()->render_surface()->
         AddContributingDelegatedRenderPassLayer(layer);
   }
-
-  SavePaintPropertiesLayer(layer);
 }
 
 void LayerTreeHostCommon::CalculateDrawProperties(
     Layer* root_layer,
     gfx::Size device_viewport_size,
     const gfx::Transform& device_transform,
     float device_scale_factor,
     float page_scale_factor,
     Layer* page_scale_application_layer,
     int max_texture_size,
@@ skipping 289 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