FOR REFERENCE ONLY Task Scheduler COM Task Runner

base/task_scheduler/task_tracker_unittest.cc

 // Copyright 2016 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/task_scheduler/task_tracker.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
@@ skipping 871 matching lines @@
 // task.
 TEST(TaskSchedulerTaskTrackerWaitAllowedTest, WaitAllowed) {
   // Run the test on the separate thread since it is not possible to reset the
   // "wait allowed" bit of a thread without being a friend of
   // ThreadRestrictions.
   WaitAllowedTestThread wait_allowed_test_thread;
   wait_allowed_test_thread.Start();
   wait_allowed_test_thread.Join();
 }
 
+namespace {
+
+struct TaskTraitHistogramPair {
+  TaskTraits traits;
+  const char* expected_histogram;
+
+  TaskTraitHistogramPair(const TaskTraits& traits_in,
+                         const char* expected_histogram_in)
+      : traits(traits_in), expected_histogram(expected_histogram_in) {}
+};
+
+std::vector<TaskTraitHistogramPair> GenerateTaskTraitHistogramPairs() {
+  std::vector<TaskTraitHistogramPair> pairs;
+  pairs.emplace_back(TaskTraits().WithPriority(TaskPriority::BACKGROUND),
+                     "TaskScheduler.TaskLatency.BackgroundTaskPriority");
+  pairs.emplace_back(
+      TaskTraits().WithPriority(TaskPriority::BACKGROUND).MayBlock(),
+      "TaskScheduler.TaskLatency.BackgroundTaskPriority.MayBlock");
+  pairs.emplace_back(
+      TaskTraits()
+          .WithPriority(TaskPriority::BACKGROUND)
+          .WithBaseSyncPrimitives(),
+      "TaskScheduler.TaskLatency.BackgroundTaskPriority.MayBlock");
+  pairs.emplace_back(TaskTraits().WithPriority(TaskPriority::USER_VISIBLE),
+                     "TaskScheduler.TaskLatency.UserVisibleTaskPriority");
+  pairs.emplace_back(
+      TaskTraits().WithPriority(TaskPriority::USER_VISIBLE).MayBlock(),
+      "TaskScheduler.TaskLatency.UserVisibleTaskPriority.MayBlock");
+  pairs.emplace_back(
+      TaskTraits()
+          .WithPriority(TaskPriority::USER_VISIBLE)
+          .WithBaseSyncPrimitives(),
+      "TaskScheduler.TaskLatency.UserVisibleTaskPriority.MayBlock");
+  pairs.emplace_back(TaskTraits().WithPriority(TaskPriority::USER_BLOCKING),
+                     "TaskScheduler.TaskLatency.UserBlockingTaskPriority");
+  pairs.emplace_back(
+      TaskTraits().WithPriority(TaskPriority::USER_BLOCKING).MayBlock(),
+      "TaskScheduler.TaskLatency.UserBlockingTaskPriority.MayBlock");
+  pairs.emplace_back(
+      TaskTraits()
+          .WithPriority(TaskPriority::USER_BLOCKING)
+          .WithBaseSyncPrimitives(),
+      "TaskScheduler.TaskLatency.UserBlockingTaskPriority.MayBlock");
+  return pairs;
+}
+
+}  // namespace
+
 // Verify that TaskScheduler.TaskLatency.* histograms are correctly recorded
 // when a task runs.
 TEST(TaskSchedulerTaskTrackerHistogramTest, TaskLatency) {
   auto statistics_recorder = StatisticsRecorder::CreateTemporaryForTesting();
 
   TaskTracker tracker;
 
-  struct {
-    const TaskTraits traits;
-    const char* const expected_histogram;
-  } tests[] = {
-      {TaskTraits().WithPriority(TaskPriority::BACKGROUND),
-       "TaskScheduler.TaskLatency.BackgroundTaskPriority"},
-      {TaskTraits().WithPriority(TaskPriority::BACKGROUND).MayBlock(),
-       "TaskScheduler.TaskLatency.BackgroundTaskPriority.MayBlock"},
-      {TaskTraits()
-           .WithPriority(TaskPriority::BACKGROUND)
-           .WithBaseSyncPrimitives(),
-       "TaskScheduler.TaskLatency.BackgroundTaskPriority.MayBlock"},
-      {TaskTraits().WithPriority(TaskPriority::USER_VISIBLE),
-       "TaskScheduler.TaskLatency.UserVisibleTaskPriority"},
-      {TaskTraits().WithPriority(TaskPriority::USER_VISIBLE).MayBlock(),
-       "TaskScheduler.TaskLatency.UserVisibleTaskPriority.MayBlock"},
-      {TaskTraits()
-           .WithPriority(TaskPriority::USER_VISIBLE)
-           .WithBaseSyncPrimitives(),
-       "TaskScheduler.TaskLatency.UserVisibleTaskPriority.MayBlock"},
-      {TaskTraits().WithPriority(TaskPriority::USER_BLOCKING),
-       "TaskScheduler.TaskLatency.UserBlockingTaskPriority"},
-      {TaskTraits().WithPriority(TaskPriority::USER_BLOCKING).MayBlock(),
-       "TaskScheduler.TaskLatency.UserBlockingTaskPriority.MayBlock"},
-      {TaskTraits()
-           .WithPriority(TaskPriority::USER_BLOCKING)
-           .WithBaseSyncPrimitives(),
-       "TaskScheduler.TaskLatency.UserBlockingTaskPriority.MayBlock"}};
-
-  for (const auto& test : tests) {
+  for (const auto& test : GenerateTaskTraitHistogramPairs()) {
     auto task =
         MakeUnique<Task>(FROM_HERE, Bind(&DoNothing), test.traits, TimeDelta());
     ASSERT_TRUE(tracker.WillPostTask(task.get()));
 
     HistogramTester tester;
     EXPECT_TRUE(tracker.RunTask(std::move(task), SequenceToken::Create()));
     tester.ExpectTotalCount(test.expected_histogram, 1);
   }
 }
 
+TEST(TaskSchedulerTaskTrackerHistogramTest, TaskLatencyInternalOnly) {
+  auto statistics_recorder = StatisticsRecorder::CreateTemporaryForTesting();
+
+  TaskTracker tracker;
+
+  for (const auto& test : GenerateTaskTraitHistogramPairs()) {
+    auto task = MakeUnique<Task>(FROM_HERE, Bind(&DoNothing), test.traits,
+                                 TimeDelta(), Task::TaskType::INTERNAL);
+    ASSERT_TRUE(tracker.WillPostTask(task.get()));
+
+    HistogramTester tester;
+    EXPECT_TRUE(tracker.RunTask(std::move(task), SequenceToken::Create()));
+    tester.ExpectTotalCount(test.expected_histogram, 0);
+  }
+}
+
 }  // namespace internal
 }  // namespace base