Adding UMA logging to touch text selection

ui/touch_selection/touch_selection_controller.cc

 // Copyright 2014 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 "ui/touch_selection/touch_selection_controller.h"
 
 #include "base/auto_reset.h"
 #include "base/logging.h"
+#include "base/metrics/histogram_macros.h"
 
 namespace ui {
 namespace {
 
 gfx::Vector2dF ComputeLineOffsetFromBottom(const SelectionBound& bound) {
   gfx::Vector2dF line_offset =
       gfx::ScaleVector2d(bound.edge_top() - bound.edge_bottom(), 0.5f);
   // An offset of 5 DIPs is sufficient for most line sizes. For small lines,
   // using half the line height avoids synthesizing a point on a line above
   // (or below) the intended line.
@@ skipping 35 matching lines @@
       is_selection_active_(false),
       activate_selection_automatically_(false),
       selection_empty_(false),
       selection_editable_(false),
       temporarily_hidden_(false) {
   DCHECK(client_);
   HideAndDisallowShowingAutomatically();
 }
 
 TouchSelectionController::~TouchSelectionController() {
+  if (is_selection_active_)
+    LogSelectionEnd();
 }
 
 void TouchSelectionController::OnSelectionBoundsChanged(
     const SelectionBound& start,
     const SelectionBound& end) {
   if (start == start_ && end_ == end)
     return;
 
   start_ = start;
   end_ = end;
@@ skipping 304 matching lines @@
     end_selection_handle_.reset(new TouchHandle(this, end_orientation_));
   } else {
     end_selection_handle_->SetEnabled(true);
     end_selection_handle_->SetOrientation(end_orientation_);
   }
 
   // As a long press received while a selection is already active may trigger
   // an entirely new selection, notify the client but avoid sending an
   // intervening SELECTION_CLEARED update to avoid unnecessary state changes.
   if (!is_selection_active_ || response_pending_input_event_ == LONG_PRESS) {
+    if (is_selection_active_) {
+      // The active selection session finishes with the start of the new one.
+      LogSelectionEnd();
+    }
     is_selection_active_ = true;
+    selection_start_time_ = base::TimeTicks::Now();
     response_pending_input_event_ = INPUT_EVENT_TYPE_NONE;
     client_->OnSelectionEvent(SELECTION_SHOWN, GetStartPosition());
   }
 }
 
 void TouchSelectionController::DeactivateSelection() {
   if (!is_selection_active_)
     return;
   DCHECK(start_selection_handle_);
   DCHECK(end_selection_handle_);
+  LogSelectionEnd();
   start_selection_handle_->SetEnabled(false);
   end_selection_handle_->SetEnabled(false);
   is_selection_active_ = false;
   client_->OnSelectionEvent(SELECTION_CLEARED, gfx::PointF());
 }
 
 void TouchSelectionController::ResetCachedValuesIfInactive() {
   if (is_selection_active_ || is_insertion_active_)
     return;
   start_ = SelectionBound();
@@ skipping 26 matching lines @@
   return end_.visible() && !temporarily_hidden_;
 }
 
 TouchHandle::AnimationStyle TouchSelectionController::GetAnimationStyle(
     bool was_active) const {
   return was_active && client_->SupportsAnimation()
              ? TouchHandle::ANIMATION_SMOOTH
              : TouchHandle::ANIMATION_NONE;
 }
 
+void TouchSelectionController::LogSelectionEnd() {

[jdduke (slow), 2015/02/09 16:10:56]

Hmm, on second thought, if this will need to change for when we unify, I'm fine
with leaving it out. I guess I'm also curious what the duration of the selection
means, and how actionable it is... What does the duration of the selection tell
us?

[mfomitchev, 2015/02/09 17:09:32]

My hope is that getting this into M42 will help us understand if the new
selection granularity strategy (which I plan to get into M43) improves the UX.

Generally we want the duration to go down and the success rate to go up. Now,
this is more tricky when duration is the only thing we are logging, because the
avg duration may decrease b/c of accidental selections. Still, I think having
some information here would be useful. E.g. if we implement nothing to affect
the number of accidental selections, while implementing a new selection
granularity strategy, and the duration goes down - we can hypothesize that with
a high degree of likelihood that is because the new selection strategy is
working well. And vice versa.

+  base::TimeDelta duration = base::TimeTicks::Now() - selection_start_time_;
+  UMA_HISTOGRAM_CUSTOM_TIMES("Event.TouchSelectionDuration",
+                             duration,
+                             base::TimeDelta::FromMilliseconds(1),
+                             base::TimeDelta::FromSeconds(60),
+                             50);
+}
+
 }  // namespace ui