cc: Allow transparent layers with background filters to render

cc/trees/draw_property_utils.cc

 // Copyright 2014 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/draw_property_utils.h"
 
 #include <vector>
 
 #include "cc/base/math_util.h"
 #include "cc/layers/layer.h"
@@ skipping 252 matching lines @@
       IsSurfaceBackFaceVisible(layer, tree))
     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->HasPotentiallyRunningOpacityAnimation())
     return false;
 
+  // If layer has a background filter, don't skip the layer, even it the
+  // opacity is 0.
+  if (!layer->background_filters().IsEmpty())
+    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,
                                           bool layer_is_drawn,
                                           const TransformTree& tree) {
   // If the layer transform is not invertible, it should not be drawn.
   if (!layer->transform_is_invertible() &&
       !layer->HasPotentiallyRunningTransformAnimation())
     return true;
 
   // When we need to do a readback/copy of a layer's output, we can not skip
   // it or any of its ancestors.
   if (layer->draw_properties().layer_or_descendant_has_copy_request)
     return false;
 
   // If the layer is not drawn, then skip it and its subtree.
   if (!layer_is_drawn)
     return true;
 
   if (layer->render_surface() && !layer->double_sided() &&
       !layer->HasPotentiallyRunningTransformAnimation() &&
       IsSurfaceBackFaceVisible(layer, tree))
     return true;
 
+  // If layer has a background filter, don't skip the layer, even it the
+  // opacity is 0.
+  if (!layer->background_filters().IsEmpty())
+    return false;
+
   // 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->HasPotentiallyRunningOpacityAnimation() &&
          !layer->OpacityCanAnimateOnImplThread();
 }
 
@@ skipping 531 matching lines @@
 gfx::Rect ClipRectFromPropertyTrees(const LayerImpl* layer,
                                     const TransformTree& transform_tree) {
   if (layer->is_clipped() && layer->clip_tree_index() > 0)
     return layer->clip_rect_in_target_space_from_property_trees();
   return MathUtil::MapEnclosingClippedRect(
       DrawTransformFromPropertyTrees(layer, transform_tree),
       gfx::Rect(layer->bounds()));
 }
 
 }  // namespace cc