Correctly record TouchView metrics on suspend/shutdown

ash/wm/maximize_mode/maximize_mode_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 "ash/wm/maximize_mode/maximize_mode_controller.h"
 
 #include "ash/accelerators/accelerator_controller.h"
 #include "ash/accelerators/accelerator_table.h"
 #include "ash/ash_switches.h"
 #include "ash/display/display_manager.h"
@@ skipping 76 matching lines @@
                  update.get(chromeos::ACCELEROMETER_SOURCE_SCREEN)).Length()) <=
          kNoisyMagnitudeDeviation;
 }
 #endif  // OS_CHROMEOS
 
 }  // namespace
 
 MaximizeModeController::MaximizeModeController()
     : have_seen_accelerometer_data_(false),
       lid_open_past_180_(false),
-      last_touchview_transition_time_(base::Time::Now()),
+      touchview_usage_interval_start_time_(base::Time::Now()),
       tick_clock_(new base::DefaultTickClock()),
       lid_is_closed_(false) {
   Shell::GetInstance()->AddShellObserver(this);
 #if defined(OS_CHROMEOS)
   chromeos::AccelerometerReader::GetInstance()->AddObserver(this);
   chromeos::DBusThreadManager::Get()->
       GetPowerManagerClient()->AddObserver(this);
 #endif  // OS_CHROMEOS
 }
 
@@ skipping 70 matching lines @@
 
 void MaximizeModeController::LidEventReceived(bool open,
                                               const base::TimeTicks& time) {
   if (open)
     last_lid_open_time_ = time;
   lid_is_closed_ = !open;
   LeaveMaximizeMode();
 }
 
 void MaximizeModeController::SuspendImminent() {
-  RecordTouchViewStateTransition();
+  // The system is about to suspend, so record TouchView usage interval metrics
+  // based on whether TouchView mode is currently active.
+  TouchViewIntervalType type = TOUCH_VIEW_INTERVAL_INACTIVE;
+  if (IsMaximizeModeWindowManagerEnabled())
+    type = TOUCH_VIEW_INTERVAL_ACTIVE;

[flackr, 2015/02/12 19:59:06]

If it's a bool, can you just use IsMaximizeModeWindowManagerEnabled() rather
than if statement? If still an enum, maybe make a function which returns the
current state.

[tdanderson, 2015/02/12 20:30:49]

OK, will do.

[tdanderson, 2015/02/12 21:38:22]

Done.

+  RecordTouchViewUsageInterval(type);
 }
 
 void MaximizeModeController::SuspendDone(
     const base::TimeDelta& sleep_duration) {
-  last_touchview_transition_time_ = base::Time::Now();
+  // We do not want TouchView usage metrics to include time spent in suspend.
+  touchview_usage_interval_start_time_ = base::Time::Now();
 }
 
 void MaximizeModeController::HandleHingeRotation(
     const chromeos::AccelerometerUpdate& update) {
   static const gfx::Vector3dF hinge_vector(1.0f, 0.0f, 0.0f);
   // Ignore the component of acceleration parallel to the hinge for the purposes
   // of hinge angle calculation.
   gfx::Vector3dF base_flattened(ui::ConvertAccelerometerReadingToVector3dF(
       update.get(chromeos::ACCELEROMETER_SOURCE_ATTACHED_KEYBOARD)));
   gfx::Vector3dF lid_flattened(ui::ConvertAccelerometerReadingToVector3dF(
@@ skipping 57 matching lines @@
 }
 
 void MaximizeModeController::LeaveMaximizeMode() {
   if (!IsMaximizeModeWindowManagerEnabled())
     return;
   EnableMaximizeModeWindowManager(false);
 }
 
 // Called after maximize mode has started, windows might still animate though.
 void MaximizeModeController::OnMaximizeModeStarted() {
-  RecordTouchViewStateTransition();
+  RecordTouchViewUsageInterval(TOUCH_VIEW_INTERVAL_INACTIVE);
 }
 
 // Called after maximize mode has ended, windows might still be returning to
 // their original position.
 void MaximizeModeController::OnMaximizeModeEnded() {
-  RecordTouchViewStateTransition();
+  RecordTouchViewUsageInterval(TOUCH_VIEW_INTERVAL_ACTIVE);
 }
 
-void MaximizeModeController::RecordTouchViewStateTransition() {
-  if (CanEnterMaximizeMode()) {
-    base::Time current_time = base::Time::Now();
-    base::TimeDelta delta = current_time - last_touchview_transition_time_;
-    if (IsMaximizeModeWindowManagerEnabled()) {
+void MaximizeModeController::RecordTouchViewUsageInterval(
+    TouchViewIntervalType type) {
+  if (!CanEnterMaximizeMode())
+    return;
+
+  base::Time current_time = base::Time::Now();
+  base::TimeDelta delta = current_time - touchview_usage_interval_start_time_;
+  switch (type) {
+    case TOUCH_VIEW_INTERVAL_INACTIVE:
       UMA_HISTOGRAM_LONG_TIMES("Ash.TouchView.TouchViewInactive", delta);
       total_non_touchview_time_ += delta;
-    } else {
+      break;
+    case TOUCH_VIEW_INTERVAL_ACTIVE:
       UMA_HISTOGRAM_LONG_TIMES("Ash.TouchView.TouchViewActive", delta);
       total_touchview_time_ += delta;
-    }
-    last_touchview_transition_time_ = current_time;
+      break;
   }
+
+  touchview_usage_interval_start_time_ = current_time;
 }
 
 void MaximizeModeController::OnAppTerminating() {
+  // The system is about to shut down, so record TouchView usage interval
+  // metrics based on whether TouchView mode is currently active.
+  TouchViewIntervalType type = TOUCH_VIEW_INTERVAL_INACTIVE;
+  if (IsMaximizeModeWindowManagerEnabled())
+    type = TOUCH_VIEW_INTERVAL_ACTIVE;
+  RecordTouchViewUsageInterval(type);
+
   if (CanEnterMaximizeMode()) {
-    RecordTouchViewStateTransition();
     UMA_HISTOGRAM_CUSTOM_COUNTS("Ash.TouchView.TouchViewActiveTotal",
         total_touchview_time_.InMinutes(),
         1, base::TimeDelta::FromDays(7).InMinutes(), 50);
     UMA_HISTOGRAM_CUSTOM_COUNTS("Ash.TouchView.TouchViewInactiveTotal",
         total_non_touchview_time_.InMinutes(),
         1, base::TimeDelta::FromDays(7).InMinutes(), 50);
     base::TimeDelta total_runtime = total_touchview_time_ +
         total_non_touchview_time_;
     if (total_runtime.InSeconds() > 0) {
       UMA_HISTOGRAM_PERCENTAGE("Ash.TouchView.TouchViewActivePercentage",
@@ skipping 12 matching lines @@
   return elapsed_time <= kLidRecentlyOpenedDuration;
 }
 
 void MaximizeModeController::SetTickClockForTest(
     scoped_ptr<base::TickClock> tick_clock) {
   DCHECK(tick_clock_);
   tick_clock_ = tick_clock.Pass();
 }
 
 }  // namespace ash