Handle ui::Layer's visibility using cc::Layer's m_isDrawable flag

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 25 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),
       opacity_(1.0f),
       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_x_offset_(0),
       zoom_y_offset_(0),
       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),
       opacity_(1.0f),
       background_blur_radius_(0),
       layer_saturation_(0.0f),
       layer_brightness_(0.0f),
       layer_grayscale_(0.0f),
       layer_inverted_(false),
       layer_mask_(NULL),
@@ skipping 44 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();
 }
 
 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;
   child->cc_layer_->removeFromParent();
 }
@@ skipping 213 matching lines @@
 }
 
 bool Layer::GetTargetVisibility() const {
   if (animator_.get() && animator_->IsAnimatingProperty(
       LayerAnimationElement::VISIBILITY))
     return animator_->GetTargetVisibility();
   return visible_;
 }
 
 bool Layer::IsDrawn() const {
-  const Layer* layer = this;
-  while (layer && layer->visible_)
-    layer = layer->parent_;
-  return layer == NULL;
+  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) {
@@ skipping 47 matching lines @@
       parent_->cc_layer_->replaceChild(cc_layer_, new_layer);
     }
     cc_layer_= new_layer;
     cc_layer_is_accelerated_ = layer_updated_externally_;
     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_->setOpacity(visible_ ? opacity_ : 0.f);
+    cc_layer_->setOpacity(opacity_);
     cc_layer_->setForceRenderSurface(force_render_surface_);
-    cc_layer_->setIsDrawable(true);
+    cc_layer_->setIsDrawable(IsDrawn());
     RecomputeTransform();
   }
   RecomputeDrawsContentAndUVRect();
 }
 
 void Layer::SetColor(SkColor color) {
   GetAnimator()->SetColor(color);
 }
 
 bool Layer::SchedulePaint(const gfx::Rect& invalid_rect) {
@@ skipping 181 matching lines @@
   }
 }
 
 void Layer::SetTransformImmediately(const gfx::Transform& transform) {
   transform_ = transform;
 
   RecomputeTransform();
 }
 
 void Layer::SetOpacityImmediately(float opacity) {
-  bool schedule_draw = (opacity != opacity_ && IsDrawn());
   opacity_ = opacity;
 
-  if (visible_)
-    cc_layer_->setOpacity(opacity);
-  if (schedule_draw)
-    ScheduleDraw();
+  cc_layer_->setOpacity(opacity);
+  ScheduleDraw();
 }
 
 void Layer::SetVisibilityImmediately(bool visible) {
   if (visible_ == visible)
     return;
 
   visible_ = visible;
-  // TODO(piman): Expose a visibility flag on WebLayer.
-  cc_layer_->setOpacity(visible_ ? opacity_ : 0.f);
+  UpdateIsDrawn();
 }
 
 void Layer::SetBrightnessImmediately(float brightness) {
   layer_brightness_ = brightness;
   SetLayerFilters();
 }
 
 void Layer::SetGrayscaleImmediately(float grayscale) {
   layer_grayscale_ = grayscale;
   SetLayerFilters();
@@ skipping 119 matching lines @@
     gfx::PointF uv_bottom_right(
         static_cast<float>(size.width())/texture_size.width(),
         static_cast<float>(size.height())/texture_size.height());
     texture_layer_->setUV(uv_top_left, uv_bottom_right);
 
     cc_layer_->setBounds(ConvertSizeToPixel(this, size));
   }
 }
 
 }  // namespace ui