Migrate flutter_runner from flutter_runner::{Thread,Loop} to

fml::{Thread,MessageLoop}

Author: George Wright

fml/message_loop.cc

@@ -80,5 +80,4 @@ TaskQueueId MessageLoop::GetCurrentTaskQueueId() {
          "this thread prior to message loop use.";
   return loop->GetLoopImpl()->GetTaskQueueId();
 }
-
 }  // namespace fml

fml/message_loop_impl.cc

@@ -145,4 +145,8 @@ TaskQueueId MessageLoopImpl::GetTaskQueueId() const {
   return queue_id_;
 }
 
+fml::RefPtr<MessageLoopImpl> MessageLoopImpl::GetLoopImpl(MessageLoop& message_loop) {
+  return message_loop.GetLoopImpl();
+}
+
 }  // namespace fml

fml/message_loop_impl.h

@@ -58,6 +58,8 @@ class MessageLoopImpl : public Wakeable,
  protected:
   MessageLoopImpl();
 
+  static fml::RefPtr<MessageLoopImpl> GetLoopImpl(MessageLoop& loop);
+
  private:
   fml::RefPtr<MessageLoopTaskQueues> task_queue_;
   TaskQueueId queue_id_;

fml/platform/fuchsia/message_loop_fuchsia.cc

@@ -35,4 +35,15 @@ void MessageLoopFuchsia::WakeUp(fml::TimePoint time_point) {
   FML_DCHECK(status == ZX_OK);
 }
 
+// TODO(gw280): This is needed in order to get the underlying async::Loop object to pass to other Fuchsia components,
+// such as the Trace component.
+async::Loop* MessageLoopFuchsia::FuchsiaLoopForMessageLoop(MessageLoop& message_loop) {
+  MessageLoopFuchsia* loop_impl = (MessageLoopFuchsia*)MessageLoopImpl::GetLoopImpl(message_loop).get();
+  return loop_impl->GetAsyncLoop();
+}
+
+async::Loop* MessageLoopFuchsia::GetAsyncLoop() {
+  return &loop_;
+}
+
 }  // namespace fml

fml/platform/fuchsia/message_loop_fuchsia.h

