Name TaskScheduler's worker threads

base/task_scheduler/task_scheduler_impl_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_scheduler_impl.h"
 
 #include <stddef.h>
 
+#include <limits>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/string_piece.h"
+#include "base/strings/string_util.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/task_scheduler/task_traits.h"
 #include "base/task_scheduler/test_task_factory.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/simple_thread.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
@@ skipping 41 matching lines @@
   EXPECT_EQ(traits.priority() == TaskPriority::BACKGROUND
                 ? ThreadPriority::BACKGROUND
                 : ThreadPriority::NORMAL,
             PlatformThread::GetCurrentThreadPriority());
 
 #if ENABLE_THREAD_RESTRICTIONS
   // The #if above is required because GetIOAllowed() always returns true when
   // !ENABLE_THREAD_RESTRICTIONS, even when |traits| don't allow file I/O.
   EXPECT_EQ(traits.with_file_io(), GetIOAllowed());
 #endif
+
+  // Verify that the thread the task is running on is named as expected
+  // (appropriate prefix label and index for its traits).
+  std::string expected_thread_name = "TaskScheduler";
+  expected_thread_name += traits.priority() == TaskPriority::BACKGROUND
+                              ? "Background"
+                              : "Foreground";
+  if (traits.with_file_io())
+    expected_thread_name += "FileIO";
+  expected_thread_name += "Worker";
+
+  const std::string actual_thread_name(PlatformThread::GetName());
+  EXPECT_TRUE(StartsWith(actual_thread_name, expected_thread_name,
+                         CompareCase::SENSITIVE));
+
+  size_t thread_index_in_pool = std::numeric_limits<size_t>::max();
+  EXPECT_TRUE(base::StringToSizeT(
+      StringPiece(actual_thread_name).substr(expected_thread_name.size()),
+      &thread_index_in_pool));
+  if (traits.priority() == TaskPriority::BACKGROUND) {

[fdoray, 2016/05/04 19:04:32]

I would remove lines 101-109 because we shouldn't have to update this test when
we update the number of threads per pool.

Maybe verifying that the thread name contains the string passed in
TaskSchedulerImpl::Initialize would be enough (the rest is an implementation
detail).

[gab, 2016/05/04 21:00:02]

Done.

+    EXPECT_EQ(0U, thread_index_in_pool);
+  } else if (traits.priority() == TaskPriority::BACKGROUND) {
+    EXPECT_GE(thread_index_in_pool, 0U);
+    EXPECT_LT(thread_index_in_pool, 4U);
+  } else {
+    EXPECT_GE(thread_index_in_pool, 0U);
+    EXPECT_LT(thread_index_in_pool, 12U);
+  }
 }
 
 void VerifyTaskEnvironementAndSignalEvent(const TaskTraits& traits,
                                           WaitableEvent* event) {
   DCHECK(event);
   VerifyTaskEnvironement(traits);
   event->Signal();
 }
 
 class ThreadPostingTasks : public SimpleThread {
@@ skipping 109 matching lines @@
   }
 
   scheduler->JoinForTesting();
 }
 
 // TODO(fdoray): Add tests with Sequences that move around thread pools once
 // child TaskRunners are supported.
 
 }  // namespace internal
 }  // namespace base