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 29 matching lines @@
       tap_slop_(tap_slop),
       response_pending_input_event_(INPUT_EVENT_TYPE_NONE),
       start_orientation_(TOUCH_HANDLE_ORIENTATION_UNDEFINED),
       end_orientation_(TOUCH_HANDLE_ORIENTATION_UNDEFINED),
       is_insertion_active_(false),
       activate_insertion_automatically_(false),
       is_selection_active_(false),
       activate_selection_automatically_(false),
       selection_empty_(false),
       selection_editable_(false),
-      temporarily_hidden_(false) {
+      temporarily_hidden_(false),
+      selection_handle_dragged_(false) {
   DCHECK(client_);
   HideAndDisallowShowingAutomatically();
 }
 
 TouchSelectionController::~TouchSelectionController() {

[jdduke (slow), 2015/02/10 17:50:25]

I'm not sure we ought to count this case, as this will occur if the tab is
closed, a cross-origin navigation occurs or the page crashes. I dunno.

[mfomitchev, 2015/02/10 19:05:23]

Sure. Got rid of this.

+  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 158 matching lines @@
   }
 
   gfx::PointF base, extent;
   if (&handle == start_selection_handle_.get()) {
     base = end_selection_handle_->position() + GetEndLineOffset();
     extent = start_selection_handle_->position() + GetStartLineOffset();
   } else {
     base = start_selection_handle_->position() + GetStartLineOffset();
     extent = end_selection_handle_->position() + GetEndLineOffset();
   }
+  selection_handle_dragged_ = true;
 
   // When moving the handle we want to move only the extent point. Before doing
   // so we must make sure that the base point is set correctly.
   client_->SelectBetweenCoordinates(base, extent);
 
   client_->OnSelectionEvent(SELECTION_DRAG_STARTED, handle.position());
 }
 
 void TouchSelectionController::OnHandleDragUpdate(const TouchHandle& handle,
                                                   const gfx::PointF& position) {
@@ skipping 126 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_handle_dragged_ = false;
+    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() {
+  // TODO(mfomitchev): Once we are able to tell the difference between
+  // 'successful' and 'unsuccessful' selections - log
+  // Event.TouchSelectionDuration instead and get rid of
+  // Event.TouchDragSelectionDuration.
+  if (selection_handle_dragged_) {
+    base::TimeDelta duration = base::TimeTicks::Now() - selection_start_time_;
+    UMA_HISTOGRAM_CUSTOM_TIMES("Event.TouchDragSelectionDuration",
+                               duration,
+                               base::TimeDelta::FromMilliseconds(1),
+                               base::TimeDelta::FromSeconds(60),
+                               50);

[jdduke (slow), 2015/02/10 17:50:25]

Is this enough buckets to get the granularity we want?

[mfomitchev, 2015/02/10 19:05:23]

That's a good point. The time scale is logarithmic by default, so I had a ton of
buckets from 1ms to 100ms, which was a total waste. I changed the min to be
1000ms, which makes things a lot better: at 1s the granularity is 90ms, at 3s it
is 300ms, at 10s it is 900ms, and the last bucket is ~5s. I think that's pretty
reasonable.

[jdduke (slow), 2015/02/10 19:08:05]

Ah, I didn't realize it was logarithmic, thanks.

+  }
+}
+
 }  // namespace ui