Move gesture/touch UMA logs into gesture provider

ash/touch/touch_uma.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/touch/touch_uma.h"
 
 #include "ash/metrics/user_metrics_recorder.h"
 #include "ash/shell.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/stringprintf.h"
 #include "ui/aura/env.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/aura/window_property.h"
 #include "ui/events/event.h"
 #include "ui/events/event_utils.h"
 #include "ui/gfx/point_conversions.h"
 
 #if defined(USE_XI2_MT)
 #include <X11/extensions/XInput2.h>
 #include <X11/Xlib.h>
 #endif
 
 namespace {
 
-enum UMAEventType {
-  // WARNING: Do not change the numerical values of any of these types.
-  // Do not remove deprecated types - just comment them as deprecated.
-  UMA_ET_UNKNOWN = 0,
-  UMA_ET_TOUCH_RELEASED = 1,
-  UMA_ET_TOUCH_PRESSED = 2,
-  UMA_ET_TOUCH_MOVED = 3,
-  UMA_ET_TOUCH_STATIONARY = 4,  // Deprecated. Do not remove.
-  UMA_ET_TOUCH_CANCELLED = 5,
-  UMA_ET_GESTURE_SCROLL_BEGIN = 6,
-  UMA_ET_GESTURE_SCROLL_END = 7,
-  UMA_ET_GESTURE_SCROLL_UPDATE = 8,
-  UMA_ET_GESTURE_TAP = 9,
-  UMA_ET_GESTURE_TAP_DOWN = 10,
-  UMA_ET_GESTURE_BEGIN = 11,
-  UMA_ET_GESTURE_END = 12,
-  UMA_ET_GESTURE_DOUBLE_TAP = 13,
-  UMA_ET_GESTURE_TRIPLE_TAP = 14,
-  UMA_ET_GESTURE_TWO_FINGER_TAP = 15,
-  UMA_ET_GESTURE_PINCH_BEGIN = 16,
-  UMA_ET_GESTURE_PINCH_END = 17,
-  UMA_ET_GESTURE_PINCH_UPDATE = 18,
-  UMA_ET_GESTURE_LONG_PRESS = 19,
-  UMA_ET_GESTURE_SWIPE_2 = 20,   // Swipe with 2 fingers
-  UMA_ET_SCROLL = 21,
-  UMA_ET_SCROLL_FLING_START = 22,
-  UMA_ET_SCROLL_FLING_CANCEL = 23,
-  UMA_ET_GESTURE_SWIPE_3 = 24,   // Swipe with 3 fingers
-  UMA_ET_GESTURE_SWIPE_4P = 25,  // Swipe with 4+ fingers
-  UMA_ET_GESTURE_SCROLL_UPDATE_2 = 26,
-  UMA_ET_GESTURE_SCROLL_UPDATE_3 = 27,
-  UMA_ET_GESTURE_SCROLL_UPDATE_4P = 28,
-  UMA_ET_GESTURE_PINCH_UPDATE_3 = 29,
-  UMA_ET_GESTURE_PINCH_UPDATE_4P = 30,
-  UMA_ET_GESTURE_LONG_TAP = 31,
-  UMA_ET_GESTURE_SHOW_PRESS = 32,
-  UMA_ET_GESTURE_TAP_CANCEL = 33,
-  UMA_ET_GESTURE_WIN8_EDGE_SWIPE = 34,
-  UMA_ET_GESTURE_SWIPE_1 = 35,   // Swipe with 1 finger
-  // NOTE: Add new event types only immediately above this line. Make sure to
-  // update the UIEventType enum in tools/metrics/histograms/histograms.xml
-  // accordingly.
-  UMA_ET_COUNT
-};
-
 struct WindowTouchDetails {
-  WindowTouchDetails()
-      : max_distance_from_start_squared_(0) {
-  }
-
   // Move and start times of the touch points. The key is the touch-id.
   std::map<int, base::TimeDelta> last_move_time_;
   std::map<int, base::TimeDelta> last_start_time_;
 
   // The first and last positions of the touch points.
   std::map<int, gfx::Point> start_touch_position_;
   std::map<int, gfx::Point> last_touch_position_;
 
-  // The maximum distance the first touch point travelled from its starting
-  // location in pixels.
-  float max_distance_from_start_squared_;
-
   // Last time-stamp of the last touch-end event.
   base::TimeDelta last_release_time_;
 
   // Stores the time of the last touch released on this window (if there was a
   // multi-touch gesture on the window, then this is the release-time of the
   // last touch on the window).
   base::TimeDelta last_mt_time_;
 };
 
 DEFINE_OWNED_WINDOW_PROPERTY_KEY(WindowTouchDetails,
                                  kWindowTouchDetails,
                                  NULL);
-
-
-UMAEventType UMAEventTypeFromEvent(const ui::Event& event) {
-  switch (event.type()) {
-    case ui::ET_TOUCH_RELEASED:
-      return UMA_ET_TOUCH_RELEASED;
-    case ui::ET_TOUCH_PRESSED:
-      return UMA_ET_TOUCH_PRESSED;
-    case ui::ET_TOUCH_MOVED:
-      return UMA_ET_TOUCH_MOVED;
-    case ui::ET_TOUCH_CANCELLED:
-      return UMA_ET_TOUCH_CANCELLED;
-    case ui::ET_GESTURE_SCROLL_BEGIN:
-      return UMA_ET_GESTURE_SCROLL_BEGIN;
-    case ui::ET_GESTURE_SCROLL_END:
-      return UMA_ET_GESTURE_SCROLL_END;
-    case ui::ET_GESTURE_SCROLL_UPDATE: {
-      const ui::GestureEvent& gesture =
-          static_cast<const ui::GestureEvent&>(event);
-      if (gesture.details().touch_points() == 1)
-        return UMA_ET_GESTURE_SCROLL_UPDATE;
-      else if (gesture.details().touch_points() == 2)
-        return UMA_ET_GESTURE_SCROLL_UPDATE_2;
-      else if (gesture.details().touch_points() == 3)
-        return UMA_ET_GESTURE_SCROLL_UPDATE_3;
-      return UMA_ET_GESTURE_SCROLL_UPDATE_4P;
-    }
-    case ui::ET_GESTURE_TAP: {
-      const ui::GestureEvent& gesture =
-          static_cast<const ui::GestureEvent&>(event);
-      int tap_count = gesture.details().tap_count();
-      if (tap_count == 1)
-        return UMA_ET_GESTURE_TAP;
-      if (tap_count == 2)
-        return UMA_ET_GESTURE_DOUBLE_TAP;
-      if (tap_count == 3)
-        return UMA_ET_GESTURE_TRIPLE_TAP;
-      NOTREACHED() << "Received tap with tapcount " << tap_count;
-      return UMA_ET_UNKNOWN;
-    }
-    case ui::ET_GESTURE_TAP_DOWN:
-      return UMA_ET_GESTURE_TAP_DOWN;
-    case ui::ET_GESTURE_BEGIN:
-      return UMA_ET_GESTURE_BEGIN;
-    case ui::ET_GESTURE_END:
-      return UMA_ET_GESTURE_END;
-    case ui::ET_GESTURE_TWO_FINGER_TAP:
-      return UMA_ET_GESTURE_TWO_FINGER_TAP;
-    case ui::ET_GESTURE_PINCH_BEGIN:
-      return UMA_ET_GESTURE_PINCH_BEGIN;
-    case ui::ET_GESTURE_PINCH_END:
-      return UMA_ET_GESTURE_PINCH_END;
-    case ui::ET_GESTURE_PINCH_UPDATE: {
-      const ui::GestureEvent& gesture =
-          static_cast<const ui::GestureEvent&>(event);
-      if (gesture.details().touch_points() >= 4)
-        return UMA_ET_GESTURE_PINCH_UPDATE_4P;
-      else if (gesture.details().touch_points() == 3)
-        return UMA_ET_GESTURE_PINCH_UPDATE_3;
-      return UMA_ET_GESTURE_PINCH_UPDATE;
-    }
-    case ui::ET_GESTURE_LONG_PRESS:
-      return UMA_ET_GESTURE_LONG_PRESS;
-    case ui::ET_GESTURE_LONG_TAP:
-      return UMA_ET_GESTURE_LONG_TAP;
-    case ui::ET_GESTURE_SWIPE: {
-      const ui::GestureEvent& gesture =
-          static_cast<const ui::GestureEvent&>(event);
-      if (gesture.details().touch_points() == 1)
-        return UMA_ET_GESTURE_SWIPE_1;
-      else if (gesture.details().touch_points() == 2)
-        return UMA_ET_GESTURE_SWIPE_2;
-      else if (gesture.details().touch_points() == 3)
-        return UMA_ET_GESTURE_SWIPE_3;
-      return UMA_ET_GESTURE_SWIPE_4P;
-    }
-    case ui::ET_GESTURE_WIN8_EDGE_SWIPE:
-      return UMA_ET_GESTURE_WIN8_EDGE_SWIPE;
-    case ui::ET_GESTURE_TAP_CANCEL:
-      return UMA_ET_GESTURE_TAP_CANCEL;
-    case ui::ET_GESTURE_SHOW_PRESS:
-      return UMA_ET_GESTURE_SHOW_PRESS;
-    case ui::ET_SCROLL:
-      return UMA_ET_SCROLL;
-    case ui::ET_SCROLL_FLING_START:
-      return UMA_ET_SCROLL_FLING_START;
-    case ui::ET_SCROLL_FLING_CANCEL:
-      return UMA_ET_SCROLL_FLING_CANCEL;
-    default:
-      NOTREACHED();
-      return UMA_ET_UNKNOWN;
-  }
-}
-
 }
 
 namespace ash {
 
 // static
 TouchUMA* TouchUMA::GetInstance() {
   return Singleton<TouchUMA>::get();
 }
 
 void TouchUMA::RecordGestureEvent(aura::Window* target,
                                   const ui::GestureEvent& event) {
-  UMA_HISTOGRAM_ENUMERATION("Ash.GestureCreated",
-                            UMAEventTypeFromEvent(event),
-                            UMA_ET_COUNT);
-
   GestureActionType action = FindGestureActionType(target, event);
   RecordGestureAction(action);
 
   if (event.type() == ui::ET_GESTURE_END &&
       event.details().touch_points() == 2) {
     WindowTouchDetails* details = target->GetProperty(kWindowTouchDetails);
     if (!details) {
       LOG(ERROR) << "Window received gesture events without receiving any touch"
                     " events";
       return;
@@ skipping 66 matching lines @@
       position.y() / bucket_size_y,
       0, kBucketCountForLocation, kBucketCountForLocation + 1);
 
   if (event.type() == ui::ET_TOUCH_PRESSED) {
     Shell::GetInstance()->metrics()->RecordUserMetricsAction(
         UMA_TOUCHSCREEN_TAP_DOWN);
 
     details->last_start_time_[event.touch_id()] = event.time_stamp();
     details->start_touch_position_[event.touch_id()] = event.root_location();
     details->last_touch_position_[event.touch_id()] = event.location();
-    details->max_distance_from_start_squared_ = 0;
 
     if (details->last_release_time_.ToInternalValue()) {
       // Measuring the interval between a touch-release and the next
       // touch-start is probably less useful when doing multi-touch (e.g.
       // gestures, or multi-touch friendly apps). So count this only if the user
       // hasn't done any multi-touch during the last 30 seconds.
       base::TimeDelta diff = event.time_stamp() - details->last_mt_time_;
       if (diff.InSeconds() > 30) {
         base::TimeDelta gap = event.time_stamp() - details->last_release_time_;
         UMA_HISTOGRAM_COUNTS_10000("Ash.TouchStartAfterEnd",
             gap.InMilliseconds());
       }
     }
 
     // Record the number of touch-points currently active for the window.
     const int kMaxTouchPoints = 10;
     UMA_HISTOGRAM_CUSTOM_COUNTS("Ash.ActiveTouchPoints",
         details->last_start_time_.size(),
         1, kMaxTouchPoints, kMaxTouchPoints + 1);
   } else if (event.type() == ui::ET_TOUCH_RELEASED) {
-    if (is_single_finger_gesture_) {
-      UMA_HISTOGRAM_CUSTOM_COUNTS("Ash.TouchMaxDistance",
-          static_cast<int>(
-              sqrt(details->max_distance_from_start_squared_)), 0, 1500, 50);
-    }
-
     if (details->last_start_time_.count(event.touch_id())) {
       base::TimeDelta duration = event.time_stamp() -
                                  details->last_start_time_[event.touch_id()];
-      UMA_HISTOGRAM_TIMES("Ash.TouchDuration2", duration);
-
       // Look for touches that were [almost] stationary for a long time.
       const double kLongStationaryTouchDuration = 10;
       const int kLongStationaryTouchDistanceSquared = 100;
       if (duration.InSecondsF() > kLongStationaryTouchDuration) {
         gfx::Vector2d distance = event.root_location() -
             details->start_touch_position_[event.touch_id()];
         if (distance.LengthSquared() < kLongStationaryTouchDistanceSquared) {
           UMA_HISTOGRAM_CUSTOM_COUNTS("Ash.StationaryTouchDuration",
               duration.InSeconds(),
               kLongStationaryTouchDuration,
@@ skipping 20 matching lines @@
                                    details->last_move_time_[event.touch_id()];
       UMA_HISTOGRAM_CUSTOM_COUNTS("Ash.TouchMoveInterval",
                                   move_delay.InMilliseconds(),
                                   1, 50, 25);
     }
 
     UMA_HISTOGRAM_CUSTOM_COUNTS("Ash.TouchMoveSteps", distance, 1, 1000, 50);
 
     details->last_move_time_[event.touch_id()] = event.time_stamp();
     details->last_touch_position_[event.touch_id()] = event.location();
-
-    float cur_dist = (details->start_touch_position_[event.touch_id()] -
-                      event.root_location()).LengthSquared();
-    if (cur_dist > details->max_distance_from_start_squared_)
-      details->max_distance_from_start_squared_ = cur_dist;
   }
 }
 
 TouchUMA::TouchUMA()
     : is_single_finger_gesture_(false),
       touch_in_progress_(false),
       burst_length_(0) {
 }
 
 TouchUMA::~TouchUMA() {
@@ skipping 86 matching lines @@
       return GESTURE_OMNIBOX_SCROLL;
     if (event.type() == ui::ET_GESTURE_PINCH_BEGIN)
       return GESTURE_OMNIBOX_PINCH;
     return GESTURE_UNKNOWN;
   }
 
   return GESTURE_UNKNOWN;
 }
 
 }  // namespace ash