[Merge M48] Add Startup.TimeSinceLastStartup histogram.

components/startup_metric_utils/browser/startup_metric_utils.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 "components/startup_metric_utils/browser/startup_metric_utils.h"
 
 #include "base/containers/hash_tables.h"
 #include "base/environment.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
+#include "base/prefs/pref_registry_simple.h"
+#include "base/prefs/pref_service.h"
+#include "base/process/process_info.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/sys_info.h"
 #include "base/threading/platform_thread.h"
 #include "base/trace_event/trace_event.h"
 
 #if defined(OS_WIN)
 #include <winternl.h>
 #include "base/win/windows_version.h"
 #endif
 
 namespace startup_metric_utils {
 
 namespace {
 
+const char kLastStartupTimestampPref[] =
+    "startup_metric.last_startup_timestamp";
+
 // Mark as volatile to defensively make sure usage is thread-safe.
 // Note that at the time of this writing, access is only on the UI thread.
 volatile bool g_non_browser_ui_displayed = false;
 
 base::LazyInstance<base::TimeTicks>::Leaky g_process_creation_ticks =
     LAZY_INSTANCE_INITIALIZER;
 
 base::LazyInstance<base::TimeTicks>::Leaky g_main_entry_point_ticks =
     LAZY_INSTANCE_INITIALIZER;
 
@@ skipping 116 matching lines @@
     if (proc_info->NextEntryOffset <= 0)
       return false;
     index += proc_info->NextEntryOffset;
   }
 
   return false;
 }
 
 #endif  // defined(OS_WIN)
 
+#define UMA_HISTOGRAM_TIME_IN_MINUTES_MONTH_RANGE(name, sample) \
+  UMA_HISTOGRAM_CUSTOM_COUNTS(name, sample, 1,                  \
+                              base::TimeDelta::FromDays(30).InMinutes(), 50)
 
 // Helper macro for splitting out an UMA histogram based on cold or warm start.
 // |type| is the histogram type, and corresponds to an UMA macro like
 // UMA_HISTOGRAM_LONG_TIMES. It must itself be a macro that only takes two
 // parameters.
 // |basename| is the basename of the histogram. A histogram of this name will
 // always be recorded to. If the startup is either cold or warm then a value
 // will also be recorded to the histogram with name |basename| and suffix
 // ".ColdStart" or ".WarmStart", as appropriate.
 // |value_expr| is an expression evaluating to the value to be recorded. This
@@ skipping 199 matching lines @@
   int64 time_int = 0;
   if (env->GetVar(kChromeMainTicksEnvVar, &ticks_string) &&
       base::StringToInt64(ticks_string, &time_int)) {
     return base::TimeTicks::FromInternalValue(time_int);
   }
   return base::TimeTicks();
 }
 
 }  // namespace
 
+void RegisterPrefs(PrefRegistrySimple* registry) {
+  DCHECK(registry);
+  registry->RegisterInt64Pref(kLastStartupTimestampPref, 0);
+}
+
 bool WasNonBrowserUIDisplayed() {
   return g_non_browser_ui_displayed;
 }
 
 void SetNonBrowserUIDisplayed() {
   g_non_browser_ui_displayed = true;
 }
 
 void RecordStartupProcessCreationTime(const base::Time& time) {
   DCHECK(g_process_creation_ticks.Get().is_null());
@@ skipping 74 matching lines @@
 
       // Process create to chrome.dll:main(). Reported as a histogram only as
       // the other two events above are sufficient for tracing purposes.
       UMA_HISTOGRAM_WITH_STARTUP_TEMPERATURE(
           UMA_HISTOGRAM_LONG_TIMES, "Startup.LoadTime.ProcessCreateToDllMain",
           g_main_entry_point_ticks.Get() - process_creation_ticks);
     }
   }
 }
 
+void RecordTimeSinceLastStartup(PrefService* pref_service) {
+#if defined(OS_MACOSX) || defined(OS_WIN) || defined(OS_LINUX)
+  DCHECK(pref_service);
+
+  // Get the timestamp of the current startup.
+  const base::Time process_start_time =
+      base::CurrentProcessInfo::CreationTime();
+
+  // Get the timestamp of the last startup from |pref_service|.
+  const int64_t last_startup_timestamp_internal =
+      pref_service->GetInt64(kLastStartupTimestampPref);
+  if (last_startup_timestamp_internal != 0) {
+    // Log the Startup.TimeSinceLastStartup histogram.
+    const base::Time last_startup_timestamp =
+        base::Time::FromInternalValue(last_startup_timestamp_internal);
+    const base::TimeDelta time_since_last_startup =
+        process_start_time - last_startup_timestamp;
+    const int minutes_since_last_startup = time_since_last_startup.InMinutes();
+
+    // Ignore negative values, which can be caused by system clock changes.
+    if (minutes_since_last_startup >= 0) {
+      UMA_HISTOGRAM_WITH_STARTUP_TEMPERATURE(
+          UMA_HISTOGRAM_TIME_IN_MINUTES_MONTH_RANGE,
+          "Startup.TimeSinceLastStartup", minutes_since_last_startup);
+    }
+  }
+
+  // Write the timestamp of the current startup in |pref_service|.
+  pref_service->SetInt64(kLastStartupTimestampPref,
+                         process_start_time.ToInternalValue());
+#endif  // defined(OS_MACOSX) || defined(OS_WIN) || defined(OS_LINUX)
+}
+
 void RecordBrowserWindowDisplay(const base::TimeTicks& ticks) {
   static bool is_first_call = true;
   if (!is_first_call || ticks.is_null())
     return;
   is_first_call = false;
   if (WasNonBrowserUIDisplayed() || g_process_creation_ticks.Get().is_null())
     return;
 
   UMA_HISTOGRAM_AND_TRACE_WITH_STARTUP_TEMPERATURE(
       UMA_HISTOGRAM_LONG_TIMES, "Startup.BrowserWindowDisplay",
@@ skipping 95 matching lines @@
 
 base::TimeTicks MainEntryPointTicks() {
   return g_main_entry_point_ticks.Get();
 }
 
 StartupTemperature GetStartupTemperature() {
   return g_startup_temperature;
 }
 
 }  // namespace startup_metric_utils