@@ -13,6 +13,9 @@
 namespace fml {
 
 class MessageLoopFuchsia : public MessageLoopImpl {
+ public:
+  static async::Loop* FuchsiaLoopForMessageLoop(MessageLoop& message_loop);
+
  private:
   MessageLoopFuchsia();
 
@@ -24,6 +27,8 @@ class MessageLoopFuchsia : public MessageLoopImpl {
 
   void WakeUp(fml::TimePoint time_point) override;
 
+  async::Loop* GetAsyncLoop();
+
   async::Loop loop_;
 
   FML_FRIEND_MAKE_REF_COUNTED(MessageLoopFuchsia);

fml/thread.cc

@@ -10,6 +10,8 @@
 
 #if defined(OS_WIN)
 #include <windows.h>
+#elif defined(OS_FUCHSIA)
+#include <lib/zx/thread.h>
 #else
 #include <pthread.h>
 #endif
@@ -85,6 +87,9 @@ void Thread::SetCurrentThreadName(const std::string& name) {
                    reinterpret_cast<DWORD_PTR*>(&info));
   } __except (EXCEPTION_CONTINUE_EXECUTION) {
   }
+#elif OS_FUCHSIA
+  zx::thread::self()->set_property(ZX_PROP_NAME, name.c_str(),
+                                   name.size());
 #else
   FML_DLOG(INFO) << "Could not set the thread name to '" << name
                  << "' on this platform.";

shell/platform/fuchsia/flutter/BUILD.gn

@@ -303,8 +303,6 @@ executable("flutter_runner_unittests") {
     "fuchsia_intl.h",
     "fuchsia_intl_unittest.cc",
     "logging.h",
-    "loop.cc",
-    "loop.h",
     "platform_view.cc",
     "platform_view.h",
     "platform_view_unittest.cc",
@@ -317,8 +315,6 @@ executable("flutter_runner_unittests") {
     "task_observers.h",
     "task_runner_adapter.cc",
     "task_runner_adapter.h",
-    "thread.cc",
-    "thread.h",
     "vsync_recorder.cc",
     "vsync_recorder.h",
     "vsync_waiter.cc",

shell/platform/fuchsia/flutter/component.cc

@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#define FML_USED_ON_EMBEDDER
+
 #include "component.h"
 
 #include <dlfcn.h>
@@ -37,7 +39,6 @@
 
 #include "task_observers.h"
 #include "task_runner_adapter.h"
-#include "thread.h"
 
 // TODO(kaushikiska): Use these constants from ::llcpp::fuchsia::io
 // Can read from target object.
@@ -58,11 +59,11 @@ ActiveApplication Application::Create(
     fuchsia::sys::StartupInfo startup_info,
     std::shared_ptr<sys::ServiceDirectory> runner_incoming_services,
     fidl::InterfaceRequest<fuchsia::sys::ComponentController> controller) {
-  std::unique_ptr<Thread> thread = std::make_unique<Thread>();
+  std::unique_ptr<fml::Thread> thread = std::make_unique<fml::Thread>();
   std::unique_ptr<Application> application;
 
   fml::AutoResetWaitableEvent latch;
-  async::PostTask(thread->dispatcher(), [&]() mutable {
+  fml::TaskRunner::RunNowOrPostTask(thread->GetTaskRunner(), [&]() mutable {
     application.reset(
         new Application(std::move(termination_callback), std::move(package),
                         std::move(startup_info), runner_incoming_services,
@@ -372,8 +373,7 @@ Application::Application(
 #endif  // defined(__aarch64__)
 
   auto weak_application = weak_factory_.GetWeakPtr();
-  auto platform_task_runner =
-      CreateFMLTaskRunner(async_get_default_dispatcher());
+  auto platform_task_runner = fml::MessageLoop::GetCurrent().GetTaskRunner();
   const std::string component_url = package.resolved_url;
   settings_.unhandled_exception_callback = [weak_application,
                                             platform_task_runner,

shell/platform/fuchsia/flutter/component.h

@@ -24,16 +24,16 @@
 #include "engine.h"
 #include "flutter/common/settings.h"
 #include "flutter/fml/macros.h"
+#include "flutter/fml/thread.h"
 
-#include "thread.h"
 #include "unique_fdio_ns.h"
 
 namespace flutter_runner {
 
 class Application;
 
 struct ActiveApplication {
-  std::unique_ptr<Thread> thread;
+  std::unique_ptr<fml::Thread> thread;
   std::unique_ptr<Application> application;
 
   ActiveApplication& operator=(ActiveApplication&& other) noexcept {

shell/platform/fuchsia/flutter/engine.cc

@@ -20,7 +20,6 @@
 #include "runtime/dart/utils/files.h"
 #include "task_runner_adapter.h"
 #include "third_party/skia/include/ports/SkFontMgr_fuchsia.h"
-#include "thread.h"
 
 namespace flutter_runner {
 
@@ -60,19 +59,16 @@ Engine::Engine(Delegate& delegate,
                fidl::InterfaceRequest<fuchsia::io::Directory> directory_request)
     : delegate_(delegate),
       thread_label_(std::move(thread_label)),
+      thread_host_(thread_label_ + ".",
+                    flutter::ThreadHost::Type::Platform | flutter::ThreadHost::Type::IO |
+                    flutter::ThreadHost::Type::UI | flutter::ThreadHost::Type::GPU),
       settings_(std::move(settings)),
       weak_factory_(this) {
   if (zx::event::create(0, &vsync_event_) != ZX_OK) {
     FML_DLOG(ERROR) << "Could not create the vsync event.";
     return;
   }
 
-  // Launch the threads that will be used to run the shell. These threads will
-  // be joined in the destructor.
-  for (auto& thread : threads_) {
-    thread.reset(new Thread());
-  }
-
   // Set up the session connection.
   auto scenic = svc->Connect<fuchsia::ui::scenic::Scenic>();
   fidl::InterfaceHandle<fuchsia::ui::scenic::Session> session;
@@ -169,10 +165,10 @@ Engine::Engine(Delegate& delegate,
   // used as the "platform" thread.
   const flutter::TaskRunners task_runners(
       thread_label_,  // Dart thread labels
-      CreateFMLTaskRunner(async_get_default_dispatcher()),  // platform
-      CreateFMLTaskRunner(threads_[0]->dispatcher()),       // gpu
-      CreateFMLTaskRunner(threads_[1]->dispatcher()),       // ui
-      CreateFMLTaskRunner(threads_[2]->dispatcher())        // io
+      thread_host_.platform_thread->GetTaskRunner(),  // platform
+      thread_host_.gpu_thread->GetTaskRunner(),       // gpu
+      thread_host_.ui_thread->GetTaskRunner(),       // ui
+      thread_host_.io_thread->GetTaskRunner()        // io
   );
 
   // Setup the callback that will instantiate the rasterizer.
@@ -352,12 +348,6 @@ Engine::Engine(Delegate& delegate,
 
 Engine::~Engine() {
   shell_.reset();
-  for (const auto& thread : threads_) {
-    thread->Quit();
-  }
-  for (const auto& thread : threads_) {
-    thread->Join();
-  }
 }
 
 std::pair<bool, uint32_t> Engine::GetEngineReturnCode() const {