[animations] Adds metrics for jank on selected layer animations

ui/compositor/layer_animation_sequence.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_sequence.h"
 
 #include <algorithm>
 #include <iterator>
 
 #include "base/trace_event/trace_event.h"
 #include "cc/animation/animation_id_provider.h"
 #include "ui/compositor/layer_animation_delegate.h"
 #include "ui/compositor/layer_animation_element.h"
 #include "ui/compositor/layer_animation_observer.h"
 
 namespace ui {
 
 LayerAnimationSequence::LayerAnimationSequence()
     : properties_(LayerAnimationElement::UNKNOWN),
       is_cyclic_(false),
       last_element_(0),
       waiting_for_group_start_(false),
       animation_group_id_(0),
       last_progressed_fraction_(0.0),
-      weak_ptr_factory_(this) {
-}
+      animation_metrics_reporter_(nullptr),
+      weak_ptr_factory_(this) {}
 
 LayerAnimationSequence::LayerAnimationSequence(
     std::unique_ptr<LayerAnimationElement> element)
     : properties_(LayerAnimationElement::UNKNOWN),
       is_cyclic_(false),
       last_element_(0),
       waiting_for_group_start_(false),
       animation_group_id_(0),
       last_progressed_fraction_(0.0),
+      animation_metrics_reporter_(nullptr),
       weak_ptr_factory_(this) {
   AddElement(std::move(element));
 }
 
 LayerAnimationSequence::~LayerAnimationSequence() {
   for (auto& observer : observers_)
     observer.DetachedFromSequence(this, true);
 }
 
 void LayerAnimationSequence::Start(LayerAnimationDelegate* delegate) {
@@ skipping 133 matching lines @@
     ++current_index;
   }
   last_element_ = 0;
   waiting_for_group_start_ = false;
   NotifyAborted();
 }
 
 void LayerAnimationSequence::AddElement(
     std::unique_ptr<LayerAnimationElement> element) {
   properties_ |= element->properties();
+  element->set_animation_metrics_reporter(animation_metrics_reporter_);
   elements_.push_back(std::move(element));
 }
 
 bool LayerAnimationSequence::HasConflictingProperty(
     LayerAnimationElement::AnimatableProperties other) const {
   return (properties_ & other) != LayerAnimationElement::UNKNOWN;
 }
 
 bool LayerAnimationSequence::IsFirstElementThreaded() const {
   if (!elements_.empty())
@@ skipping 37 matching lines @@
 void LayerAnimationSequence::OnAnimatorDestroyed() {
   for (LayerAnimationObserver& observer : observers_) {
     if (!observer.RequiresNotificationWhenAnimatorDestroyed()) {
       // Remove the observer, but do not allow notifications to be sent.
       observers_.RemoveObserver(&observer);
       observer.DetachedFromSequence(this, false);
     }
   }
 }
 
+void LayerAnimationSequence::SetAnimationMetricsReporter(
+    AnimationMetricsReporter* reporter) {
+  animation_metrics_reporter_ = reporter;
+  for (auto& element : elements_)
+    element->set_animation_metrics_reporter(animation_metrics_reporter_);
+}
+
 size_t LayerAnimationSequence::size() const {
   return elements_.size();
 }
 
 LayerAnimationElement* LayerAnimationSequence::FirstElement() const {
   if (elements_.empty()) {
     return NULL;
   }
 
   return elements_[0].get();
@@ skipping 21 matching lines @@
 
 LayerAnimationElement* LayerAnimationSequence::CurrentElement() const {
   if (elements_.empty())
     return NULL;
 
   size_t current_index = last_element_ % elements_.size();
   return elements_[current_index].get();
 }
 
 }  // namespace ui