Adds UMA for screen rotation animation smoothness.

ash/rotator/screen_rotation_animator.cc

 // Copyright 2015 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 "ash/rotator/screen_rotation_animator.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "ash/display/window_tree_host_manager.h"
 #include "ash/rotator/screen_rotation_animation.h"
 #include "ash/rotator/screen_rotation_animator_observer.h"
 #include "ash/shell.h"
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
+#include "base/metrics/histogram_macros.h"
 #include "base/time/time.h"
 #include "ui/aura/window.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animation_observer.h"
 #include "ui/compositor/layer_animation_sequence.h"
 #include "ui/compositor/layer_animator.h"
 #include "ui/compositor/layer_owner.h"
 #include "ui/compositor/layer_tree_owner.h"
 #include "ui/display/display.h"
 #include "ui/display/manager/display_manager.h"
@@ skipping 109 matching lines @@
 LayerCleanupObserver::~LayerCleanupObserver() {
   // We must eplicitly detach from |sequence_| because we return true from
   // RequiresNotificationWhenAnimatorDestroyed.
   if (sequence_)
     sequence_->RemoveObserver(this);
 }
 
 void LayerCleanupObserver::OnLayerAnimationEnded(
     ui::LayerAnimationSequence* sequence) {
   if (animator_)
-    animator_->OnLayerAnimationEnded();
+    animator_->ProcessAnimationQueue();
 
   delete this;
 }
 
 void LayerCleanupObserver::OnLayerAnimationAborted(
     ui::LayerAnimationSequence* sequence) {
   if (animator_)
-    animator_->OnLayerAnimationAborted();
+    animator_->ProcessAnimationQueue();
 
   delete this;
 }
 
 void LayerCleanupObserver::OnAttachedToSequence(
     ui::LayerAnimationSequence* sequence) {
   sequence_ = sequence;
 }
 
 void LayerCleanupObserver::OnDetachedFromSequence(
     ui::LayerAnimationSequence* sequence) {
   DCHECK_EQ(sequence, sequence_);
   sequence_ = nullptr;
 }
 
 }  // namespace
 
 struct ScreenRotationAnimator::ScreenRotationRequest {
   ScreenRotationRequest(display::Display::Rotation to_rotation,
                         display::Display::RotationSource from_source)
       : new_rotation(to_rotation), source(from_source) {}
   display::Display::Rotation new_rotation;
   display::Display::RotationSource source;
 };
 
+class ScreenRotationAnimator::ScreenRotationAnimationMetricsReporter
+    : public ui::AnimationMetricsReporter {
+  void Report(int value) override {

[oshima, 2017/03/24 22:46:00]

nit: define public ctor/dtor, then DISALLOW_COPY_AND_ASSIGN.

[wutao, 2017/03/24 23:50:55]

Done.

+    UMA_HISTOGRAM_PERCENTAGE("Ash.Rotation.AnimationSmoothness", value);
+  }
+};
+
 ScreenRotationAnimator::ScreenRotationAnimator(int64_t display_id)
     : display_id_(display_id),
       is_rotating_(false),
+      metrics_reporter_(
+          base::MakeUnique<ScreenRotationAnimationMetricsReporter>()),
       disable_animation_timers_for_test_(false),
       weak_factory_(this) {}
 
-ScreenRotationAnimator::~ScreenRotationAnimator() {}
+ScreenRotationAnimator::~ScreenRotationAnimator() {
+  // To prevent a call to |LayerCleanupObserver::OnLayerAnimationAborted()| from
+  // calling a method on the |animator_|.
+  weak_factory_.InvalidateWeakPtrs();
+
+  // Explicitly reset the |old_layer_tree_owner_| and |metrics_reporter_| in
+  // order to make sure |metrics_reporter_| outlives the attached animation
+  // sequence.
+  old_layer_tree_owner_.reset();
+  metrics_reporter_.reset();
+}
 
 void ScreenRotationAnimator::AnimateRotation(
     std::unique_ptr<ScreenRotationRequest> rotation_request) {
   aura::Window* root_window = GetRootWindow(display_id_);
 
   const gfx::Rect original_screen_bounds = root_window->GetTargetBounds();
 
   const int rotation_factor = GetRotationFactor(
       GetCurrentScreenRotation(display_id_), rotation_request->new_rotation);
 
@@ skipping 74 matching lines @@
       ui::LayerAnimator::REPLACE_QUEUED_ANIMATIONS);
   std::unique_ptr<ui::LayerAnimationSequence> animation_sequence =
       base::MakeUnique<ui::LayerAnimationSequence>(std::move(screen_rotation));
   // Add an observer so that the cloned layers can be cleaned up with the
   // animation completes/aborts.
   animation_sequence->AddObserver(old_layer_cleanup_observer.release());
   // In unit test, we can use ash::test::ScreenRotationAnimatorTestApi to
   // control the animation.
   if (disable_animation_timers_for_test_)
     animator->set_disable_timer_for_test(true);
+  animation_sequence->SetAnimationMetricsReporter(metrics_reporter_.get());
   animator->StartAnimation(animation_sequence.release());
 
   rotation_request.reset();
 }
 
 void ScreenRotationAnimator::Rotate(display::Display::Rotation new_rotation,
                                     display::Display::RotationSource source) {
   if (GetCurrentScreenRotation(display_id_) == new_rotation)
     return;
 
@@ skipping 15 matching lines @@
 void ScreenRotationAnimator::AddScreenRotationAnimatorObserver(
     ScreenRotationAnimatorObserver* observer) {
   screen_rotation_animator_observers_.AddObserver(observer);
 }
 
 void ScreenRotationAnimator::RemoveScreenRotationAnimatorObserver(
     ScreenRotationAnimatorObserver* observer) {
   screen_rotation_animator_observers_.RemoveObserver(observer);
 }
 
-void ScreenRotationAnimator::OnLayerAnimationEnded() {
-  ProcessAnimationQueue();
-}
-
-void ScreenRotationAnimator::OnLayerAnimationAborted() {
-  AbortAnimations(old_layer_tree_owner_->root());
-  ProcessAnimationQueue();
-}
-
 void ScreenRotationAnimator::ProcessAnimationQueue() {
   is_rotating_ = false;
   old_layer_tree_owner_.reset();
   if (last_pending_request_ && IsDisplayIdValid(display_id_)) {
     std::unique_ptr<ScreenRotationRequest> rotation_request =
         std::move(last_pending_request_);
     Rotate(rotation_request->new_rotation, rotation_request->source);
     rotation_request.reset();
     return;
   }
@@ skipping 13 matching lines @@
     if (child_layer == old_layer_tree_owner_->root())
       continue;
 
     child_layer->GetAnimator()->StopAnimating();
   }
 
   old_layer_tree_owner_->root()->GetAnimator()->StopAnimating();
 }
 
 }  // namespace ash