Compute if a layer is drawn without LayerTree hierarchy

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 <utility>
 
 #include "base/auto_reset.h"
@@ skipping 57 matching lines @@
       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),
       owner_(NULL),
       cc_layer_(NULL),
-      device_scale_factor_(1.0f) {
+      device_scale_factor_(1.0f),
+      cached_cc_layer_opacity_(1.0f) {
   CreateCcLayer();
 }
 
 Layer::Layer(LayerType type)
     : type_(type),
       compositor_(NULL),
       parent_(NULL),
       visible_(true),
       force_render_surface_(false),
       fills_bounds_opaquely_(true),
       fills_bounds_completely_(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),
       owner_(NULL),
       cc_layer_(NULL),
-      device_scale_factor_(1.0f) {
+      device_scale_factor_(1.0f),
+      cached_cc_layer_opacity_(1.0f) {
   CreateCcLayer();
 }
 
 Layer::~Layer() {
   // Destroying the animator may cause observers to use the layer (and
   // indirectly the WebLayer). Destroy the animator first so that the WebLayer
   // is still around.
   if (animator_.get())
     animator_->SetDelegate(NULL);
   animator_ = NULL;
@@ skipping 22 matching lines @@
   g_ui_layer_settings.Get().use_compositor_animation_timelines =
       !command_line->HasSwitch(
           switches::kUIDisableCompositorAnimationTimelines);
 }
 
 const Compositor* Layer::GetCompositor() const {
   return GetRoot(this)->compositor_;
 }
 
 float Layer::opacity() const {
-  return cc_layer_->opacity();
+  return !visible_ ? cached_cc_layer_opacity_ : cc_layer_->opacity();
 }
 
 void Layer::SetCompositor(Compositor* compositor,
                           scoped_refptr<cc::Layer> root_layer) {
   // This function must only be called to set the compositor on the root ui
   // layer.
   DCHECK(compositor);
   DCHECK(!compositor_);
   DCHECK(compositor->root_layer() == this);
   DCHECK(!parent_);
@@ skipping 119 matching lines @@
 
 void Layer::SetMasksToBounds(bool masks_to_bounds) {
   cc_layer_->SetMasksToBounds(masks_to_bounds);
 }
 
 bool Layer::GetMasksToBounds() const {
   return cc_layer_->masks_to_bounds();
 }
 
 void Layer::SetOpacity(float opacity) {
-  GetAnimator()->SetOpacity(opacity);
+  if (visible_)
+    GetAnimator()->SetOpacity(opacity);
+  else
+    cached_cc_layer_opacity_ = opacity;
 }
 
 float Layer::GetCombinedOpacity() const {
   float opacity = this->opacity();
   Layer* current = this->parent_;
   while (current) {
     opacity *= current->opacity();
     current = current->parent_;
   }
   return opacity;
@@ skipping 220 matching lines @@
 
   for (size_t i = 0; i < children_.size(); ++i) {
     DCHECK(children_[i]->cc_layer_);
     cc_layer_->AddChild(children_[i]->cc_layer_);
   }
   cc_layer_->SetLayerClient(this);
   cc_layer_->SetTransformOrigin(gfx::Point3F());
   cc_layer_->SetContentsOpaque(fills_bounds_opaquely_);
   cc_layer_->SetForceRenderSurface(force_render_surface_);
   cc_layer_->SetIsDrawable(type_ != LAYER_NOT_DRAWN);
-  cc_layer_->SetHideLayerAndSubtree(!visible_);
 
   SetLayerFilters();
   SetLayerBackgroundFilters();
 }
 
 void Layer::SwitchCCLayerForTest() {
   scoped_refptr<cc::Layer> new_layer =
       cc::PictureLayer::Create(UILayerSettings(), this);
   SwitchToLayer(new_layer);
   content_layer_ = new_layer;
@@ skipping 368 matching lines @@
 void Layer::SetOpacityFromAnimation(float opacity) {
   cc_layer_->SetOpacity(opacity);
   ScheduleDraw();
 }
 
 void Layer::SetVisibilityFromAnimation(bool visible) {
   if (visible_ == visible)
     return;
 
   visible_ = visible;
-  cc_layer_->SetHideLayerAndSubtree(!visible_);
+  if (visible) {
+    cc_layer_->SetOpacity(cached_cc_layer_opacity_);
+  } else {
+    cached_cc_layer_opacity_ = cc_layer_->opacity();
+    cc_layer_->SetOpacity(0.f);
+  }
 }
 
 void Layer::SetBrightnessFromAnimation(float brightness) {
   layer_brightness_ = brightness;
   SetLayerFilters();
 }
 
 void Layer::SetGrayscaleFromAnimation(float grayscale) {
   layer_grayscale_ = grayscale;
   SetLayerFilters();
@@ skipping 172 matching lines @@
     animator_->ResetCompositor(compositor);
     if (animator_->is_animating())
       animator_->RemoveFromCollection(collection);
   }
 
   for (auto* child : children_)
     child->ResetCompositorForAnimatorsInTree(compositor);
 }
 
 }  // namespace ui