ash: Add UMA for taps on webpage, bezel and tabstrip.

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/shell_delegate.h"
 #include "base/metrics/histogram.h"
 #include "base/stringprintf.h"
 #include "ui/aura/root_window.h"
@@ skipping 12 matching lines @@
   GESTURE_UNKNOWN,
   GESTURE_OMNIBOX_PINCH,
   GESTURE_OMNIBOX_SCROLL,
   GESTURE_TABSTRIP_PINCH,
   GESTURE_TABSTRIP_SCROLL,
   GESTURE_BEZEL_SCROLL,
   GESTURE_DESKTOP_SCROLL,
   GESTURE_DESKTOP_PINCH,
   GESTURE_WEBPAGE_PINCH,
   GESTURE_WEBPAGE_SCROLL,
+  GESTURE_WEBPAGE_TAP,
+  GESTURE_TABSTRIP_TAP,
+  GESTURE_BEZEL_TAP,
 // NOTE: Add new action types only immediately above this line. Also, make sure
 // the enum list in tools/histogram/histograms.xml is updated with any change in
 // here.
   GESTURE_ACTION_COUNT
 };
 
 enum UMAEventType {
   UMA_ET_UNKNOWN,
   UMA_ET_TOUCH_RELEASED,
   UMA_ET_TOUCH_PRESSED,
@@ skipping 48 matching lines @@
 
 DEFINE_OWNED_WINDOW_PROPERTY_KEY(WindowTouchDetails,
                                  kWindowTouchDetails,
                                  NULL);
 
 GestureActionType FindGestureActionType(aura::Window* window,
                                         const ui::GestureEvent& event) {
   if (!window || window->GetRootWindow() == window) {
     if (event.type() == ui::ET_GESTURE_SCROLL_BEGIN)
       return GESTURE_BEZEL_SCROLL;
+    if (event.type() == ui::ET_GESTURE_TAP)
+      return GESTURE_BEZEL_TAP;

[sadrul, 2012/08/14 05:21:05]

rbyers@: Do you think counting long-press here would be useful?

[Rick Byers, 2012/08/14 05:30:41]

Couldn't hurt, but I'm not sure it adds that much value.  Your call.

     return GESTURE_UNKNOWN;
   }
 
   std::string name = window ? window->name() : std::string();
 
   const char kDesktopBackgroundView[] = "DesktopBackgroundView";
   if (name == kDesktopBackgroundView) {
     if (event.type() == ui::ET_GESTURE_SCROLL_BEGIN)
       return GESTURE_DESKTOP_SCROLL;
     if (event.type() == ui::ET_GESTURE_PINCH_BEGIN)
       return GESTURE_DESKTOP_PINCH;
     return GESTURE_UNKNOWN;
   }
 
   const char kWebPage[] = "RenderWidgetHostViewAura";
   if (name == kWebPage) {
     if (event.type() == ui::ET_GESTURE_PINCH_BEGIN)
       return GESTURE_WEBPAGE_PINCH;
     if (event.type() == ui::ET_GESTURE_SCROLL_BEGIN)
       return GESTURE_WEBPAGE_SCROLL;
+    if (event.type() == ui::ET_GESTURE_TAP)
+      return GESTURE_WEBPAGE_TAP;
     return GESTURE_UNKNOWN;
   }
 
   views::Widget* widget = views::Widget::GetWidgetForNativeView(window);
   if (!widget)
     return GESTURE_UNKNOWN;
 
   views::View* view = widget->GetRootView()->
       GetEventHandlerForPoint(event.location());
   if (!view)
     return GESTURE_UNKNOWN;
 
   name = view->GetClassName();
 
   const char kTabStrip[] = "TabStrip";
   const char kTab[] = "BrowserTab";
   if (name == kTabStrip || name == kTab) {
     if (event.type() == ui::ET_GESTURE_SCROLL_BEGIN)
       return GESTURE_TABSTRIP_SCROLL;
     if (event.type() == ui::ET_GESTURE_PINCH_BEGIN)
       return GESTURE_TABSTRIP_PINCH;
+    if (event.type() == ui::ET_GESTURE_TAP)
+      return GESTURE_TABSTRIP_TAP;
     return GESTURE_UNKNOWN;
   }
 
   const char kOmnibox[] = "BrowserOmniboxViewViews";
   if (name == kOmnibox) {
     if (event.type() == ui::ET_GESTURE_SCROLL_BEGIN)
       return GESTURE_OMNIBOX_SCROLL;
     if (event.type() == ui::ET_GESTURE_PINCH_BEGIN)
       return GESTURE_OMNIBOX_PINCH;
     return GESTURE_UNKNOWN;
@@ skipping 114 matching lines @@
       static_cast<int>(std::max(event.radius_x(), event.radius_y())),
       1, 500, 100);
 
   WindowTouchDetails* details = target->GetProperty(kWindowTouchDetails);
   if (!details) {
     details = new WindowTouchDetails;
     target->SetProperty(kWindowTouchDetails, details);
   }
 
   // Record the location of the touch points.
-  const int kBucketCount = 100;
+  const int kBucketCountForLocation = 100;
   const gfx::Rect bounds = target->GetRootWindow()->bounds();
-  const int bucket_size_x = bounds.width() / kBucketCount;
-  const int bucket_size_y = bounds.height() / kBucketCount;
+  const int bucket_size_x = bounds.width() / kBucketCountForLocation;
+  const int bucket_size_y = bounds.height() / kBucketCountForLocation;
 
   gfx::Point position = event.root_location();
 
   // Prefer raw event location (when available) over calibrated location.
   if (event.HasNativeEvent()) {
 #if defined(USE_XI2_MT)
     XEvent* xevent = event.native_event();
     CHECK_EQ(GenericEvent, xevent->type);
     XIEvent* xievent = static_cast<XIEvent*>(xevent->xcookie.data);
     if (xievent->evtype == XI_TouchBegin ||
         xievent->evtype == XI_TouchUpdate ||
         xievent->evtype == XI_TouchEnd) {
       XIDeviceEvent* device_event =
           static_cast<XIDeviceEvent*>(xevent->xcookie.data);
       position.SetPoint(static_cast<int>(device_event->event_x),
                         static_cast<int>(device_event->event_y));
     } else {
       position = ui::EventLocationFromNative(event.native_event());
     }
 #else
     position = ui::EventLocationFromNative(event.native_event());
 #endif
   }
 
   position.set_x(std::min(bounds.width() - 1, std::max(0, position.x())));
   position.set_y(std::min(bounds.height() - 1, std::max(0, position.y())));
 
   STATIC_HISTOGRAM_POINTER_BLOCK("Ash.TouchPositionX",
       Add(position.x() / bucket_size_x),
-      base::LinearHistogram::FactoryGet("Ash.TouchPositionX", 1, kBucketCount,
-          kBucketCount + 1, base::Histogram::kUmaTargetedHistogramFlag));
+      base::LinearHistogram::FactoryGet("Ash.TouchPositionX", 0,
+          kBucketCountForLocation, kBucketCountForLocation + 1,
+          base::Histogram::kUmaTargetedHistogramFlag));
   STATIC_HISTOGRAM_POINTER_BLOCK("Ash.TouchPositionY",
       Add(position.y() / bucket_size_y),
-      base::LinearHistogram::FactoryGet("Ash.TouchPositionY", 1, kBucketCount,
-          kBucketCount + 1, base::Histogram::kUmaTargetedHistogramFlag));
+      base::LinearHistogram::FactoryGet("Ash.TouchPositionY", 0,
+          kBucketCountForLocation, kBucketCountForLocation + 1,
+          base::Histogram::kUmaTargetedHistogramFlag));

