Split out the thread data and the thread data set operator

Author: JsouLiang

fml/thread.cc

@@ -24,26 +24,22 @@
 
 namespace fml {
 
-Thread::ThreadConfig::ThreadConfig(const std::string& name,
-                                   ThreadPriority priority)
-    : thread_name_(name), thread_priority_(priority) {}
-
-void Thread::ThreadConfig::SetCurrentThreadName() const {
-  Thread::SetCurrentThreadName(thread_name_);
+void Thread::ThreadConfigSetter::set(const ThreadConfig& config) const {
+  Thread::SetCurrentThreadName(config.name);
 }
 
-void Thread::ThreadConfig::SetCurrentThreadPriority() const {}
-
 Thread::Thread(const std::string& name)
-    : Thread(ThreadConfig::MakeDefaultConfigure(name)) {}
+    : Thread(Thread::ThreadConfigSetter::MakeDefaultConfigurerSetter(),
+             ThreadConfig(name)) {}
 
-Thread::Thread(std::unique_ptr<ThreadConfig> config) : joined_(false) {
+Thread::Thread(std::shared_ptr<ThreadConfigSetter> setter,
+               const ThreadConfig& config)
+    : joined_(false) {
   fml::AutoResetWaitableEvent latch;
   fml::RefPtr<fml::TaskRunner> runner;
   thread_ = std::make_unique<std::thread>(
-      [&latch, &runner, threadConfig = std::move(config)]() -> void {
-        threadConfig->SetCurrentThreadName();
-        threadConfig->SetCurrentThreadPriority();
+      [&latch, &runner, setter, config]() -> void {
+        setter->set(config);
         fml::MessageLoop::EnsureInitializedForCurrentThread();
         auto& loop = MessageLoop::GetCurrent();
         runner = loop.GetTaskRunner();

fml/thread.h

@@ -29,40 +29,38 @@ class Thread {
     RASTER,
   };
 
-  /// The ThreadConfig is used for setting thread perorities.
-  class ThreadConfig {
-   public:
-    explicit ThreadConfig(const std::string& name = "",
-                          ThreadPriority priority = ThreadPriority::NORMAL);
-
-    static std::unique_ptr<ThreadConfig> MakeDefaultConfigure(
-        const std::string& name = "") {
-      return std::make_unique<ThreadConfig>(name);
-    }
+  /// The ThreadConfig is the thread info include thread name, thread priority.
+  struct ThreadConfig {
+    ThreadConfig(const std::string& name, ThreadPriority priority)
+        : name(name), priority(priority) {}
 
-    ThreadPriority GetThreadPriority() const { return thread_priority_; }
+    explicit ThreadConfig(const std::string& name)
+        : ThreadConfig(name, ThreadPriority::NORMAL) {}
 
-    const std::string& GetThreadName() const { return thread_name_; }
+    ThreadConfig() : ThreadConfig("", ThreadPriority::NORMAL) {}
 
-    /// Set current thread name.
-    virtual void SetCurrentThreadName() const;
+    std::string name;
+    ThreadPriority priority;
+  };
 
-    /// default do nothing, which mean user can use platform api to set priority
-    /// example: iOS might use pthread_qos set thread priority, Android might
-    /// use ::setPriority set thread priority
-    virtual void SetCurrentThreadPriority() const;
+  class ThreadConfigSetter {
+   public:
+    /// Use the ThreadConfig info to set thread priorities.
+    /// The default set method has implement set thread name logic.
+    virtual void set(const ThreadConfig& config) const;
 
-    virtual ~ThreadConfig() = default;
+    /// Make a default thread config setter, it can only set the thread name
+    static std::shared_ptr<ThreadConfigSetter> MakeDefaultConfigurerSetter() {
+      return std::make_shared<ThreadConfigSetter>();
+    }
 
-   private:
-    const std::string thread_name_;
-    ThreadPriority thread_priority_;
+    virtual ~ThreadConfigSetter() = default;
   };
 
-  explicit Thread(const std::string& name);
+  explicit Thread(const std::string& name = "");
 
-  explicit Thread(std::unique_ptr<ThreadConfig> config =
-                      ThreadConfig::MakeDefaultConfigure());
+  explicit Thread(std::shared_ptr<ThreadConfigSetter> setter,
+                  const ThreadConfig& config = ThreadConfig());
 
   ~Thread();
 
@@ -74,7 +72,9 @@ class Thread {
 
  private:
   std::unique_ptr<std::thread> thread_;
+
   fml::RefPtr<fml::TaskRunner> task_runner_;
+
   std::atomic_bool joined_;
 
   FML_DISALLOW_COPY_AND_ASSIGN(Thread);

fml/thread_unittests.cc

@@ -4,13 +4,15 @@
 
 #include "flutter/fml/thread.h"
 
-#define FLUTTER_PTHREAD_SUPPORTED \
-  defined(OS_MACOSX) || defined(OS_LINUX) || defined(OS_ANDROID)
+#if defined(OS_MACOSX) || defined(OS_LINUX) || defined(OS_ANDROID)
+#define FLUTTER_PTHREAD_SUPPORTED 1
+#else
+#define FLUTTER_PTHREAD_SUPPORTED 0
+#endif
 
-#ifdef FLUTTER_PTHREAD_SUPPORTED
+#if FLUTTER_PTHREAD_SUPPORTED
 #include <pthread.h>
 #else
-#error "Doesn't has pthead.h"
 #endif
 
 #include <memory>
@@ -35,33 +37,35 @@ TEST(Thread, HasARunningMessageLoop) {
   ASSERT_TRUE(done);
 }
 
-#ifdef FLUTTER_PTHREAD_SUPPORTED
+#if FLUTTER_PTHREAD_SUPPORTED
 TEST(Thread, ThreadNameCreatedWithConfig) {
   const std::string name = "Thread1";
-  fml::Thread thread(fml::Thread::ThreadConfig::MakeDefaultConfigure(name));
+  fml::Thread thread(name);
 
   bool done = false;
-  constexpr int NAMELEN = 8;
   thread.GetTaskRunner()->PostTask([&done, &name]() {
     done = true;
-    char thread_name[NAMELEN];
+    char thread_name[8];
     pthread_t current_thread = pthread_self();
-    pthread_getname_np(current_thread, thread_name, NAMELEN);
+    pthread_getname_np(current_thread, thread_name, 8);
     ASSERT_EQ(thread_name, name);
   });
   thread.Join();
   ASSERT_TRUE(done);
 }
 
-class MockThreadConfig : public fml::Thread::ThreadConfig {
+class MockThreadConfigSetter : public fml::Thread::ThreadConfigSetter {
  public:
-  using fml::Thread::ThreadConfig::ThreadConfig;
+  using fml::Thread::ThreadConfigSetter::ThreadConfigSetter;
+
+  void set(const fml::Thread::ThreadConfig& config) const override {
+    // set thread name
+    fml::Thread::ThreadConfigSetter::set(config);
 
-  void SetCurrentThreadPriority() const override {
     pthread_t tid = pthread_self();
     struct sched_param param;
     int policy = SCHED_OTHER;
-    switch (GetThreadPriority()) {
+    switch (config.priority) {
       case fml::Thread::ThreadPriority::DISPLAY:
         param.sched_priority = 10;
         break;
@@ -75,31 +79,33 @@ class MockThreadConfig : public fml::Thread::ThreadConfig {
 TEST(Thread, ThreadPriorityCreatedWithConfig) {
   const std::string thread1_name = "Thread1";
   const std::string thread2_name = "Thread2";
-  fml::Thread thread(std::make_unique<MockThreadConfig>(
-      thread1_name, fml::Thread::ThreadPriority::NORMAL));
 
+  fml::Thread thread(std::make_shared<MockThreadConfigSetter>(),
+                     fml::Thread::ThreadConfig(
+                         thread1_name, fml::Thread::ThreadPriority::NORMAL));
   bool done = false;
-  constexpr int NAMELEN = 8;
+
   struct sched_param param;
   int policy;
   thread.GetTaskRunner()->PostTask([&]() {
     done = true;
-    char thread_name[NAMELEN];
+    char thread_name[8];
     pthread_t current_thread = pthread_self();
-    pthread_getname_np(current_thread, thread_name, NAMELEN);
+    pthread_getname_np(current_thread, thread_name, 8);
     pthread_getschedparam(current_thread, &policy, &param);
     ASSERT_EQ(thread_name, thread1_name);
     ASSERT_EQ(policy, SCHED_OTHER);
     ASSERT_EQ(param.sched_priority, 1);
   });
 
-  fml::Thread thread2(std::make_unique<MockThreadConfig>(
-      thread2_name, fml::Thread::ThreadPriority::DISPLAY));
+  fml::Thread thread2(std::make_shared<MockThreadConfigSetter>(),
+                      fml::Thread::ThreadConfig(
+                          thread2_name, fml::Thread::ThreadPriority::DISPLAY));
   thread2.GetTaskRunner()->PostTask([&]() {
     done = true;
-    char thread_name[NAMELEN];
+    char thread_name[8];
     pthread_t current_thread = pthread_self();
-    pthread_getname_np(current_thread, thread_name, NAMELEN);
+    pthread_getname_np(current_thread, thread_name, 8);
     pthread_getschedparam(current_thread, &policy, &param);
     ASSERT_EQ(thread_name, thread2_name);
     ASSERT_EQ(policy, SCHED_OTHER);

lib/ui/ui_benchmarks.cc

@@ -20,9 +20,9 @@ class Fixture : public testing::FixtureTest {
 };
 
 static void BM_PlatformMessageResponseDartComplete(benchmark::State& state) {
-  ThreadHost thread_host("test",
-                         ThreadHost::Type::Platform | ThreadHost::Type::RASTER |
-                             ThreadHost::Type::IO | ThreadHost::Type::UI);
+  ThreadHost thread_host(ThreadHost::ThreadHostConfig(
+      "test", ThreadHost::Type::Platform | ThreadHost::Type::RASTER |
+                  ThreadHost::Type::IO | ThreadHost::Type::UI));
   TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
                            thread_host.raster_thread->GetTaskRunner(),
                            thread_host.ui_thread->GetTaskRunner(),
@@ -68,9 +68,9 @@ static void BM_PlatformMessageResponseDartComplete(benchmark::State& state) {
 }
 
 static void BM_PathVolatilityTracker(benchmark::State& state) {
-  ThreadHost thread_host("test",
-                         ThreadHost::Type::Platform | ThreadHost::Type::RASTER |
-                             ThreadHost::Type::IO | ThreadHost::Type::UI);
+  ThreadHost thread_host(ThreadHost::ThreadHostConfig(
+      "test", ThreadHost::Type::Platform | ThreadHost::Type::RASTER |
+                  ThreadHost::Type::IO | ThreadHost::Type::UI));
   TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
                            thread_host.raster_thread->GetTaskRunner(),
                            thread_host.ui_thread->GetTaskRunner(),

shell/common/shell_benchmarks.cc

@@ -43,10 +43,10 @@ static void StartupAndShutdownShell(benchmark::State& state,
       };
     }
 
-    thread_host = std::make_unique<ThreadHost>(
+    thread_host = std::make_unique<ThreadHost>(ThreadHost::ThreadHostConfig(
         "io.flutter.bench.", ThreadHost::Type::Platform |
                                  ThreadHost::Type::RASTER |
-                                 ThreadHost::Type::IO | ThreadHost::Type::UI);
+                                 ThreadHost::Type::IO | ThreadHost::Type::UI));
 
     TaskRunners task_runners("test",
                              thread_host->platform_thread->GetTaskRunner(),

shell/common/shell_unittests.cc

@@ -264,9 +264,10 @@ TEST_F(ShellTest, InitializeWithInvalidThreads) {
 TEST_F(ShellTest, InitializeWithDifferentThreads) {
   ASSERT_FALSE(DartVMRef::IsInstanceRunning());
   Settings settings = CreateSettingsForFixture();
-  ThreadHost thread_host("io.flutter.test." + GetCurrentTestName() + ".",
-                         ThreadHost::Type::Platform | ThreadHost::Type::RASTER |
-                             ThreadHost::Type::IO | ThreadHost::Type::UI);
+  ThreadHost thread_host(ThreadHost::ThreadHostConfig(
+      "io.flutter.test." + GetCurrentTestName() + ".",
+      ThreadHost::Type::Platform | ThreadHost::Type::RASTER |
+          ThreadHost::Type::IO | ThreadHost::Type::UI));
   TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
                            thread_host.raster_thread->GetTaskRunner(),
                            thread_host.ui_thread->GetTaskRunner(),
@@ -3112,8 +3113,9 @@ TEST_F(ShellTest, UpdateAssetResolverByTypeAppends) {
 TEST_F(ShellTest, UpdateAssetResolverByTypeNull) {
   ASSERT_FALSE(DartVMRef::IsInstanceRunning());
   Settings settings = CreateSettingsForFixture();
-  ThreadHost thread_host("io.flutter.test." + GetCurrentTestName() + ".",
-                         ThreadHost::Type::Platform);
+  ThreadHost thread_host(ThreadHost::ThreadHostConfig(
+      "io.flutter.test." + GetCurrentTestName() + ".",
+      ThreadHost::Type::Platform));
   auto task_runner = thread_host.platform_thread->GetTaskRunner();
   TaskRunners task_runners("test", task_runner, task_runner, task_runner,
                            task_runner);
@@ -3149,8 +3151,9 @@ TEST_F(ShellTest, UpdateAssetResolverByTypeNull) {
 TEST_F(ShellTest, UpdateAssetResolverByTypeDoesNotReplaceMismatchType) {
   ASSERT_FALSE(DartVMRef::IsInstanceRunning());
   Settings settings = CreateSettingsForFixture();
-  ThreadHost thread_host("io.flutter.test." + GetCurrentTestName() + ".",
-                         ThreadHost::Type::Platform);
+  ThreadHost thread_host(ThreadHost::ThreadHostConfig(
+      "io.flutter.test." + GetCurrentTestName() + ".",
+      ThreadHost::Type::Platform));
   auto task_runner = thread_host.platform_thread->GetTaskRunner();
   TaskRunners task_runners("test", task_runner, task_runner, task_runner,
                            task_runner);

shell/common/thread_host.cc

@@ -6,6 +6,7 @@
 
 #include <algorithm>
 #include <memory>
+#include <optional>
 #include <string>
 #include <utility>
 
@@ -30,49 +31,46 @@ std::string ThreadHost::ThreadHostConfig::MakeThreadName(
 
 std::unique_ptr<fml::Thread> ThreadHost::CreateThread(
     Type type,
-    ThreadHost::ThreadConfig configure) {
-  std::string name = ThreadHostConfig::MakeThreadName(type, name_prefix);
-  if (configure != nullptr) {
-    return std::make_unique<fml::Thread>(std::move(configure));
+    std::optional<ThreadConfig> thread_config,
+    const ThreadHostConfig& host_config) const {
+  /// if not specified ThreadConfig, create a ThreadConfig.
+  if (!thread_config.has_value()) {
+    thread_config = ThreadConfig(
+        ThreadHostConfig::MakeThreadName(type, host_config.name_prefix));
   }
-  return std::make_unique<fml::Thread>(
-      fml::Thread::ThreadConfig::MakeDefaultConfigure(name));
+  return std::make_unique<fml::Thread>(host_config.config_setter,
+                                       thread_config.value());
 }
 
 ThreadHost::ThreadHost() = default;
 
 ThreadHost::ThreadHost(ThreadHost&&) = default;
 
-ThreadHost::ThreadHost(std::string name_prefix_arg,
-                       uint64_t mask,
-                       ThreadHostConfig configure_host)
-    : name_prefix(name_prefix_arg) {
-  if (mask & ThreadHost::Type::Platform) {
+ThreadHost::ThreadHost(const std::string name_prefix, uint64_t mask)
+    : ThreadHost(ThreadHostConfig(name_prefix, mask)) {}
+
+ThreadHost::ThreadHost(const ThreadHostConfig& host_config) {
+  if (host_config.isNeedThread(ThreadHost::Type::Platform)) {
     platform_thread =
-        CreateThread(ThreadHost::Type::Platform,
-                     std::move(configure_host.platform_configure));
+        CreateThread(Type::Platform, host_config.platform_config, host_config);
   }
 
-  if (mask & ThreadHost::Type::UI) {
-    ui_thread = CreateThread(ThreadHost::Type::UI,
-                             std::move(configure_host.ui_configure));
+  if (host_config.isNeedThread(ThreadHost::Type::UI)) {
+    ui_thread = CreateThread(Type::UI, host_config.ui_config, host_config);
   }
 
-  if (mask & ThreadHost::Type::RASTER) {
-    raster_thread = CreateThread(ThreadHost::Type::RASTER,
-                                 std::move(configure_host.raster_configure));
+  if (host_config.isNeedThread(ThreadHost::Type::RASTER)) {
+    raster_thread =
+        CreateThread(Type::RASTER, host_config.raster_config, host_config);
   }
 
-  if (mask & ThreadHost::Type::IO) {
-    io_thread = CreateThread(ThreadHost::Type::IO,
-                             std::move(configure_host.io_configure));
+  if (host_config.isNeedThread(ThreadHost::Type::IO)) {
+    io_thread = CreateThread(Type::IO, host_config.io_config, host_config);
   }
 
-  if (mask & ThreadHost::Type::Profiler) {
+  if (host_config.isNeedThread(ThreadHost::Type::Profiler)) {
     profiler_thread =
-        CreateThread(ThreadHost::Type::Profiler,
-                     std::move(configure_host.profiler_configure));
-    ;
+        CreateThread(Type::Profiler, host_config.profiler_config, host_config);
   }
 }