Update from https://crrev.com/318214

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 139 matching lines @@
 }
 
 static bool IsInvisibleDueToTransform(Layer* layer, const TransformTree& tree) {
   return HasSingularTransform(layer, tree) || IsBackFaceInvisible(layer, tree);
 }
 
 void FindLayersThatNeedVisibleRects(Layer* layer,
                                     const TransformTree& tree,
                                     bool subtree_is_visible_from_ancestor,
                                     std::vector<Layer*>* layers_to_update) {
-  const bool subtree_is_invisble =
-      layer->opacity() == 0.0f ||
+  const bool layer_is_invisible =
+      (!layer->opacity() && !layer->OpacityIsAnimating() &&
+       !layer->OpacityCanAnimateOnImplThread());
+  const bool layer_is_backfacing =
       (layer->has_render_surface() && !layer->double_sided() &&
        IsSurfaceBackFaceExposed(layer, tree));
 
+  const bool subtree_is_invisble = layer_is_invisible || layer_is_backfacing;
   if (subtree_is_invisble)
     return;
 
   bool layer_is_drawn =
       layer->HasCopyRequest() ||
       (subtree_is_visible_from_ancestor && !layer->hide_layer_and_subtree());
 
   if (layer_is_drawn && layer->DrawsContent()) {
     const bool visible = !IsInvisibleDueToTransform(layer, tree);
     if (visible)
@@ skipping 80 matching lines @@
 }
 
 void ComputeVisibleRectsUsingPropertyTrees(
     Layer* root_layer,
     const Layer* page_scale_layer,
     float page_scale_factor,
     float device_scale_factor,
     const gfx::Rect& viewport,
     const gfx::Transform& device_transform,
     TransformTree* transform_tree,
-    ClipTree* clip_tree) {
+    ClipTree* clip_tree,
+    OpacityTree* opacity_tree) {
   PropertyTreeBuilder::BuildPropertyTrees(
       root_layer, page_scale_layer, page_scale_factor, device_scale_factor,
-      viewport, device_transform, transform_tree, clip_tree);
+      viewport, device_transform, transform_tree, clip_tree, opacity_tree);
   ComputeTransforms(transform_tree);
   ComputeClips(clip_tree, *transform_tree);
 
   std::vector<Layer*> layers_to_update;
   const bool subtree_is_visible_from_ancestor = true;
   FindLayersThatNeedVisibleRects(root_layer, *transform_tree,
                                  subtree_is_visible_from_ancestor,
                                  &layers_to_update);
   CalculateVisibleRects(layers_to_update, *clip_tree, *transform_tree);
 }
 
 }  // namespace cc