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 13 matching lines @@
 // The number of degrees that the rotation animations animate through.
 const int kRotationDegrees = 20;
 
 // The time it takes for the rotation animations to run.
 const int kRotationDurationInMs = 250;
 
 // The rotation factors.
 const int kCounterClockWiseRotationFactor = 1;
 const int kClockWiseRotationFactor = -1;
 
+// The percentage histogram boundary.
+const int kPercentage_MIN = 1;
+const int kPercentage_MAX = 101;
+
 // Aborts the active animations of the layer, and recurses upon its child
 // layers.
 void AbortAnimations(ui::Layer* layer) {
   for (ui::Layer* child_layer : layer->children())
     AbortAnimations(child_layer);
   layer->GetAnimator()->AbortAllAnimations();
 }
 
 display::Display::Rotation GetCurrentScreenRotation(int64_t display_id) {
   return Shell::GetInstance()
@@ skipping 110 matching lines @@
 }  // 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 {
+    base::LinearHistogram::FactoryGet(
+        "Ash.Rotation.AnimationSmoothness", kPercentage_MIN, kPercentage_MAX,

[bruthig, 2017/03/24 14:25:39]

FYI You will need to add an entry to histograms.xml so that the UMA dashboards
surface this metric.

[wutao, 2017/03/24 20:24:37]

Done.

+        kPercentage_MAX + 1, base::HistogramBase::kUmaTargetedHistogramFlag)
+        ->Add(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() {}
 
 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();
@@ skipping 42 matching lines @@
 
     std::unique_ptr<ScreenRotationAnimation> screen_rotation =
         base::MakeUnique<ScreenRotationAnimation>(
             child_layer, kRotationDegrees * rotation_factor,
             0 /* end_degrees */, child_layer->opacity(),
             1.0f /* target_opacity */, pivot, duration, tween_type);
 
     ui::LayerAnimator* animator = child_layer->GetAnimator();
     animator->set_preemption_strategy(
         ui::LayerAnimator::REPLACE_QUEUED_ANIMATIONS);
     std::unique_ptr<ui::LayerAnimationSequence> animation_sequence =

[bruthig, 2017/03/24 14:25:39]

Why don't we add the metric for this sequence?

[varkha, 2017/03/24 15:04:59]

I think it would effectively be redundant given that those animations use the
same duration.

[varkha, 2017/03/24 16:49:32]

Also, perhaps more importantly, the |child_layer|s here can outlive the Shell >
DisplayConfigurationController > ScreenRotationAnimator ownership chain and so
you would have a lifetime problem unless |metrics_reporter_| lifetime is beyond
all of the |child_layer|s and |screen_rotation| elements.
So I don't recommend adding the metric to those |child_layer|s.

[wutao, 2017/03/24 20:24:37]

Thank you to address this for me!

         base::MakeUnique<ui::LayerAnimationSequence>(
             std::move(screen_rotation));
     animator->StartAnimation(animation_sequence.release());
   }
 
   // The old layer will also be transformed into the new orientation. We will
   // translate it so that the old layer's center point aligns with the new
   // orientation's center point and use that center point as the pivot for the
   // rotation animation.
   gfx::Transform translate_transform;
@@ skipping 13 matching lines @@
   ui::LayerAnimator* animator = old_root_layer->GetAnimator();
   animator->set_preemption_strategy(
       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_)

[bruthig, 2017/03/24 14:25:39]

Not related to this change but shouldn't we be disabling the timer for the
|animation_sequence| above?

[wutao, 2017/03/24 20:24:37]

Ideally yes, but it will not affect the test result.
Due to that the above block animation will be replaced by the animation of
|new_layer_tree|, a screenshot after screen rotation, I would like to add the
timer flag and add the animator of the |new_layer_tree| to the testapi at that
time.

     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 57 matching lines @@
     if (child_layer == old_layer_tree_owner_->root())
       continue;
 
     child_layer->GetAnimator()->StopAnimating();
   }
 
   old_layer_tree_owner_->root()->GetAnimator()->StopAnimating();
 }
 
 }  // namespace ash