Add UMA for CrossFadeAnimation.

ash/wm/window_animations.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 "ash/wm/window_animations.h"
 
 #include <math.h>
 #include <algorithm>
 #include <utility>
 #include <vector>
 
 #include "ash/shelf/wm_shelf.h"
 #include "ash/wm/window_animation_types.h"
 #include "ash/wm/window_util.h"
 #include "ash/wm/workspace_controller.h"
 #include "ash/wm_window.h"
 #include "base/i18n/rtl.h"
+#include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
+#include "base/metrics/histogram_macros.h"
 #include "base/stl_util.h"
 #include "base/time/time.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_observer.h"
 #include "ui/base/class_property.h"
 #include "ui/compositor/compositor_observer.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animation_observer.h"
 #include "ui/compositor/layer_animation_sequence.h"
@@ skipping 47 matching lines @@
   // If the area didn't change, the animation is instantaneous.
   if (delta_area == 0)
     return base::TimeDelta::FromMilliseconds(kCrossFadeDurationMS);
 
   float factor = static_cast<float>(delta_area) / static_cast<float>(max_area);
   const float kRange = kCrossFadeDurationMaxMs - kCrossFadeDurationMinMs;
   return base::TimeDelta::FromMilliseconds(
       Round64(kCrossFadeDurationMinMs + (factor * kRange)));
 }
 
+class CrossFadeMetricsReporter : public ui::AnimationMetricsReporter {

[varkha, 2017/05/12 15:14:25]

There was a nit in a previous similar CL to define public ctor/dtor, then
DISALLOW_COPY_AND_ASSIGN so I would keep those consistent.

[wutao, 2017/05/12 17:46:37]

I kept copying from your first code. I will make change to that code too.

+  void Report(int value) override {
+    UMA_HISTOGRAM_PERCENTAGE("Ash.Window.AnimationSmoothness.CrossFade", value);
+  }
+};
+
+base::LazyInstance<CrossFadeMetricsReporter>::Leaky g_reporter_cross_fade =
+    LAZY_INSTANCE_INITIALIZER;
+
 }  // namespace
 
 const int kCrossFadeDurationMS = 200;
 
 void AddLayerAnimationsForMinimize(aura::Window* window, bool show) {
   // Recalculate the transform at restore time since the launcher item may have
   // moved while the window was minimized.
   gfx::Rect bounds = window->bounds();
   gfx::Rect target_bounds = GetMinimizeAnimationTargetBoundsInScreen(window);
   ::wm::ConvertRectFromScreen(window->parent(), &target_bounds);
@@ skipping 215 matching lines @@
     ui::Layer* old_layer = old_layer_owner->root();
     old_layer->GetAnimator()->StopAnimating();
     old_layer->SetTransform(old_transform);
     ui::ScopedLayerAnimationSettings settings(old_layer->GetAnimator());
 
     // Animation observer owns the old layer and deletes itself.
     settings.AddObserver(
         new CrossFadeObserver(window, std::move(old_layer_owner)));
     settings.SetTransitionDuration(duration);
     settings.SetTweenType(tween_type);
+    // Only add reporter to |old_layer|.
+    settings.SetAnimationMetricsReporter(g_reporter_cross_fade.Pointer());
     gfx::Transform out_transform;
     float scale_x = static_cast<float>(new_bounds.width()) /
                     static_cast<float>(old_bounds.width());
     float scale_y = static_cast<float>(new_bounds.height()) /
                     static_cast<float>(old_bounds.height());
     out_transform.Translate(new_bounds.x() - old_bounds.x(),
                             new_bounds.y() - old_bounds.y());
     out_transform.Scale(scale_x, scale_y);
     old_layer->SetTransform(out_transform);
     if (old_on_top) {
@@ skipping 119 matching lines @@
     case SHELF_ALIGNMENT_LEFT:
       return gfx::Rect(work_area.x(), work_area.y(), 0, 0);
     case SHELF_ALIGNMENT_RIGHT:
       return gfx::Rect(work_area.right(), work_area.y(), 0, 0);
   }
   NOTREACHED();
   return gfx::Rect();
 }
 
 }  // namespace ash