[Cleanup] Migrate the WatcherMetricsProvider to use the Task Scheduler.

components/browser_watcher/watcher_metrics_provider_win.cc

 // Copyright (c) 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 "components/browser_watcher/watcher_metrics_provider_win.h"
 
 #include <stddef.h>
 
 #include <limits>
 #include <memory>
 #include <set>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/feature_list.h"
 #include "base/metrics/field_trial_params.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/histogram_base.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/process/process.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/task_scheduler/post_task.h"
+#include "base/task_scheduler/task_traits.h"
 #include "base/win/registry.h"
 #include "components/browser_watcher/features.h"
 #include "components/browser_watcher/postmortem_report_collector.h"
 #include "components/browser_watcher/stability_paths.h"
 #include "components/browser_watcher/system_session_analyzer_win.h"
 #include "third_party/crashpad/crashpad/client/crash_report_database.h"
 
 namespace browser_watcher {
 
 namespace {
@@ skipping 119 matching lines @@
   GET_STABILITY_FILE_PATH_FAILED = 2,
   CRASHPAD_DATABASE_INIT_FAILED = 3,
   INIT_STATUS_MAX = 4
 };
 
 void LogCollectionInitStatus(CollectionInitializationStatus status) {
   UMA_HISTOGRAM_ENUMERATION("ActivityTracker.Collect.InitStatus", status,
                             INIT_STATUS_MAX);
 }
 
+// Returns a task runner appropriate for running background tasks that perform
+// file I/O.
+scoped_refptr<base::TaskRunner> CreateBackgroundTaskRunner() {
+  return base::CreateSequencedTaskRunnerWithTraits(
+      {base::MayBlock(), base::TaskPriority::BACKGROUND,
+       base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN});
+}
+
 }  // namespace
 
 const char WatcherMetricsProviderWin::kBrowserExitCodeHistogramName[] =
     "Stability.BrowserExitCodes";
 
 WatcherMetricsProviderWin::WatcherMetricsProviderWin(
     const base::string16& registry_path,
     const base::FilePath& user_data_dir,
     const base::FilePath& crash_dir,
-    const GetExecutableDetailsCallback& exe_details_cb,
-    base::TaskRunner* io_task_runner)
+    const GetExecutableDetailsCallback& exe_details_cb)
     : recording_enabled_(false),
       cleanup_scheduled_(false),
       registry_path_(registry_path),
       user_data_dir_(user_data_dir),
       crash_dir_(crash_dir),
       exe_details_cb_(exe_details_cb),
-      io_task_runner_(io_task_runner),
-      weak_ptr_factory_(this) {
-  DCHECK(io_task_runner_);
-}
+      task_runner_(CreateBackgroundTaskRunner()),
+      weak_ptr_factory_(this) {}
 
 WatcherMetricsProviderWin::~WatcherMetricsProviderWin() {
 }
 
 void WatcherMetricsProviderWin::OnRecordingEnabled() {
   recording_enabled_ = true;
 }
 
 void WatcherMetricsProviderWin::OnRecordingDisabled() {
   if (!recording_enabled_ && !cleanup_scheduled_) {
     // When metrics reporting is disabled, the providers get an
     // OnRecordingDisabled notification at startup. Use that first notification
     // to issue the cleanup task.
-    io_task_runner_->PostTask(
-        FROM_HERE, base::Bind(&DeleteExitCodeRegistryKey, registry_path_));
+    task_runner_->PostTask(
+        FROM_HERE, base::BindOnce(&DeleteExitCodeRegistryKey, registry_path_));
 
     cleanup_scheduled_ = true;
   }
 }
 
 void WatcherMetricsProviderWin::ProvideStabilityMetrics(
     metrics::SystemProfileProto* /* system_profile_proto */) {
   // Note that if there are multiple instances of Chrome running in the same
   // user account, there's a small race that will double-report the exit codes
   // from both/multiple instances. This ought to be vanishingly rare and will
   // only manifest as low-level "random" noise. To work around this it would be
   // necessary to implement some form of global locking, which is not worth it
   // here.
   RecordExitCodes(registry_path_);
 }
 
 void WatcherMetricsProviderWin::CollectPostmortemReports(
     const base::Closure& done_callback) {
-  io_task_runner_->PostTaskAndReply(
+  task_runner_->PostTaskAndReply(
       FROM_HERE,
-      base::Bind(
-          &WatcherMetricsProviderWin::CollectPostmortemReportsOnBlockingPool,
-          weak_ptr_factory_.GetWeakPtr()),
+      base::BindOnce(&WatcherMetricsProviderWin::CollectPostmortemReportsImpl,
+                     weak_ptr_factory_.GetWeakPtr()),
       done_callback);
 }
 
 // TODO(manzagop): consider mechanisms for partial collection if this is to be
 //     used on a critical path.
-void WatcherMetricsProviderWin::CollectPostmortemReportsOnBlockingPool() {
+void WatcherMetricsProviderWin::CollectPostmortemReportsImpl() {
   SCOPED_UMA_HISTOGRAM_TIMER("ActivityTracker.Collect.TotalTime");
 
   bool is_stability_debugging_on =
       base::FeatureList::IsEnabled(browser_watcher::kStabilityDebuggingFeature);
   if (!is_stability_debugging_on) {
     return;  // TODO(manzagop): scan for possible data to delete?
   }
 
   if (user_data_dir_.empty() || crash_dir_.empty()) {

[manzagop (departed), 2017/06/30 20:11:43]

Sidenote, this reminds me I have a bug to make this a free function to avoid a
UAF (https://crbug.com/711743).

     LogCollectionInitStatus(UNKNOWN_DIR);
     return;
   }
 
   // Determine which files to harvest.
   base::FilePath stability_dir = GetStabilityDir(user_data_dir_);
 
   base::FilePath current_stability_file;
   if (!GetStabilityFileForProcess(base::Process::Current(), user_data_dir_,
                                   &current_stability_file)) {
@@ skipping 36 matching lines @@
 
   const size_t kSystemSessionsToInspect = 5U;
   SystemSessionAnalyzer analyzer(kSystemSessionsToInspect);
   PostmortemReportCollector collector(
       base::UTF16ToUTF8(product_name), base::UTF16ToUTF8(version_number),
       base::UTF16ToUTF8(channel_name), crashpad_database.get(), &analyzer);
   collector.Process(stability_files);
 }
 
 }  // namespace browser_watcher