[animations] Adds metrics for jank on selected layer animations

ui/compositor/layer_animation_element.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_animation_element.h"
 
 #include <utility>
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
@@ skipping 429 matching lines @@
                          : gfx::Transform()),
       opacity(delegate ? delegate->GetOpacityForAnimation() : 0.0f),
       visibility(delegate ? delegate->GetVisibilityForAnimation() : false),
       brightness(delegate ? delegate->GetBrightnessForAnimation() : 0.0f),
       grayscale(delegate ? delegate->GetGrayscaleForAnimation() : 0.0f),
       color(delegate ? delegate->GetColorForAnimation() : SK_ColorTRANSPARENT) {
 }
 
 // LayerAnimationElement -------------------------------------------------------
 
-LayerAnimationElement::LayerAnimationElement(
-    AnimatableProperties properties, base::TimeDelta duration)
+LayerAnimationElement::LayerAnimationElement(AnimatableProperties properties,
+                                             base::TimeDelta duration)
     : first_frame_(true),
       properties_(properties),
       duration_(GetEffectiveDuration(duration)),
       tween_type_(gfx::Tween::LINEAR),
       animation_id_(cc::AnimationIdProvider::NextAnimationId()),
       animation_group_id_(0),
       last_progressed_fraction_(0.0),
-      weak_ptr_factory_(this) {
-}
+      animation_metrics_reporter_(nullptr),
+      start_frame_number_(0),
+      weak_ptr_factory_(this) {}
 
 LayerAnimationElement::LayerAnimationElement(
-    const LayerAnimationElement &element)
+    const LayerAnimationElement& element)
     : first_frame_(element.first_frame_),
       properties_(element.properties_),
       duration_(element.duration_),
       tween_type_(element.tween_type_),
       animation_id_(cc::AnimationIdProvider::NextAnimationId()),
       animation_group_id_(element.animation_group_id_),
       last_progressed_fraction_(element.last_progressed_fraction_),
-      weak_ptr_factory_(this) {
-}
+      animation_metrics_reporter_(nullptr),
+      start_frame_number_(0),
+      weak_ptr_factory_(this) {}
 
 LayerAnimationElement::~LayerAnimationElement() {
 }
 
 void LayerAnimationElement::Start(LayerAnimationDelegate* delegate,
                                   int animation_group_id) {
   DCHECK(requested_start_time_ != base::TimeTicks());
   DCHECK(first_frame_);
   animation_group_id_ = animation_group_id;
   last_progressed_fraction_ = 0.0;
   OnStart(delegate);
+  if (delegate)
+    start_frame_number_ = delegate->GetFrameNumber();
   RequestEffectiveStart(delegate);
   first_frame_ = false;
 }
 
 bool LayerAnimationElement::Progress(base::TimeTicks now,
                                      LayerAnimationDelegate* delegate) {
   DCHECK(requested_start_time_ != base::TimeTicks());
   DCHECK(!first_frame_);
 
   bool need_draw;
@@ skipping 33 matching lines @@
 
   base::TimeDelta elapsed = time - requested_start_time_;
   if (elapsed >= duration_ + queueing_delay) {
     *total_duration = duration_ + queueing_delay;
     return true;
   }
   return false;
 }
 
 bool LayerAnimationElement::ProgressToEnd(LayerAnimationDelegate* delegate) {
-  if (first_frame_)
+  const int frame_number = delegate ? delegate->GetFrameNumber() : 0;
+  if (first_frame_) {
     OnStart(delegate);
+    start_frame_number_ = frame_number;
+  }
   base::WeakPtr<LayerAnimationElement> alive(weak_ptr_factory_.GetWeakPtr());
   bool need_draw = OnProgress(1.0, delegate);
+
+  int end_frame_number = frame_number;
+  if (animation_metrics_reporter_ && end_frame_number > start_frame_number_ &&
+      !duration_.is_zero()) {
+    base::TimeDelta elapsed = base::TimeTicks::Now() - effective_start_time_;
+    if (elapsed >= duration_) {
+      int smoothness = 100;
+      const double kFrameInterval = 1000.f / 60.f;

[reveman, 2017/01/21 15:27:39]

Should we get the actual vsync interval here instead of assuming 60?

[varkha, 2017/01/24 00:18:57]

Is there an easy place to get it from in compositor? I can see it seems to be
hardcoded as kDefaultRefreshRate=60.0 in compositor.cc but I am not sure if
there are significant deviations from this in practice.

[reveman, 2017/01/24 17:21:45]

VSync manager observer interface provides this:
https://cs.chromium.org/chromium/src/ui/compositor/compositor_vsync_manager.h...

We should at least have a TODO and comment here to indicate that this will need
to be updated to produce correct data on devices with lower/higher refresh rate.

[varkha, 2017/01/24 20:18:29]

Looks like it is the Compositor that always sets this interval in a
CompositorVSyncManager. Would it be OK to cache it in Compositor and then here
simply to ask Compositor for the up to date value?

[varkha, 2017/01/24 23:56:20]

Please see if this works.

+      const double actual_duration =
+          (end_frame_number - start_frame_number_) * kFrameInterval;
+      if (duration_.InMillisecondsF() - actual_duration >= kFrameInterval)
+        smoothness = 100 * (actual_duration / duration_.InMillisecondsF());

[reveman, 2017/01/21 15:27:39]

Did you consider just reporting dropped frames instead? I'm not sure this type
of smoothness is a good metric for user experience. E.g. one dropped frame can
ruin the user experience but that will be reported as 99% smoothness.

[varkha, 2017/01/24 00:18:57]

one dropped frame could indeed ruin user experience but then to still show 99%
here we would need an animation that is 100 frames or 1.6 seconds long and drop
just a single frame - most likely not a concern.

Animation can be still smooth with some frames dropped, I tried to take
animation expected duration into account. I admit in a long animation it
probably matters whether one in every 10 frames is lost (barely noticeable) or
when a whole 10 frames block in a 100 frame sequence is lost (very visible).

+      animation_metrics_reporter_->Report(smoothness);
+    }
+  }
   if (!alive)
     return need_draw;
   last_progressed_fraction_ = 1.0;
   first_frame_ = true;
   return need_draw;
 }
 
 void LayerAnimationElement::GetTargetValue(TargetValue* target) const {
   OnGetTarget(target);
 }
@@ skipping 106 matching lines @@
 }
 
 // static
 std::unique_ptr<LayerAnimationElement>
 LayerAnimationElement::CreateColorElement(SkColor color,
                                           base::TimeDelta duration) {
   return base::MakeUnique<ColorTransition>(color, duration);
 }
 
 }  // namespace ui