Add UMA for High Resolution Timer Usage

base/timer/hi_res_timer_manager_win.cc

 // Copyright (c) 2011 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 "base/timer/hi_res_timer_manager.h"
 
+#include <algorithm>
+
+#include "base/atomicops.h"
+#include "base/metrics/histogram_macros.h"
 #include "base/power_monitor/power_monitor.h"
+#include "base/task_scheduler/post_task.h"
 #include "base/time/time.h"
 
 namespace base {
 
+namespace {
+
+constexpr TimeDelta kUsageSampleInterval = TimeDelta::FromMinutes(10);
+
+subtle::Atomic32 g_report_id = 0;
+
+// Forward declaration.
+void MaybeReportHighResolutionTimerUsageAndReschedule(int report_id);
+
+void ScheduleHighResolutionTimerUsageReport() {
+  Time::ResetHighResolutionTimerUsage();
+  int next_report_id = subtle::NoBarrier_AtomicIncrement(&g_report_id, 1);
+  PostDelayedTaskWithTraits(
+      FROM_HERE,
+      {TaskPriority::BACKGROUND, TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
+      Bind(&MaybeReportHighResolutionTimerUsageAndReschedule, next_report_id),
+      kUsageSampleInterval);
+}
+
+void ReportHighResolutionTimerUsage() {
+  UMA_HISTOGRAM_PERCENTAGE("Windows.HighResolutionTimerUsage",
+                           Time::GetHighResolutionTimerUsage());
+}
+
+void MaybeReportHighResolutionTimerUsageAndReschedule(int report_id) {
+  if (report_id != subtle::NoBarrier_Load(&g_report_id))
+    return;
+
+  ReportHighResolutionTimerUsage();
+  ScheduleHighResolutionTimerUsageReport();
+}
+
+}  // namespace
+
 HighResolutionTimerManager::HighResolutionTimerManager()
     : hi_res_clock_available_(false) {
-  base::PowerMonitor* power_monitor = base::PowerMonitor::Get();
+  PowerMonitor* power_monitor = PowerMonitor::Get();
   DCHECK(power_monitor != NULL);
   power_monitor->AddObserver(this);
   UseHiResClock(!power_monitor->IsOnBatteryPower());
+  ScheduleHighResolutionTimerUsageReport();
 }
 
 HighResolutionTimerManager::~HighResolutionTimerManager() {
-  base::PowerMonitor::Get()->RemoveObserver(this);
+  PowerMonitor::Get()->RemoveObserver(this);
   UseHiResClock(false);
 }
 
 void HighResolutionTimerManager::OnPowerStateChange(bool on_battery_power) {
   UseHiResClock(!on_battery_power);
 }
 
+void HighResolutionTimerManager::OnSuspend() {
+  // Skip to next report id to prevent a queued usage report from being logged
+  // on resume and including the standby time.
+  subtle::NoBarrier_AtomicIncrement(&g_report_id, 1);
+}
+
+void HighResolutionTimerManager::OnResume() {
+  ScheduleHighResolutionTimerUsageReport();

[gab, 2017/06/28 16:39:33]

It's possible that the task fired from here runs at the same time as the
recurring task. Since Time::Get...() isn't thread-safe you at least need to post
to a SequencedTaskRunner (e.g. anonymous LazySequencedTaskRunner).

Overall though I think base::Timer is probably what you want (assuming 
HighResolutionTimerManager is constructed and notified on the same sequence then
all you need is to Timer::Reset() to avoid running the delayed task).

[stanisc, 2017/06/28 22:28:35]

report_id was supposed to protect from running concurrent tasks, but you are
right that using base::Timer is much simpler in this case. Done. 

[gab, 2017/07/01 06:55:30]

FWIW atomics merely provide eventual consistency so it was still possible for
two threads to each see the value they expected at the same time and execute in
parallel.

+}
+
 void HighResolutionTimerManager::UseHiResClock(bool use) {
   if (use == hi_res_clock_available_)
     return;
   hi_res_clock_available_ = use;
-  base::Time::EnableHighResolutionTimer(use);
+  Time::EnableHighResolutionTimer(use);
 }
 
 }  // namespace base