Report user actions when gesture starts and stops in user_model.

components/scheduler/renderer/user_model.cc

 // Copyright 2015 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 "components/scheduler/renderer/user_model.h"
 
 #include "base/metrics/histogram_macros.h"
+#include "base/metrics/user_metrics.h"
+#include "base/single_thread_task_runner.h"
 
 namespace scheduler {
 
 namespace {
 // This enum is used to back a histogram, and should therefore be treated as
 // append-only.
 enum GesturePredictionResult {
   GESTURE_OCCURED_WAS_PREDICTED = 0,
   GESTURE_OCCURED_BUT_NOT_PREDICTED = 1,
   GESTURE_PREDICTED_BUT_DID_NOT_OCCUR = 2,
   GESTURE_PREDICTION_RESULT_COUNT = 3
 };
 
 void RecordGesturePrediction(GesturePredictionResult result) {
   UMA_HISTOGRAM_ENUMERATION(
       "RendererScheduler.UserModel.GesturePredictedCorrectly", result,
       GESTURE_PREDICTION_RESULT_COUNT);
 }
 
 }  // namespace
 
-UserModel::UserModel()
-    : pending_input_event_count_(0),
+namespace features {
+
+// Enables the recording of gesture as UMA user actions.

[Ilya Sherman, 2016/03/21 08:09:43]

nit: s/gesture/gestures

[beaudoin, 2016/03/23 02:46:41]

Done.

+// That feature is disabled by default and controlled from the server so as not
+// to generate too many UMA user actions.
+const base::Feature kRecordGestureAction {"RecordGestureActions",
+                                          base::FEATURE_DISABLED_BY_DEFAULT};
+
+}  // namespace features
+
+UserModel::UserModel(
+    const scoped_refptr<base::SingleThreadTaskRunner>& default_task_runner)
+    : default_task_runner_(default_task_runner),
+      pending_input_event_count_(0),
       is_gesture_active_(false),
-      is_gesture_expected_(false) {}
+      is_gesture_expected_(false),
+      record_gesture_action_(

[Ilya Sherman, 2016/03/21 08:09:43]

Hmm, why do you need to cache this state?  base::FeatureList::IsEnabled() should
be pretty efficient.  Did you find that it's not sufficiently efficient for your
needs?

[alex clarke (OOO till 29th), 2016/03/21 09:27:26]

Because I asked him to:)  The UserModel gets evaluated quite a bit so I don't
want to do unnecessary work when we could cache it.

[beaudoin, 2016/03/23 02:46:41]

Suggest leaving it like that for now. I've added a comment.

[Ilya Sherman, 2016/03/24 05:02:35]

the base::FeatureList::IsEnabled() call is basically a single map lookup.  Is
your code really so performance-sensitive?  IMO this seems like premature
optimization which hurts readability.

+          base::FeatureList::IsEnabled(features::kRecordGestureAction)) {}
 UserModel::~UserModel() {}
 
 void UserModel::DidStartProcessingInputEvent(blink::WebInputEvent::Type type,
                                              const base::TimeTicks now) {
   last_input_signal_time_ = now;
   if (type == blink::WebInputEvent::TouchStart ||
       type == blink::WebInputEvent::GestureScrollBegin ||
       type == blink::WebInputEvent::GesturePinchBegin) {
     // Only update stats once per gesture.
     if (!is_gesture_active_) {
       last_gesture_start_time_ = now;
 
+      if (record_gesture_action_) {
+        default_task_runner_->PostTask(
+            FROM_HERE,
+            base::Bind(&base::RecordAction,
+                       base::UserMetricsAction(
+                           "RendererScheduler.UserModel.GestureStart")));
+      }
+
       RecordGesturePrediction(is_gesture_expected_
                                   ? GESTURE_OCCURED_WAS_PREDICTED
                                   : GESTURE_OCCURED_BUT_NOT_PREDICTED);
 
       if (!last_reset_time_.is_null()) {
         base::TimeDelta time_since_reset = now - last_reset_time_;
         UMA_HISTOGRAM_MEDIUM_TIMES(
             "RendererScheduler.UserModel.GestureStartTimeSinceModelReset",
             time_since_reset);
       }
@@ skipping 29 matching lines @@
   // metric that tracks its duration.
   if (type == blink::WebInputEvent::GestureScrollEnd ||
       type == blink::WebInputEvent::GesturePinchEnd ||
       type == blink::WebInputEvent::GestureFlingStart ||
       type == blink::WebInputEvent::TouchEnd) {
     // Only update stats once per gesture.
     if (is_gesture_active_) {
       base::TimeDelta duration = now - last_gesture_start_time_;
       UMA_HISTOGRAM_TIMES("RendererScheduler.UserModel.GestureDuration",
                           duration);
+      if (record_gesture_action_) {
+        default_task_runner_->PostTask(
+            FROM_HERE,
+            base::Bind(&base::RecordAction,
+                       base::UserMetricsAction(
+                           "RendererScheduler.UserModel.GestureEnd")));
+      }
     }
     is_gesture_active_ = false;
   }
 
   TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                  "is_gesture_active", is_gesture_active_);
 
   pending_input_event_count_++;
 }
 
@@ skipping 109 matching lines @@
                    (last_gesture_expected_start_time_ - base::TimeTicks())
                        .InMillisecondsF());
   state->SetDouble("last_reset_time",
                    (last_reset_time_ - base::TimeTicks()).InMillisecondsF());
   state->SetBoolean("is_gesture_expected", is_gesture_expected_);
   state->SetBoolean("is_gesture_active", is_gesture_active_);
   state->EndDictionary();
 }
 
 }  // namespace scheduler