cc : Calculate jitter without using layer hierarchy

cc/trees/layer_tree_host_common.cc

 // Copyright 2011 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/layer_tree_host_common.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
@@ skipping 601 matching lines @@
               pending_tree_layer->draw_properties()
                   .screen_space_transform.To2dTranslation())
           .Length();
     }
   }
   return 0.f;
 }
 
 // A layer jitters if its screen space transform is same on two successive
 // commits, but has changed in between the commits. CalculateFrameJitter
-// computes the jitter in the entire frame.
+// computes the jitter for the layer.
 int LayerTreeHostCommon::CalculateFrameJitter(LayerImpl* layer) {

[ajuma, 2016/03/29 14:24:02]

"CalculateLayerJitter" or "CalculateJitter"?

[jaydasika, 2016/03/29 15:57:24]

Done.

-  if (!layer)
-    return 0.f;
   float jitter = 0.f;
   layer->performance_properties().translation_from_last_frame = 0.f;
   layer->performance_properties().last_commit_screen_space_transform =
       layer->draw_properties().screen_space_transform;
 
   if (!layer->visible_layer_rect().IsEmpty()) {
     if (layer->draw_properties().screen_space_transform.ApproximatelyEqual(
             layer->performance_properties()
                 .last_commit_screen_space_transform)) {
       float translation_from_last_commit =
           TranslationFromActiveTreeLayerScreenSpaceTransform(layer);
       if (translation_from_last_commit > 0.f) {
         layer->performance_properties().num_fixed_point_hits++;
         layer->performance_properties().translation_from_last_frame =
             translation_from_last_commit;
         if (layer->performance_properties().num_fixed_point_hits >
             layer->layer_tree_impl()->kFixedPointHitsThreshold) {
           // Jitter = Translation from fixed point * sqrt(Area of the layer).
           // The square root of the area is used instead of the area to match
           // the dimensions of both terms on the rhs.
           jitter += translation_from_last_commit *
                     sqrt(layer->visible_layer_rect().size().GetArea());
         }
       } else {
         layer->performance_properties().num_fixed_point_hits = 0;
       }
     }
   }
-  // Descendants of jittering layer will not contribute to unique jitter.
-  if (jitter > 0.f)
-    return jitter;
-
-  for (size_t i = 0; i < layer->children().size(); ++i) {
-    LayerImpl* child_layer =
-        LayerTreeHostCommon::get_layer_as_raw_ptr(layer->children(), i);
-    jitter += CalculateFrameJitter(child_layer);
-  }
   return jitter;
 }
 
 enum PropertyTreeOption {
   BUILD_PROPERTY_TREES_IF_NEEDED,
   DONT_BUILD_PROPERTY_TREES
 };
 
 void CalculateRenderTarget(LayerImpl* layer,
                            PropertyTrees* property_trees,
@@ skipping 404 matching lines @@
   CalculateDrawPropertiesInternal(inputs, DONT_BUILD_PROPERTY_TREES);
 
   if (CdpPerfTracingEnabled()) {
     LayerTreeImpl* layer_tree_impl = inputs->root_layer->layer_tree_impl();
     if (layer_tree_impl->IsPendingTree() &&
         layer_tree_impl->is_first_frame_after_commit()) {
       LayerImpl* active_tree_root =
           layer_tree_impl->FindActiveTreeLayerById(inputs->root_layer->id());
       float jitter = 0.f;
       if (active_tree_root) {
-        LayerImpl* last_scrolled_layer = layer_tree_impl->LayerById(
-            active_tree_root->layer_tree_impl()->LastScrolledLayerId());
-        jitter = CalculateFrameJitter(last_scrolled_layer);
+        std::unordered_set<int> jitter_nodes;
+        const int last_scrolled_scroll_node_id =
+            layer_tree_impl->LastScrolledScrollNodeId();
+        for (auto* layer : *layer_tree_impl) {
+          // Layers that have the same scroll tree index jitter together. So, it
+          // is enough to calculate jitter on one of these layers.

[ajuma, 2016/03/29 14:24:02]

Please clarify this comment to say that once we've found a jittering layer, we
don't need to consider other layers with the same scroll tree index (but until
then, we compute the jitter for each layer).

[jaydasika, 2016/03/29 15:57:24]

Done.

+          int scroll_tree_index = layer->scroll_tree_index();
+          if (last_scrolled_scroll_node_id <= scroll_tree_index &&
+              jitter_nodes.find(scroll_tree_index) == jitter_nodes.end()) {
+            float layer_jitter = CalculateFrameJitter(layer);
+            if (layer_jitter > 0.f) {
+              jitter_nodes.insert(layer->scroll_tree_index());
+              jitter += layer_jitter;
+            }
+          }
+        }
       }
       TRACE_EVENT_ASYNC_BEGIN1(
           "cdp.perf", "jitter",
           inputs->root_layer->layer_tree_impl()->source_frame_number(), "value",
           jitter);
       inputs->root_layer->layer_tree_impl()->set_is_first_frame_after_commit(
           false);
       TRACE_EVENT_ASYNC_END1(
           "cdp.perf", "jitter",
           inputs->root_layer->layer_tree_impl()->source_frame_number(), "value",
           jitter);
     }
   }
 }
 
 void LayerTreeHostCommon::CalculateDrawProperties(
     CalcDrawPropsImplInputsForTesting* inputs) {
   CalculateDrawPropertiesInternal(inputs, BUILD_PROPERTY_TREES_IF_NEEDED);
 }
 
 PropertyTrees* GetPropertyTrees(Layer* layer) {
   return layer->layer_tree_host()->property_trees();
 }
 
 PropertyTrees* GetPropertyTrees(LayerImpl* layer) {
   return layer->layer_tree_impl()->property_trees();
 }
 
 }  // namespace cc