ash: Add some more touch UMA.

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"
 #include "ui/aura/window.h"
 #include "ui/aura/window_property.h"
 #include "ui/base/event.h"
 
+#if defined(USE_XI2_MT)
+#include <X11/extensions/XInput2.h>
+#include <X11/Xlib.h>
+#endif
+
 namespace {
 
 enum GestureActionType {
   GESTURE_UNKNOWN,
   GESTURE_OMNIBOX_PINCH,
   GESTURE_OMNIBOX_SCROLL,
   GESTURE_TABSTRIP_PINCH,
   GESTURE_TABSTRIP_SCROLL,
   GESTURE_BEZEL_SCROLL,
   GESTURE_DESKTOP_SCROLL,
@@ skipping 235 matching lines @@
   UMA_HISTOGRAM_CUSTOM_COUNTS("Ash.TouchRadius",
       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 gfx::Rect bounds = target->GetRootWindow()->bounds();
+  const int kBucketSizeX = bounds.width() / kBucketCount;

[sky, 2012/08/10 19:18:33]

Don't use kStyle for computed values like this.

[sadrul, 2012/08/10 19:20:24]

Done.

+  const int kBucketSizeY = bounds.height() / kBucketCount;
+
+  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() / kBucketSizeX),
+      base::LinearHistogram::FactoryGet("Ash.TouchPositionX", 1, kBucketCount,
+          kBucketCount + 1, base::Histogram::kUmaTargetedHistogramFlag));
+  STATIC_HISTOGRAM_POINTER_BLOCK("Ash.TouchPositionY",
+      Add(position.y() / kBucketSizeY),
+      base::LinearHistogram::FactoryGet("Ash.TouchPositionY", 1, kBucketCount,
+          kBucketCount + 1, base::Histogram::kUmaTargetedHistogramFlag));
+
   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),
+        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());
     details->last_release_time_ = event.time_stamp();
@@ skipping 14 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