[Ilya Sherman, 2012/08/14 05:27:38]

As I mentioned on the other CL, I don't think that you should be using
STATIC_HISTOGRAM_POINTER_BLOCK here -- it's logically meant to be private to the
histogram.h file, but macros can't really be declared as private.  Why doesn't
an UMA_HISTOGRAM_CUSTOM_COUNTS work here?

[sadrul, 2012/08/14 05:29:56]

We expect that a linear histogram would be more useful here, and there doesn't
appear to be a good way of using linear-histograms using the current
UMA_HISTOGRAM_ macros. Perhaps I should add UMA_HISTOGRAM_CUSTOM_COUNT_LINEAR?

[Rick Byers, 2012/08/14 05:30:41]

CUSTOM_COUNTS uses an exponential distribution, right?  That's not appropriate
for pixel co-ordinates - we want a linear distribution.  Perhaps we need a new
macro.

[Ilya Sherman, 2012/08/14 05:45:00]

If you create a CUSTOM_COUNTS histogram with 101 buckets between 0 and 99 (plus
an overflow bucket, and with the 0 bucket implicitly serving as an underflow
bucket), you should end up with a linear histogram.  I'm not entirely sure why
we have a separate LinearHistogram class; perhaps Jim can comment on that...

 
   if (event.type() == ui::ET_TOUCH_PRESSED) {
     Shell::GetInstance()->delegate()->RecordUserMetricsAction(
         UMA_TOUCHSCREEN_TAP_DOWN);
 
     details->last_start_time_[event.touch_id()] = event.time_stamp();
     details->last_touch_position_[event.touch_id()] = event.location();
 
     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",
-        std::min(static_cast<int>(details->last_start_time_.size()),
-                 kMaxTouchPoints),
+        details->last_start_time_.size(),
         1, kMaxTouchPoints, kMaxTouchPoints);
   } else if (event.type() == ui::ET_TOUCH_RELEASED) {
     if (details->last_start_time_.count(event.touch_id())) {
       base::TimeDelta duration = event.time_stamp() -
                                  details->last_start_time_[event.touch_id()];
       UMA_HISTOGRAM_COUNTS_100("Ash.TouchDuration", duration.InMilliseconds());
     }
     details->last_start_time_.erase(event.touch_id());
     details->last_move_time_.erase(event.touch_id());
     details->last_touch_position_.erase(event.touch_id());
@@ skipping 15 matching lines @@
 
     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();
   }
 }
 
 }  // namespace internal
 }  // namespace ash