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 116 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->OnParentIsDrawnChanged(IsDrawn(), true);

[piman, 2013/01/31 23:21:59]

If we are going to propagate the information down, could we then store it and
make IsDrawn() non recursive?

[ajuma, 2013/02/01 16:04:06]

Done.

 }
 
 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 219 matching lines @@
   return visible_;
 }
 
 bool Layer::IsDrawn() const {
   const Layer* layer = this;
   while (layer && layer->visible_)
     layer = layer->parent_;
   return layer == NULL;
 }
 
+void Layer::OnParentIsDrawnChanged(bool parent_is_drawn, bool force_update) {
+  if (!visible_ && !force_update)
+    return;
+
+  cc_layer_->setIsDrawable(
+      visible_ && parent_is_drawn && type_ != LAYER_NOT_DRAWN);
+
+  for (size_t i = 0; i < children_.size(); ++i) {
+    children_[i]->OnParentIsDrawnChanged(visible_ && parent_is_drawn,
+                                         force_update);
+  }
+}
+
 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 45 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 184 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);
+  cc_layer_->setOpacity(opacity);
   if (schedule_draw)
     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);
+
+  if (parent_ && !parent_->IsDrawn())
+    return;
+
+  cc_layer_->setIsDrawable(visible_ && type_ != LAYER_NOT_DRAWN);
+  for (size_t i = 0; i < children_.size(); ++i)
+    children_[i]->OnParentIsDrawnChanged(visible_, false);

[piman, 2013/01/31 23:21:59]

Can we share that code with OnParentIsDrawnChanged? In particular the logic for
what we pass to setIsDrawable would benefit from being specified only once.

[ajuma, 2013/02/01 16:04:06]

Done. The logic is now specified only in 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