Add a hide_layer_and_subtree() flag to cc::Layer

ui/compositor/layer.cc

 // Copyright (c) 2012 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 "ui/compositor/layer.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 29 matching lines @@
 
 }  // namespace
 
 namespace ui {
 
 Layer::Layer()
     : type_(LAYER_TEXTURED),
       compositor_(NULL),
       parent_(NULL),
       visible_(true),
-      is_drawn_(true),
       force_render_surface_(false),
       fills_bounds_opaquely_(true),
       layer_updated_externally_(false),
       background_blur_radius_(0),
       layer_saturation_(0.0f),
       layer_brightness_(0.0f),
       layer_grayscale_(0.0f),
       layer_inverted_(false),
       layer_mask_(NULL),
       layer_mask_back_link_(NULL),
       zoom_(1),
       zoom_inset_(0),
       delegate_(NULL),
       cc_layer_(NULL),
       scale_content_(true),
       device_scale_factor_(1.0f) {
   CreateWebLayer();
 }
 
 Layer::Layer(LayerType type)
     : type_(type),
       compositor_(NULL),
       parent_(NULL),
       visible_(true),
-      is_drawn_(true),
       force_render_surface_(false),
       fills_bounds_opaquely_(true),
       layer_updated_externally_(false),
       background_blur_radius_(0),
       layer_saturation_(0.0f),
       layer_brightness_(0.0f),
       layer_grayscale_(0.0f),
       layer_inverted_(false),
       layer_mask_(NULL),
       layer_mask_back_link_(NULL),
@@ skipping 49 matching lines @@
 }
 
 void Layer::Add(Layer* child) {
   DCHECK(!child->compositor_);
   if (child->parent_)
     child->parent_->Remove(child);
   child->parent_ = this;
   children_.push_back(child);
   cc_layer_->AddChild(child->cc_layer_);
   child->OnDeviceScaleFactorChanged(device_scale_factor_);
-  child->UpdateIsDrawn();
   if (GetCompositor())
     child->SendPendingThreadedAnimations();
 }
 
 void Layer::Remove(Layer* child) {
   std::vector<Layer*>::iterator i =
       std::find(children_.begin(), children_.end(), child);
   DCHECK(i != children_.end());
   children_.erase(i);
   child->parent_ = NULL;
@@ skipping 206 matching lines @@
   GetAnimator()->SetVisibility(visible);
 }
 
 bool Layer::GetTargetVisibility() const {
   if (animator_.get() && animator_->IsAnimatingProperty(
       LayerAnimationElement::VISIBILITY))
     return animator_->GetTargetVisibility();
   return visible_;
 }
 
-bool Layer::IsDrawn() const {
-  return is_drawn_;
-}
-
-void Layer::UpdateIsDrawn() {
-  bool updated_is_drawn = visible_ && (!parent_ || parent_->IsDrawn());
-
-  if (updated_is_drawn == is_drawn_)
-    return;
-
-  is_drawn_ = updated_is_drawn;
-  cc_layer_->SetIsDrawable(is_drawn_ && type_ != LAYER_NOT_DRAWN);
-
-  for (size_t i = 0; i < children_.size(); ++i) {
-    children_[i]->UpdateIsDrawn();
-  }
-}
-
 bool Layer::ShouldDraw() const {
   return type_ != LAYER_NOT_DRAWN && GetCombinedOpacity() > 0.0f;
 }
 
 // static
 void Layer::ConvertPointToLayer(const Layer* source,
                                 const Layer* target,
                                 gfx::Point* point) {
   if (source == target)
     return;
@@ skipping 71 matching lines @@
   delegated_renderer_layer_ = NULL;
 
   cc_layer_->AddLayerAnimationEventObserver(this);
   for (size_t i = 0; i < children_.size(); ++i) {
     DCHECK(children_[i]->cc_layer_);
     cc_layer_->AddChild(children_[i]->cc_layer_);
   }
   cc_layer_->SetAnchorPoint(gfx::PointF());
   cc_layer_->SetContentsOpaque(fills_bounds_opaquely_);
   cc_layer_->SetForceRenderSurface(force_render_surface_);
-  cc_layer_->SetIsDrawable(IsDrawn());
+  cc_layer_->SetHideLayerAndSubtree(!visible_);
 }
 
 void Layer::SwitchCCLayerForTest() {
   scoped_refptr<cc::ContentLayer> new_layer = cc::ContentLayer::Create(this);
   SwitchToLayer(new_layer);
   content_layer_ = new_layer;
 }
 
 void Layer::SetExternalTexture(Texture* texture) {
   // Hold a ref to the old |Texture| until we have updated all
@@ skipping 252 matching lines @@
 
   RecomputeDrawsContentAndUVRect();
   RecomputePosition();
 
   if (!closure.is_null())
     closure.Run();
 
   if (was_move) {
     // Don't schedule a draw if we're invisible. We'll schedule one
     // automatically when we get visible.
-    if (IsDrawn())
+    if (visible_)
       ScheduleDraw();
   } else {
     // Always schedule a paint, even if we're invisible.
     SchedulePaint(gfx::Rect(bounds.size()));
   }
 }
 
 void Layer::SetTransformImmediately(const gfx::Transform& transform) {
   RecomputeCCTransformFromTransform(transform);
 }
 
 void Layer::SetOpacityImmediately(float opacity) {
   cc_layer_->SetOpacity(opacity);
   ScheduleDraw();
 }
 
 void Layer::SetVisibilityImmediately(bool visible) {
   if (visible_ == visible)
     return;
 
   visible_ = visible;
-  UpdateIsDrawn();
+  cc_layer_->SetHideLayerAndSubtree(!visible_);
 }
 
 void Layer::SetBrightnessImmediately(float brightness) {
   layer_brightness_ = brightness;
   SetLayerFilters();
 }
 
 void Layer::SetGrayscaleImmediately(float grayscale) {
   layer_grayscale_ = grayscale;
   SetLayerFilters();
@@ skipping 186 matching lines @@
   cc_layer_->SetBounds(ConvertSizeToPixel(this, size));
 }
 
 void Layer::RecomputePosition() {
   cc_layer_->SetPosition(gfx::ScalePoint(
         gfx::PointF(bounds_.x(), bounds_.y()),
         device_scale_factor_));
 }
 
 }  // namespace ui