Changed when the UMA metric Ash.NumberOfVisibleWindowsInPrimaryDisplay is recorded.

ash/metrics/user_metrics_recorder.cc

 // Copyright 2013 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/metrics/user_metrics_recorder.h"
 
+#include "ash/session/session_state_delegate.h"
 #include "ash/shelf/shelf_layout_manager.h"
 #include "ash/shelf/shelf_view.h"
 #include "ash/shelf/shelf_widget.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
+#include "ash/system/tray/system_tray_delegate.h"
 #include "ash/wm/window_state.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/user_metrics.h"
 #include "ui/aura/window.h"
 
 namespace ash {
 
 namespace {
 
 // Time in seconds between calls to "RecordPeriodicMetrics".
@@ skipping 35 matching lines @@
       case wm::WINDOW_STATE_TYPE_INACTIVE:
       case wm::WINDOW_STATE_TYPE_END:
       case wm::WINDOW_STATE_TYPE_AUTO_POSITIONED:
         active_window_state_type = ACTIVE_WINDOW_STATE_TYPE_OTHER;
         break;
     }
   }
   return active_window_state_type;
 }
 
+// Returns true if kiosk mode is active.
+bool IsKioskModeActive() {
+  return Shell::GetInstance()->system_tray_delegate()->GetUserLoginStatus() ==
+         user::LOGGED_IN_KIOSK_APP;
+}
+
+// Returns true if there is an active user and their session isn't currently
+// locked.
+bool IsUserActive() {
+  switch (Shell::GetInstance()->system_tray_delegate()->GetUserLoginStatus()) {
+    case user::LOGGED_IN_NONE:
+    case user::LOGGED_IN_LOCKED:
+      return false;
+    case user::LOGGED_IN_USER:
+    case user::LOGGED_IN_OWNER:
+    case user::LOGGED_IN_GUEST:
+    case user::LOGGED_IN_PUBLIC:
+    case user::LOGGED_IN_SUPERVISED:
+    case user::LOGGED_IN_KIOSK_APP:
+      return true;
+  }
+  NOTREACHED();
+  return false;
+}
+
 // Array of window container ids that contain visible windows to be counted for
 // UMA statistics. Note the containers are ordered from top most visible
 // container to the lowest to allow the |GetNumVisibleWindows| method to short
 // circuit when processing a maximized or fullscreen window.
 int kVisibleWindowContainerIds[] = {kShellWindowId_PanelContainer,
                                     kShellWindowId_DockedContainer,
                                     kShellWindowId_AlwaysOnTopContainer,
                                     kShellWindowId_DefaultContainer};
 
 // Returns an approximate count of how many windows are currently visible in the
@@ skipping 40 matching lines @@
         break;
       }
     }
   }
   return visible_window_count;
 }
 
 }  // namespace
 
 UserMetricsRecorder::UserMetricsRecorder() {
-  timer_.Start(FROM_HERE,
-               base::TimeDelta::FromSeconds(kAshPeriodicMetricsTimeInSeconds),
-               this,
-               &UserMetricsRecorder::RecordPeriodicMetrics);
+  StartTimer();
+}
+
+UserMetricsRecorder::UserMetricsRecorder(bool record_periodic_metrics) {
+  if (record_periodic_metrics)
+    StartTimer();
 }
 
 UserMetricsRecorder::~UserMetricsRecorder() {
   timer_.Stop();
 }
 
 void UserMetricsRecorder::RecordUserMetricsAction(UserMetricsAction action) {
   switch (action) {
     case ash::UMA_ACCEL_KEYBOARD_BRIGHTNESS_DOWN_F6:
       base::RecordAction(
@@ skipping 371 matching lines @@
     case ash::UMA_WINDOW_CYCLE:
       base::RecordAction(
           base::UserMetricsAction("WindowCycleController_Cycle"));
       break;
   }
 }
 
 void UserMetricsRecorder::RecordPeriodicMetrics() {
   ShelfLayoutManager* manager =
       ShelfLayoutManager::ForShelf(Shell::GetPrimaryRootWindow());
+  // TODO(bruthig): Investigating whether the check for |manager| is necessary
+  // and add tests if it is.
   if (manager) {
+    // TODO(bruthig): Consider tracking the time spent in each alignment.
     UMA_HISTOGRAM_ENUMERATION("Ash.ShelfAlignmentOverTime",
                               manager->SelectValueForShelfAlignment(
                                   SHELF_ALIGNMENT_UMA_ENUM_VALUE_BOTTOM,
                                   SHELF_ALIGNMENT_UMA_ENUM_VALUE_LEFT,
                                   SHELF_ALIGNMENT_UMA_ENUM_VALUE_RIGHT,
                                   -1),
                               SHELF_ALIGNMENT_UMA_ENUM_VALUE_COUNT);
   }
 
-  UMA_HISTOGRAM_COUNTS_100("Ash.NumberOfVisibleWindowsInPrimaryDisplay",
-                           GetNumVisibleWindowsInPrimaryDisplay());
+  if (IsUserActiveInMultiWindowEnvironment()) {
+    UMA_HISTOGRAM_COUNTS_100("Ash.NumberOfVisibleWindowsInPrimaryDisplay",
+                             GetNumVisibleWindowsInPrimaryDisplay());
+  }
 
+  // TODO(bruthig): Find out if this should only be logged when the user is
+  // active.
+  // TODO(bruthig): Consider tracking how long a particular type of window is
+  // active at a time.
   UMA_HISTOGRAM_ENUMERATION("Ash.ActiveWindowShowTypeOverTime",
                             GetActiveWindowState(),
                             ACTIVE_WINDOW_STATE_TYPE_COUNT);
 }
 
+bool UserMetricsRecorder::IsUserActiveInMultiWindowEnvironment() const {
+  return IsUserActive() && !IsKioskModeActive();
+}
+
+void UserMetricsRecorder::StartTimer() {
+  timer_.Start(FROM_HERE,
+               base::TimeDelta::FromSeconds(kAshPeriodicMetricsTimeInSeconds),
+               this, &UserMetricsRecorder::RecordPeriodicMetrics);
+}
+
 }  // namespace ash