cc/blimp: Eliminate Layer updates for common cases.

cc/blimp/layer_tree_host_remote.cc

 // Copyright 2016 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/blimp/layer_tree_host_remote.h"
 
 #include "base/atomic_sequence_num.h"
 #include "base/auto_reset.h"
 #include "base/memory/ptr_util.h"
 #include "cc/animation/animation_host.h"
@@ skipping 11 matching lines @@
 #include "cc/trees/task_runner_provider.h"
 #include "ui/gfx/geometry/scroll_offset.h"
 
 namespace cc {
 namespace {
 // We use a 16ms default frame interval because the rate at which the engine
 // produces main frames doesn't matter.
 base::TimeDelta kDefaultFrameInterval = base::TimeDelta::FromMilliseconds(16);
 
 static base::StaticAtomicSequenceNumber s_layer_tree_host_sequence_number;
+
+bool ShouldUpdateLayer(Layer* layer) {
+  // If the embedder has marked the layer as non-drawable.
+  if (!layer->DrawsContent())
+    return false;
+
+  // If the layer bounds are empty.
+  if (layer->bounds().IsEmpty())
+    return false;
+
+  // If the layer is transparent and has no background filters applied.
+  // See EffectTree::UpdateIsDrawn for the logic details.
+  // A few things have been ignored:
+  // 1) We don't support threaded animations at the moment, so the opacity can
+  //    not change on the client.
+  // 2) This does not account for layer hiding its subtree, but that is never
+  //    used by the renderer.

[ajuma, 2016/11/01 19:27:58]

It's true that the renderer never uses the HideLayerAndSubtree call, but there's
still the case of a layer with opacity 0 causing its subtree to get skipped.
Those layers won't get skipped with the logic below (but that might be fine --
the amount of work saved by skipping is small).

[Khushal, 2016/11/01 21:09:01]

You're right, thanks! I've added that in the comment. Will come back here later,
I'm going to leave the bug open for now.

Also, while writing the test, I ran into a problem because
CallFunctionForEveryLayer wouldn't run on a mask layer's subtree. Is that
expected? Is the mask layer not supposed to have any children?

[ajuma, 2016/11/01 21:37:07]

Right, a mask layer shouldn't have children, the mask layer itself is supposed
to represent the entire mask.

[Khushal, 2016/11/01 21:42:23]

Ohh, makes sense. Would it be a good idea to add a DCHECK in Layer::SetMaskLayer
for this? Makes it obvious to someone reading it.

[ajuma, 2016/11/01 21:47:20]

Yes, that's an excellent idea!

[Khushal, 2016/11/01 23:21:00]

Done. :)

+  if (layer->opacity() == 0.f && layer->background_filters().IsEmpty())
+    return false;
+
+  return true;
+}
+
 }  // namespace
 
 LayerTreeHostRemote::InitParams::InitParams() = default;
 
 LayerTreeHostRemote::InitParams::~InitParams() = default;
 
 LayerTreeHostRemote::LayerTreeHostRemote(InitParams* params)
     : LayerTreeHostRemote(
           params,
           base::MakeUnique<LayerTree>(std::move(params->animation_host),
@@ skipping 314 matching lines @@
 
   current_pipeline_stage_ = FramePipelineStage::UPDATE_LAYERS;
   LayerList layer_list;
   if (max_pipeline_stage_for_current_frame_ >=
       FramePipelineStage::UPDATE_LAYERS) {
     // Pull updates for all layers from the client.
     // TODO(khushalsagar): Investigate the data impact from updating all the
     // layers. See crbug.com/650885.
     LayerTreeHostCommon::CallFunctionForEveryLayer(
         layer_tree_.get(), [&layer_list](Layer* layer) {
+          if (!ShouldUpdateLayer(layer))
+            return;
           layer->SavePaintProperties();
           layer_list.push_back(layer);
         });
 
     bool content_is_suitable_for_gpu = false;
     bool layers_updated =
         layer_tree_->UpdateLayers(layer_list, &content_is_suitable_for_gpu);
 
     // If pulling layer updates resulted in any content updates, we need to go
     // till the commit stage.
@@ skipping 117 matching lines @@
         layer_tree_host_proto->mutable_layer_updates(), inputs_only);
   layer_tree_->LayersThatShouldPushProperties().clear();
 
   std::vector<PictureData> pictures =
       engine_picture_cache_->CalculateCacheUpdateAndFlush();
   proto::PictureDataVectorToSkPicturesProto(
       pictures, layer_tree_host_proto->mutable_pictures());
 }
 
 }  // namespace cc