More rename from GPU thread to raster thread (#17408)

This PR touches variable names, class names, and file names so it's significantly more risky than its predecessor https://github.com/flutter/engine/pull/17329

Due to file name changes, this PR is expected to change the license files.

We haven't rename `shell/gpu` to `shell/raster` yet. It should be optional but I think it's better to have `raster_surface_software.cc` than `gpu_surface_software.cc`.

ci/licenses_golden/licenses_flutter

@@ -134,9 +134,6 @@ FILE: ../../../flutter/fml/eintr_wrapper.h
 FILE: ../../../flutter/fml/file.cc
 FILE: ../../../flutter/fml/file.h
 FILE: ../../../flutter/fml/file_unittest.cc
-FILE: ../../../flutter/fml/gpu_thread_merger.cc
-FILE: ../../../flutter/fml/gpu_thread_merger.h
-FILE: ../../../flutter/fml/gpu_thread_merger_unittests.cc
 FILE: ../../../flutter/fml/hash_combine.h
 FILE: ../../../flutter/fml/hash_combine_unittests.cc
 FILE: ../../../flutter/fml/icu_util.cc
@@ -229,6 +226,9 @@ FILE: ../../../flutter/fml/platform/win/paths_win.cc
 FILE: ../../../flutter/fml/platform/win/posix_wrappers_win.cc
 FILE: ../../../flutter/fml/platform/win/wstring_conversion.h
 FILE: ../../../flutter/fml/posix_wrappers.h
+FILE: ../../../flutter/fml/raster_thread_merger.cc
+FILE: ../../../flutter/fml/raster_thread_merger.h
+FILE: ../../../flutter/fml/raster_thread_merger_unittests.cc
 FILE: ../../../flutter/fml/size.h
 FILE: ../../../flutter/fml/status.h
 FILE: ../../../flutter/fml/synchronization/atomic_object.h

common/task_runners.cc

@@ -10,12 +10,12 @@ namespace flutter {
 
 TaskRunners::TaskRunners(std::string label,
                          fml::RefPtr<fml::TaskRunner> platform,
-                         fml::RefPtr<fml::TaskRunner> gpu,
+                         fml::RefPtr<fml::TaskRunner> raster,
                          fml::RefPtr<fml::TaskRunner> ui,
                          fml::RefPtr<fml::TaskRunner> io)
     : label_(std::move(label)),
       platform_(std::move(platform)),
-      gpu_(std::move(gpu)),
+      raster_(std::move(raster)),
       ui_(std::move(ui)),
       io_(std::move(io)) {}
 
@@ -39,12 +39,12 @@ fml::RefPtr<fml::TaskRunner> TaskRunners::GetIOTaskRunner() const {
   return io_;
 }
 
-fml::RefPtr<fml::TaskRunner> TaskRunners::GetGPUTaskRunner() const {
-  return gpu_;
+fml::RefPtr<fml::TaskRunner> TaskRunners::GetRasterTaskRunner() const {
+  return raster_;
 }
 
 bool TaskRunners::IsValid() const {
-  return platform_ && gpu_ && ui_ && io_;
+  return platform_ && raster_ && ui_ && io_;
 }
 
 }  // namespace flutter

common/task_runners.h

@@ -16,7 +16,7 @@ class TaskRunners {
  public:
   TaskRunners(std::string label,
               fml::RefPtr<fml::TaskRunner> platform,
-              fml::RefPtr<fml::TaskRunner> gpu,
+              fml::RefPtr<fml::TaskRunner> raster,
               fml::RefPtr<fml::TaskRunner> ui,
               fml::RefPtr<fml::TaskRunner> io);
 
@@ -32,14 +32,14 @@ class TaskRunners {
 
   fml::RefPtr<fml::TaskRunner> GetIOTaskRunner() const;
 
-  fml::RefPtr<fml::TaskRunner> GetGPUTaskRunner() const;
+  fml::RefPtr<fml::TaskRunner> GetRasterTaskRunner() const;
 
   bool IsValid() const;
 
  private:
   const std::string label_;
   fml::RefPtr<fml::TaskRunner> platform_;
-  fml::RefPtr<fml::TaskRunner> gpu_;
+  fml::RefPtr<fml::TaskRunner> raster_;
   fml::RefPtr<fml::TaskRunner> ui_;
   fml::RefPtr<fml::TaskRunner> io_;
 };

flow/compositor_context.cc

@@ -37,10 +37,10 @@ std::unique_ptr<CompositorContext::ScopedFrame> CompositorContext::AcquireFrame(
     const SkMatrix& root_surface_transformation,
     bool instrumentation_enabled,
     bool surface_supports_readback,
-    fml::RefPtr<fml::GpuThreadMerger> gpu_thread_merger) {
+    fml::RefPtr<fml::RasterThreadMerger> raster_thread_merger) {
   return std::make_unique<ScopedFrame>(
       *this, gr_context, canvas, view_embedder, root_surface_transformation,
-      instrumentation_enabled, surface_supports_readback, gpu_thread_merger);
+      instrumentation_enabled, surface_supports_readback, raster_thread_merger);
 }
 
 CompositorContext::ScopedFrame::ScopedFrame(
@@ -51,7 +51,7 @@ CompositorContext::ScopedFrame::ScopedFrame(
     const SkMatrix& root_surface_transformation,
     bool instrumentation_enabled,
     bool surface_supports_readback,
-    fml::RefPtr<fml::GpuThreadMerger> gpu_thread_merger)
+    fml::RefPtr<fml::RasterThreadMerger> raster_thread_merger)
     : context_(context),
       gr_context_(gr_context),
       canvas_(canvas),
@@ -59,7 +59,7 @@ CompositorContext::ScopedFrame::ScopedFrame(
       root_surface_transformation_(root_surface_transformation),
       instrumentation_enabled_(instrumentation_enabled),
       surface_supports_readback_(surface_supports_readback),
-      gpu_thread_merger_(gpu_thread_merger) {
+      raster_thread_merger_(raster_thread_merger) {
   context_.BeginFrame(*this, instrumentation_enabled_);
 }
 
@@ -74,8 +74,9 @@ RasterStatus CompositorContext::ScopedFrame::Raster(
   bool root_needs_readback = layer_tree.Preroll(*this, ignore_raster_cache);
   bool needs_save_layer = root_needs_readback && !surface_supports_readback();
   PostPrerollResult post_preroll_result = PostPrerollResult::kSuccess;
-  if (view_embedder_ && gpu_thread_merger_) {
-    post_preroll_result = view_embedder_->PostPrerollAction(gpu_thread_merger_);
+  if (view_embedder_ && raster_thread_merger_) {
+    post_preroll_result =
+        view_embedder_->PostPrerollAction(raster_thread_merger_);
   }
 
   if (post_preroll_result == PostPrerollResult::kResubmitFrame) {

flow/compositor_context.h

@@ -12,8 +12,8 @@
 #include "flutter/flow/instrumentation.h"
 #include "flutter/flow/raster_cache.h"
 #include "flutter/flow/texture.h"
-#include "flutter/fml/gpu_thread_merger.h"
 #include "flutter/fml/macros.h"
+#include "flutter/fml/raster_thread_merger.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkPictureRecorder.h"
 
@@ -46,7 +46,7 @@ class CompositorContext {
                 const SkMatrix& root_surface_transformation,
                 bool instrumentation_enabled,
                 bool surface_supports_readback,
-                fml::RefPtr<fml::GpuThreadMerger> gpu_thread_merger);
+                fml::RefPtr<fml::RasterThreadMerger> raster_thread_merger);
 
     virtual ~ScopedFrame();
 
@@ -75,7 +75,7 @@ class CompositorContext {
     const SkMatrix& root_surface_transformation_;
     const bool instrumentation_enabled_;
     const bool surface_supports_readback_;
-    fml::RefPtr<fml::GpuThreadMerger> gpu_thread_merger_;
+    fml::RefPtr<fml::RasterThreadMerger> raster_thread_merger_;
 
     FML_DISALLOW_COPY_AND_ASSIGN(ScopedFrame);
   };
@@ -91,7 +91,7 @@ class CompositorContext {
       const SkMatrix& root_surface_transformation,
       bool instrumentation_enabled,
       bool surface_supports_readback,
-      fml::RefPtr<fml::GpuThreadMerger> gpu_thread_merger);
+      fml::RefPtr<fml::RasterThreadMerger> raster_thread_merger);
 
   void OnGrContextCreated();
 

flow/embedded_views.h

@@ -7,8 +7,8 @@
 
 #include <vector>
 
-#include "flutter/fml/gpu_thread_merger.h"
 #include "flutter/fml/memory/ref_counted.h"
+#include "flutter/fml/raster_thread_merger.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkPath.h"
 #include "third_party/skia/include/core/SkPoint.h"
@@ -239,7 +239,7 @@ class ExternalViewEmbedder {
   // after it does any requisite tasks needed to bring itself to a valid state.
   // Returns kSuccess if the view embedder is already in a valid state.
   virtual PostPrerollResult PostPrerollAction(
-      fml::RefPtr<fml::GpuThreadMerger> gpu_thread_merger) {
+      fml::RefPtr<fml::RasterThreadMerger> raster_thread_merger) {
     return PostPrerollResult::kSuccess;
   }
 

fml/BUILD.gn

@@ -27,8 +27,6 @@ source_set("fml") {
     "eintr_wrapper.h",
     "file.cc",
     "file.h",
-    "gpu_thread_merger.cc",
-    "gpu_thread_merger.h",
     "hash_combine.h",
     "icu_util.cc",
     "icu_util.h",
@@ -61,6 +59,8 @@ source_set("fml") {
     "paths.cc",
     "paths.h",
     "posix_wrappers.h",
+    "raster_thread_merger.cc",
+    "raster_thread_merger.h",
     "size.h",
     "synchronization/atomic_object.h",
     "synchronization/count_down_latch.cc",
@@ -232,7 +232,6 @@ executable("fml_unittests") {
     "base32_unittest.cc",
     "command_line_unittest.cc",
     "file_unittest.cc",
-    "gpu_thread_merger_unittests.cc",
     "hash_combine_unittests.cc",
     "memory/ref_counted_unittest.cc",
     "memory/weak_ptr_unittest.cc",
@@ -241,6 +240,7 @@ executable("fml_unittests") {
     "message_loop_unittests.cc",
     "message_unittests.cc",
     "paths_unittests.cc",
+    "raster_thread_merger_unittests.cc",
     "synchronization/count_down_latch_unittests.cc",
     "synchronization/semaphore_unittest.cc",
     "synchronization/sync_switch_unittest.cc",

fml/gpu_thread_merger.cc → fml/raster_thread_merger.cc

@@ -4,15 +4,15 @@
 
 #define FML_USED_ON_EMBEDDER
 
-#include "flutter/fml/gpu_thread_merger.h"
+#include "flutter/fml/raster_thread_merger.h"
 #include "flutter/fml/message_loop_impl.h"
 
 namespace fml {
 
-const int GpuThreadMerger::kLeaseNotSet = -1;
+const int RasterThreadMerger::kLeaseNotSet = -1;
 
-GpuThreadMerger::GpuThreadMerger(fml::TaskQueueId platform_queue_id,
-                                 fml::TaskQueueId gpu_queue_id)
+RasterThreadMerger::RasterThreadMerger(fml::TaskQueueId platform_queue_id,
+                                       fml::TaskQueueId gpu_queue_id)
     : platform_queue_id_(platform_queue_id),
       gpu_queue_id_(gpu_queue_id),
       task_queues_(fml::MessageLoopTaskQueues::GetInstance()),
@@ -20,7 +20,7 @@ GpuThreadMerger::GpuThreadMerger(fml::TaskQueueId platform_queue_id,
   is_merged_ = task_queues_->Owns(platform_queue_id_, gpu_queue_id_);
 }
 
-void GpuThreadMerger::MergeWithLease(size_t lease_term) {
+void RasterThreadMerger::MergeWithLease(size_t lease_term) {
   FML_DCHECK(lease_term > 0) << "lease_term should be positive.";
   if (!is_merged_) {
     is_merged_ = task_queues_->Merge(platform_queue_id_, gpu_queue_id_);
@@ -28,7 +28,7 @@ void GpuThreadMerger::MergeWithLease(size_t lease_term) {
   }
 }
 
-bool GpuThreadMerger::IsOnRasterizingThread() {
+bool RasterThreadMerger::IsOnRasterizingThread() {
   const auto current_queue_id = MessageLoop::GetCurrentTaskQueueId();
   if (is_merged_) {
     return current_queue_id == platform_queue_id_;
@@ -37,25 +37,25 @@ bool GpuThreadMerger::IsOnRasterizingThread() {
   }
 }
 
-void GpuThreadMerger::ExtendLeaseTo(size_t lease_term) {
+void RasterThreadMerger::ExtendLeaseTo(size_t lease_term) {
   FML_DCHECK(lease_term > 0) << "lease_term should be positive.";
   if (lease_term_ != kLeaseNotSet && (int)lease_term > lease_term_) {
     lease_term_ = lease_term;
   }
 }
 
-bool GpuThreadMerger::IsMerged() const {
+bool RasterThreadMerger::IsMerged() const {
   return is_merged_;
 }
 
-GpuThreadStatus GpuThreadMerger::DecrementLease() {
+RasterThreadStatus RasterThreadMerger::DecrementLease() {
   if (!is_merged_) {
-    return GpuThreadStatus::kRemainsUnmerged;
+    return RasterThreadStatus::kRemainsUnmerged;
   }
 
   // we haven't been set to merge.
   if (lease_term_ == kLeaseNotSet) {
-    return GpuThreadStatus::kRemainsUnmerged;
+    return RasterThreadStatus::kRemainsUnmerged;
   }
 
   FML_DCHECK(lease_term_ > 0)
@@ -65,10 +65,10 @@ GpuThreadStatus GpuThreadMerger::DecrementLease() {
     bool success = task_queues_->Unmerge(platform_queue_id_);
     FML_CHECK(success) << "Unable to un-merge the GPU and platform threads.";
     is_merged_ = false;
-    return GpuThreadStatus::kUnmergedNow;
+    return RasterThreadStatus::kUnmergedNow;
   }
 
-  return GpuThreadStatus::kRemainsMerged;
+  return RasterThreadStatus::kRemainsMerged;
 }
 
 }  // namespace fml

fml/gpu_thread_merger.h → fml/raster_thread_merger.h

@@ -13,9 +13,14 @@ namespace fml {
 
 class MessageLoopImpl;
 
-enum class GpuThreadStatus { kRemainsMerged, kRemainsUnmerged, kUnmergedNow };
+enum class RasterThreadStatus {
+  kRemainsMerged,
+  kRemainsUnmerged,
+  kUnmergedNow
+};
 
-class GpuThreadMerger : public fml::RefCountedThreadSafe<GpuThreadMerger> {
+class RasterThreadMerger
+    : public fml::RefCountedThreadSafe<RasterThreadMerger> {
  public:
   // Merges the raster thread into platform thread for the duration of
   // the lease term. Lease is managed by the caller by either calling
@@ -27,14 +32,14 @@ class GpuThreadMerger : public fml::RefCountedThreadSafe<GpuThreadMerger> {
 
   void ExtendLeaseTo(size_t lease_term);
 
-  // Returns |GpuThreadStatus::kUnmergedNow| if this call resulted in splitting
-  // the GPU and platform threads. Reduces the lease term by 1.
-  GpuThreadStatus DecrementLease();
+  // Returns |RasterThreadStatus::kUnmergedNow| if this call resulted in
+  // splitting the GPU and platform threads. Reduces the lease term by 1.
+  RasterThreadStatus DecrementLease();
 
   bool IsMerged() const;
 
-  GpuThreadMerger(fml::TaskQueueId platform_queue_id,
-                  fml::TaskQueueId gpu_queue_id);
+  RasterThreadMerger(fml::TaskQueueId platform_queue_id,
+                     fml::TaskQueueId gpu_queue_id);
 
   // Returns true if the current thread owns rasterizing.
   // When the threads are merged, platform thread owns rasterizing.
@@ -49,9 +54,9 @@ class GpuThreadMerger : public fml::RefCountedThreadSafe<GpuThreadMerger> {
   std::atomic_int lease_term_;
   bool is_merged_;
 
-  FML_FRIEND_REF_COUNTED_THREAD_SAFE(GpuThreadMerger);
-  FML_FRIEND_MAKE_REF_COUNTED(GpuThreadMerger);
-  FML_DISALLOW_COPY_AND_ASSIGN(GpuThreadMerger);
+  FML_FRIEND_REF_COUNTED_THREAD_SAFE(RasterThreadMerger);
+  FML_FRIEND_MAKE_REF_COUNTED(RasterThreadMerger);
+  FML_DISALLOW_COPY_AND_ASSIGN(RasterThreadMerger);
 };
 
 }  // namespace fml

fml/gpu_thread_merger_unittests.cc → fml/raster_thread_merger_unittests.cc

@@ -7,14 +7,14 @@
 #include <atomic>
 #include <thread>
 
-#include "flutter/fml/gpu_thread_merger.h"
 #include "flutter/fml/message_loop.h"
+#include "flutter/fml/raster_thread_merger.h"
 #include "flutter/fml/synchronization/count_down_latch.h"
 #include "flutter/fml/synchronization/waitable_event.h"
 #include "flutter/fml/task_runner.h"
 #include "gtest/gtest.h"
 
-TEST(GpuThreadMerger, RemainMergedTillLeaseExpires) {
+TEST(RasterThreadMerger, RemainMergedTillLeaseExpires) {
   fml::MessageLoop* loop1 = nullptr;
   fml::AutoResetWaitableEvent latch1;
   fml::AutoResetWaitableEvent term1;
@@ -40,20 +40,20 @@ TEST(GpuThreadMerger, RemainMergedTillLeaseExpires) {
 
   fml::TaskQueueId qid1 = loop1->GetTaskRunner()->GetTaskQueueId();
   fml::TaskQueueId qid2 = loop2->GetTaskRunner()->GetTaskQueueId();
-  const auto gpu_thread_merger_ =
-      fml::MakeRefCounted<fml::GpuThreadMerger>(qid1, qid2);
+  const auto raster_thread_merger_ =
+      fml::MakeRefCounted<fml::RasterThreadMerger>(qid1, qid2);
   const int kNumFramesMerged = 5;
 
-  ASSERT_FALSE(gpu_thread_merger_->IsMerged());
+  ASSERT_FALSE(raster_thread_merger_->IsMerged());
 
-  gpu_thread_merger_->MergeWithLease(kNumFramesMerged);
+  raster_thread_merger_->MergeWithLease(kNumFramesMerged);
 
   for (int i = 0; i < kNumFramesMerged; i++) {
-    ASSERT_TRUE(gpu_thread_merger_->IsMerged());
-    gpu_thread_merger_->DecrementLease();
+    ASSERT_TRUE(raster_thread_merger_->IsMerged());
+    raster_thread_merger_->DecrementLease();
   }
 
-  ASSERT_FALSE(gpu_thread_merger_->IsMerged());
+  ASSERT_FALSE(raster_thread_merger_->IsMerged());
 
   term1.Signal();
   term2.Signal();
@@ -61,7 +61,7 @@ TEST(GpuThreadMerger, RemainMergedTillLeaseExpires) {
   thread2.join();
 }
 
-TEST(GpuThreadMerger, IsNotOnRasterizingThread) {
+TEST(RasterThreadMerger, IsNotOnRasterizingThread) {
   fml::MessageLoop* loop1 = nullptr;
   fml::AutoResetWaitableEvent latch1;
   std::thread thread1([&loop1, &latch1]() {
@@ -85,29 +85,29 @@ TEST(GpuThreadMerger, IsNotOnRasterizingThread) {
 
   fml::TaskQueueId qid1 = loop1->GetTaskRunner()->GetTaskQueueId();
   fml::TaskQueueId qid2 = loop2->GetTaskRunner()->GetTaskQueueId();
-  const auto gpu_thread_merger_ =
-      fml::MakeRefCounted<fml::GpuThreadMerger>(qid1, qid2);
+  const auto raster_thread_merger_ =
+      fml::MakeRefCounted<fml::RasterThreadMerger>(qid1, qid2);
 
   fml::CountDownLatch pre_merge(2), post_merge(2), post_unmerge(2);
 
   loop1->GetTaskRunner()->PostTask([&]() {
-    ASSERT_FALSE(gpu_thread_merger_->IsOnRasterizingThread());
+    ASSERT_FALSE(raster_thread_merger_->IsOnRasterizingThread());
     ASSERT_EQ(fml::MessageLoop::GetCurrentTaskQueueId(), qid1);
     pre_merge.CountDown();
   });
 
   loop2->GetTaskRunner()->PostTask([&]() {
-    ASSERT_TRUE(gpu_thread_merger_->IsOnRasterizingThread());
+    ASSERT_TRUE(raster_thread_merger_->IsOnRasterizingThread());
     ASSERT_EQ(fml::MessageLoop::GetCurrentTaskQueueId(), qid2);
     pre_merge.CountDown();
   });
 
   pre_merge.Wait();
 
-  gpu_thread_merger_->MergeWithLease(1);
+  raster_thread_merger_->MergeWithLease(1);
 
   loop1->GetTaskRunner()->PostTask([&]() {
-    ASSERT_TRUE(gpu_thread_merger_->IsOnRasterizingThread());
+    ASSERT_TRUE(raster_thread_merger_->IsOnRasterizingThread());
     ASSERT_EQ(fml::MessageLoop::GetCurrentTaskQueueId(), qid1);
     post_merge.CountDown();
   });
@@ -115,23 +115,23 @@ TEST(GpuThreadMerger, IsNotOnRasterizingThread) {
   loop2->GetTaskRunner()->PostTask([&]() {
     // this will be false since this is going to be run
     // on loop1 really.
-    ASSERT_TRUE(gpu_thread_merger_->IsOnRasterizingThread());
+    ASSERT_TRUE(raster_thread_merger_->IsOnRasterizingThread());
     ASSERT_EQ(fml::MessageLoop::GetCurrentTaskQueueId(), qid1);
     post_merge.CountDown();
   });
 
   post_merge.Wait();
 
-  gpu_thread_merger_->DecrementLease();
+  raster_thread_merger_->DecrementLease();
 
   loop1->GetTaskRunner()->PostTask([&]() {
-    ASSERT_FALSE(gpu_thread_merger_->IsOnRasterizingThread());
+    ASSERT_FALSE(raster_thread_merger_->IsOnRasterizingThread());
     ASSERT_EQ(fml::MessageLoop::GetCurrentTaskQueueId(), qid1);
     post_unmerge.CountDown();
   });
 
   loop2->GetTaskRunner()->PostTask([&]() {
-    ASSERT_TRUE(gpu_thread_merger_->IsOnRasterizingThread());
+    ASSERT_TRUE(raster_thread_merger_->IsOnRasterizingThread());
     ASSERT_EQ(fml::MessageLoop::GetCurrentTaskQueueId(), qid2);
     post_unmerge.CountDown();
   });
@@ -146,7 +146,7 @@ TEST(GpuThreadMerger, IsNotOnRasterizingThread) {
   thread2.join();
 }
 
-TEST(GpuThreadMerger, LeaseExtension) {
+TEST(RasterThreadMerger, LeaseExtension) {
   fml::MessageLoop* loop1 = nullptr;
   fml::AutoResetWaitableEvent latch1;
   fml::AutoResetWaitableEvent term1;
@@ -172,30 +172,30 @@ TEST(GpuThreadMerger, LeaseExtension) {
 
   fml::TaskQueueId qid1 = loop1->GetTaskRunner()->GetTaskQueueId();
   fml::TaskQueueId qid2 = loop2->GetTaskRunner()->GetTaskQueueId();
-  const auto gpu_thread_merger_ =
-      fml::MakeRefCounted<fml::GpuThreadMerger>(qid1, qid2);
+  const auto raster_thread_merger_ =
+      fml::MakeRefCounted<fml::RasterThreadMerger>(qid1, qid2);
   const int kNumFramesMerged = 5;
 
-  ASSERT_FALSE(gpu_thread_merger_->IsMerged());
+  ASSERT_FALSE(raster_thread_merger_->IsMerged());
 
-  gpu_thread_merger_->MergeWithLease(kNumFramesMerged);
+  raster_thread_merger_->MergeWithLease(kNumFramesMerged);
 
   // let there be one more turn till the leases expire.
   for (int i = 0; i < kNumFramesMerged - 1; i++) {
-    ASSERT_TRUE(gpu_thread_merger_->IsMerged());
-    gpu_thread_merger_->DecrementLease();
+    ASSERT_TRUE(raster_thread_merger_->IsMerged());
+    raster_thread_merger_->DecrementLease();
   }
 
   // extend the lease once.
-  gpu_thread_merger_->ExtendLeaseTo(kNumFramesMerged);
+  raster_thread_merger_->ExtendLeaseTo(kNumFramesMerged);
 
   // we will NOT last for 1 extra turn, we just set it.
   for (int i = 0; i < kNumFramesMerged; i++) {
-    ASSERT_TRUE(gpu_thread_merger_->IsMerged());
-    gpu_thread_merger_->DecrementLease();
+    ASSERT_TRUE(raster_thread_merger_->IsMerged());
+    raster_thread_merger_->DecrementLease();
   }
 
-  ASSERT_FALSE(gpu_thread_merger_->IsMerged());
+  ASSERT_FALSE(raster_thread_merger_->IsMerged());
 
   term1.Signal();
   term2.Signal();

lib/ui/compositing/scene_host.cc

@@ -162,8 +162,8 @@ SceneHost::SceneHost(fml::RefPtr<zircon::dart::Handle> viewHolderToken,
                      Dart_Handle viewConnectedCallback,
                      Dart_Handle viewDisconnectedCallback,
                      Dart_Handle viewStateChangedCallback)
-    : gpu_task_runner_(
-          UIDartState::Current()->GetTaskRunners().GetGPUTaskRunner()),
+    : raster_task_runner_(
+          UIDartState::Current()->GetTaskRunners().GetRasterTaskRunner()),
       koid_(GetKoid(viewHolderToken->handle())) {
   auto dart_state = UIDartState::Current();
   isolate_service_id_ = Dart_IsolateServiceId(Dart_CurrentIsolate());
@@ -190,7 +190,7 @@ SceneHost::SceneHost(fml::RefPtr<zircon::dart::Handle> viewHolderToken,
 
   // Pass the raw handle to the GPU thead; destroying a |zircon::dart::Handle|
   // on that thread can cause a race condition.
-  gpu_task_runner_->PostTask(
+  raster_task_runner_->PostTask(
       [id = koid_,
        ui_task_runner =
            UIDartState::Current()->GetTaskRunners().GetUITaskRunner(),
@@ -205,7 +205,7 @@ SceneHost::SceneHost(fml::RefPtr<zircon::dart::Handle> viewHolderToken,
 SceneHost::~SceneHost() {
   scene_host_bindings.erase(SceneHostBindingKey(koid_, isolate_service_id_));
 
-  gpu_task_runner_->PostTask(
+  raster_task_runner_->PostTask(
       [id = koid_]() { flutter::ViewHolder::Destroy(id); });
 }
 
@@ -220,8 +220,9 @@ void SceneHost::setProperties(double width,
                               double insetBottom,
                               double insetLeft,
                               bool focusable) {
-  gpu_task_runner_->PostTask([id = koid_, width, height, insetTop, insetRight,
-                              insetBottom, insetLeft, focusable]() {
+  raster_task_runner_->PostTask([id = koid_, width, height, insetTop,
+                                 insetRight, insetBottom, insetLeft,
+                                 focusable]() {
     auto* view_holder = flutter::ViewHolder::FromId(id);
     FML_DCHECK(view_holder);
 

lib/ui/compositing/scene_host.h

@@ -53,7 +53,7 @@ class SceneHost : public RefCountedDartWrappable<SceneHost> {
             Dart_Handle viewDisconnectedCallback,
             Dart_Handle viewStateChangedCallback);
 
-  fml::RefPtr<fml::TaskRunner> gpu_task_runner_;
+  fml::RefPtr<fml::TaskRunner> raster_task_runner_;
   tonic::DartPersistentValue view_connected_callback_;
   tonic::DartPersistentValue view_disconnected_callback_;
   tonic::DartPersistentValue view_state_changed_callback_;

lib/ui/painting/image_encoding.cc

@@ -83,7 +83,7 @@ sk_sp<SkImage> ConvertToRasterUsingResourceContext(
 
 void ConvertImageToRaster(sk_sp<SkImage> image,
                           std::function<void(sk_sp<SkImage>)> encode_task,
-                          fml::RefPtr<fml::TaskRunner> gpu_task_runner,
+                          fml::RefPtr<fml::TaskRunner> raster_task_runner,
                           fml::RefPtr<fml::TaskRunner> io_task_runner,
                           GrContext* resource_context,
                           fml::WeakPtr<SnapshotDelegate> snapshot_delegate) {
@@ -118,9 +118,9 @@ void ConvertImageToRaster(sk_sp<SkImage> image,
   // Cross-context images do not support makeRasterImage. Convert these images
   // by drawing them into a surface.  This must be done on the raster thread
   // to prevent concurrent usage of the image on both the IO and raster threads.
-  gpu_task_runner->PostTask([image, encode_task = std::move(encode_task),
-                             resource_context, snapshot_delegate,
-                             io_task_runner]() {
+  raster_task_runner->PostTask([image, encode_task = std::move(encode_task),
+                                resource_context, snapshot_delegate,
+                                io_task_runner]() {
     sk_sp<SkImage> raster_image =
         snapshot_delegate->ConvertToRasterImage(image);
 
@@ -210,7 +210,7 @@ void EncodeImageAndInvokeDataCallback(
     std::unique_ptr<DartPersistentValue> callback,
     ImageByteFormat format,
     fml::RefPtr<fml::TaskRunner> ui_task_runner,
-    fml::RefPtr<fml::TaskRunner> gpu_task_runner,
+    fml::RefPtr<fml::TaskRunner> raster_task_runner,
     fml::RefPtr<fml::TaskRunner> io_task_runner,
     GrContext* resource_context,
     fml::WeakPtr<SnapshotDelegate> snapshot_delegate) {
@@ -227,7 +227,7 @@ void EncodeImageAndInvokeDataCallback(
          encoded = std::move(encoded)] { callback_task(encoded); });
   };
 
-  ConvertImageToRaster(std::move(image), encode_task, gpu_task_runner,
+  ConvertImageToRaster(std::move(image), encode_task, raster_task_runner,
                        io_task_runner, resource_context, snapshot_delegate);
 }
 
@@ -252,14 +252,14 @@ Dart_Handle EncodeImage(CanvasImage* canvas_image,
   task_runners.GetIOTaskRunner()->PostTask(fml::MakeCopyable(
       [callback = std::move(callback), image = canvas_image->image(),
        image_format, ui_task_runner = task_runners.GetUITaskRunner(),
-       gpu_task_runner = task_runners.GetGPUTaskRunner(),
+       raster_task_runner = task_runners.GetRasterTaskRunner(),
        io_task_runner = task_runners.GetIOTaskRunner(),
        io_manager = UIDartState::Current()->GetIOManager(),
        snapshot_delegate =
            UIDartState::Current()->GetSnapshotDelegate()]() mutable {
         EncodeImageAndInvokeDataCallback(
             std::move(image), std::move(callback), image_format,
-            std::move(ui_task_runner), std::move(gpu_task_runner),
+            std::move(ui_task_runner), std::move(raster_task_runner),
             std::move(io_task_runner), io_manager->GetResourceContext().get(),
             std::move(snapshot_delegate));
       }));

lib/ui/painting/picture.cc

@@ -79,7 +79,7 @@ Dart_Handle Picture::RasterizeToImage(sk_sp<SkPicture> picture,
       new tonic::DartPersistentValue(dart_state, raw_image_callback);
   auto unref_queue = dart_state->GetSkiaUnrefQueue();
   auto ui_task_runner = dart_state->GetTaskRunners().GetUITaskRunner();
-  auto gpu_task_runner = dart_state->GetTaskRunners().GetGPUTaskRunner();
+  auto raster_task_runner = dart_state->GetTaskRunners().GetRasterTaskRunner();
   auto snapshot_delegate = dart_state->GetSnapshotDelegate();
 
   // We can't create an image on this task runner because we don't have a
@@ -117,7 +117,7 @@ Dart_Handle Picture::RasterizeToImage(sk_sp<SkPicture> picture,
 
   // Kick things off on the GPU.
   fml::TaskRunner::RunNowOrPostTask(
-      gpu_task_runner,
+      raster_task_runner,
       [ui_task_runner, snapshot_delegate, picture, picture_bounds, ui_task] {
         sk_sp<SkImage> raster_image =
             snapshot_delegate->MakeRasterSnapshot(picture, picture_bounds);

runtime/dart_isolate.cc

@@ -222,9 +222,9 @@ bool DartIsolate::UpdateThreadPoolNames() const {
   // shells sharing the same (or subset of) threads.
   const auto& task_runners = GetTaskRunners();
 
-  if (auto task_runner = task_runners.GetGPUTaskRunner()) {
+  if (auto task_runner = task_runners.GetRasterTaskRunner()) {
     task_runner->PostTask(
-        [label = task_runners.GetLabel() + std::string{".gpu"}]() {
+        [label = task_runners.GetLabel() + std::string{".raster"}]() {
           Dart_SetThreadName(label.c_str());
         });
   }
@@ -687,7 +687,7 @@ Dart_Isolate DartIsolate::DartIsolateGroupCreateCallback(
               parent_group_data.GetIsolateShutdownCallback())));
 
   TaskRunners null_task_runners(advisory_script_uri,
-                                /* platform= */ nullptr, /* gpu= */ nullptr,
+                                /* platform= */ nullptr, /* raster= */ nullptr,
                                 /* ui= */ nullptr,
                                 /* io= */ nullptr);
 
@@ -729,7 +729,7 @@ bool DartIsolate::DartIsolateInitializeCallback(void** child_callback_data,
           Dart_CurrentIsolateGroupData());
 
   TaskRunners null_task_runners((*isolate_group_data)->GetAdvisoryScriptURI(),
-                                /* platform= */ nullptr, /* gpu= */ nullptr,
+                                /* platform= */ nullptr, /* raster= */ nullptr,
                                 /* ui= */ nullptr,
                                 /* io= */ nullptr);
 

shell/common/animator.cc

@@ -36,7 +36,7 @@ Animator::Animator(Delegate& delegate,
       // https://github.com/flutter/engine/pull/9132 for discussion.
       layer_tree_pipeline_(fml::MakeRefCounted<LayerTreePipeline>(
           task_runners.GetPlatformTaskRunner() ==
-                  task_runners.GetGPUTaskRunner()
+                  task_runners.GetRasterTaskRunner()
               ? 1
               : 2)),
 #endif  // FLUTTER_SHELL_ENABLE_METAL

shell/common/platform_view.cc

@@ -69,7 +69,7 @@ void PlatformView::NotifyCreated() {
   auto* platform_view = this;
   fml::ManualResetWaitableEvent latch;
   fml::TaskRunner::RunNowOrPostTask(
-      task_runners_.GetGPUTaskRunner(), [platform_view, &surface, &latch]() {
+      task_runners_.GetRasterTaskRunner(), [platform_view, &surface, &latch]() {
         surface = platform_view->CreateRenderingSurface();
         latch.Signal();
       });

shell/common/rasterizer.cc

@@ -69,9 +69,9 @@ void Rasterizer::Setup(std::unique_ptr<Surface> surface) {
   if (surface_->GetExternalViewEmbedder()) {
     const auto platform_id =
         task_runners_.GetPlatformTaskRunner()->GetTaskQueueId();
-    const auto gpu_id = task_runners_.GetGPUTaskRunner()->GetTaskQueueId();
-    gpu_thread_merger_ =
-        fml::MakeRefCounted<fml::GpuThreadMerger>(platform_id, gpu_id);
+    const auto gpu_id = task_runners_.GetRasterTaskRunner()->GetTaskQueueId();
+    raster_thread_merger_ =
+        fml::MakeRefCounted<fml::RasterThreadMerger>(platform_id, gpu_id);
   }
 }
 
@@ -111,11 +111,12 @@ void Rasterizer::DrawLastLayerTree() {
 
 void Rasterizer::Draw(fml::RefPtr<Pipeline<flutter::LayerTree>> pipeline) {
   TRACE_EVENT0("flutter", "GPURasterizer::Draw");
-  if (gpu_thread_merger_ && !gpu_thread_merger_->IsOnRasterizingThread()) {
+  if (raster_thread_merger_ &&
+      !raster_thread_merger_->IsOnRasterizingThread()) {
     // we yield and let this frame be serviced on the right thread.
     return;
   }
-  FML_DCHECK(task_runners_.GetGPUTaskRunner()->RunsTasksOnCurrentThread());
+  FML_DCHECK(task_runners_.GetRasterTaskRunner()->RunsTasksOnCurrentThread());
 
   RasterStatus raster_status = RasterStatus::kFailed;
   Pipeline<flutter::LayerTree>::Consumer consumer =
@@ -137,7 +138,7 @@ void Rasterizer::Draw(fml::RefPtr<Pipeline<flutter::LayerTree>> pipeline) {
   // between successive tries.
   switch (consume_result) {
     case PipelineConsumeResult::MoreAvailable: {
-      task_runners_.GetGPUTaskRunner()->PostTask(
+      task_runners_.GetRasterTaskRunner()->PostTask(
           [weak_this = weak_factory_.GetWeakPtr(), pipeline]() {
             if (weak_this) {
               weak_this->Draw(pipeline);
@@ -232,7 +233,7 @@ sk_sp<SkImage> Rasterizer::ConvertToRasterImage(sk_sp<SkImage> image) {
 
 RasterStatus Rasterizer::DoDraw(
     std::unique_ptr<flutter::LayerTree> layer_tree) {
-  FML_DCHECK(task_runners_.GetGPUTaskRunner()->RunsTasksOnCurrentThread());
+  FML_DCHECK(task_runners_.GetRasterTaskRunner()->RunsTasksOnCurrentThread());
 
   if (!layer_tree || !surface_) {
     return RasterStatus::kFailed;
@@ -283,9 +284,9 @@ RasterStatus Rasterizer::DoDraw(
   //   - |Draw| for B yields as its on the wrong thread.
   // This enqueue ensures that we attempt to consume from the right
   // thread one more time after un-merge.
-  if (gpu_thread_merger_) {
-    if (gpu_thread_merger_->DecrementLease() ==
-        fml::GpuThreadStatus::kUnmergedNow) {
+  if (raster_thread_merger_) {
+    if (raster_thread_merger_->DecrementLease() ==
+        fml::RasterThreadStatus::kUnmergedNow) {
       return RasterStatus::kEnqueuePipeline;
     }
   }
@@ -334,7 +335,7 @@ RasterStatus Rasterizer::DrawToSurface(flutter::LayerTree& layer_tree) {
       root_surface_transformation,  // root surface transformation
       true,                         // instrumentation enabled
       frame->supports_readback(),   // surface supports pixel reads
-      gpu_thread_merger_            // thread merger
+      raster_thread_merger_         // thread merger
   );
 
   if (compositor_frame) {

shell/common/rasterizer.h

@@ -13,8 +13,8 @@
 #include "flutter/flow/compositor_context.h"
 #include "flutter/flow/layers/layer_tree.h"
 #include "flutter/fml/closure.h"
-#include "flutter/fml/gpu_thread_merger.h"
 #include "flutter/fml/memory/weak_ptr.h"
+#include "flutter/fml/raster_thread_merger.h"
 #include "flutter/fml/synchronization/waitable_event.h"
 #include "flutter/lib/ui/snapshot_delegate.h"
 #include "flutter/shell/common/pipeline.h"
@@ -420,7 +420,7 @@ class Rasterizer final : public SnapshotDelegate {
   bool user_override_resource_cache_bytes_;
   std::optional<size_t> max_cache_bytes_;
   fml::WeakPtrFactory<Rasterizer> weak_factory_;
-  fml::RefPtr<fml::GpuThreadMerger> gpu_thread_merger_;
+  fml::RefPtr<fml::RasterThreadMerger> raster_thread_merger_;
 
   // |SnapshotDelegate|
   sk_sp<SkImage> MakeRasterSnapshot(sk_sp<SkPicture> picture,

shell/common/shell.cc

@@ -62,10 +62,10 @@ std::unique_ptr<Shell> Shell::CreateShellOnPlatformThread(
   std::promise<fml::WeakPtr<SnapshotDelegate>> snapshot_delegate_promise;
   auto snapshot_delegate_future = snapshot_delegate_promise.get_future();
   fml::TaskRunner::RunNowOrPostTask(
-      task_runners.GetGPUTaskRunner(), [&rasterizer_promise,  //
-                                        &snapshot_delegate_promise,
-                                        on_create_rasterizer,  //
-                                        shell = shell.get()    //
+      task_runners.GetRasterTaskRunner(), [&rasterizer_promise,  //
+                                           &snapshot_delegate_promise,
+                                           on_create_rasterizer,  //
+                                           shell = shell.get()    //
   ]() {
         TRACE_EVENT0("flutter", "ShellSetupGPUSubsystem");
         std::unique_ptr<Rasterizer> rasterizer(on_create_rasterizer(*shell));
@@ -340,7 +340,7 @@ Shell::Shell(DartVMRef vm, TaskRunners task_runners, Settings settings)
   // need to wait on a latch because it can only ever be used from the raster
   // thread from this class, so we have ordering guarantees.
   fml::TaskRunner::RunNowOrPostTask(
-      task_runners_.GetGPUTaskRunner(), fml::MakeCopyable([this]() mutable {
+      task_runners_.GetRasterTaskRunner(), fml::MakeCopyable([this]() mutable {
         this->weak_factory_gpu_ =
             std::make_unique<fml::WeakPtrFactory<Shell>>(this);
       }));
@@ -348,11 +348,11 @@ Shell::Shell(DartVMRef vm, TaskRunners task_runners, Settings settings)
   // Install service protocol handlers.
 
   service_protocol_handlers_[ServiceProtocol::kScreenshotExtensionName] = {
-      task_runners_.GetGPUTaskRunner(),
+      task_runners_.GetRasterTaskRunner(),
       std::bind(&Shell::OnServiceProtocolScreenshot, this,
                 std::placeholders::_1, std::placeholders::_2)};
   service_protocol_handlers_[ServiceProtocol::kScreenshotSkpExtensionName] = {
-      task_runners_.GetGPUTaskRunner(),
+      task_runners_.GetRasterTaskRunner(),
       std::bind(&Shell::OnServiceProtocolScreenshotSKP, this,
                 std::placeholders::_1, std::placeholders::_2)};
   service_protocol_handlers_[ServiceProtocol::kRunInViewExtensionName] = {
@@ -397,7 +397,7 @@ Shell::~Shell() {
   ui_latch.Wait();
 
   fml::TaskRunner::RunNowOrPostTask(
-      task_runners_.GetGPUTaskRunner(),
+      task_runners_.GetRasterTaskRunner(),
       fml::MakeCopyable([rasterizer = std::move(rasterizer_),
                          weak_factory_gpu = std::move(weak_factory_gpu_),
                          &gpu_latch]() mutable {
@@ -441,7 +441,7 @@ void Shell::NotifyLowMemoryWarning() const {
   // running.
   ::Dart_NotifyLowMemory();
 
-  task_runners_.GetGPUTaskRunner()->PostTask(
+  task_runners_.GetRasterTaskRunner()->PostTask(
       [rasterizer = rasterizer_->GetWeakPtr()]() {
         if (rasterizer) {
           rasterizer->NotifyLowMemoryWarning();
@@ -626,15 +626,15 @@ void Shell::OnPlatformViewCreated(std::unique_ptr<Surface> surface) {
   // gpu_task to the raster thread which signals the latch. If the GPU the and
   // platform threads are the same this results in a deadlock as the gpu_task
   // will never be posted to the plaform/raster thread that is blocked on a
-  // latch. To avoid the described deadlock, if the gpu and the platform threads
-  // are the same, should_post_gpu_task will be false, and then instead of
-  // posting a task to the raster thread, the ui thread just signals the latch
-  // and the platform/raster thread follows with executing gpu_task.
-  bool should_post_gpu_task =
-      task_runners_.GetGPUTaskRunner() != task_runners_.GetPlatformTaskRunner();
-
-  auto ui_task = [engine = engine_->GetWeakPtr(),                      //
-                  gpu_task_runner = task_runners_.GetGPUTaskRunner(),  //
+  // latch. To avoid the described deadlock, if the raster and the platform
+  // threads are the same, should_post_gpu_task will be false, and then instead
+  // of posting a task to the raster thread, the ui thread just signals the
+  // latch and the platform/raster thread follows with executing gpu_task.
+  bool should_post_gpu_task = task_runners_.GetRasterTaskRunner() !=
+                              task_runners_.GetPlatformTaskRunner();
+
+  auto ui_task = [engine = engine_->GetWeakPtr(),                            //
+                  raster_task_runner = task_runners_.GetRasterTaskRunner(),  //
                   gpu_task, should_post_gpu_task,
                   &latch  //
   ] {
@@ -644,7 +644,7 @@ void Shell::OnPlatformViewCreated(std::unique_ptr<Surface> surface) {
     // Step 2: Next, tell the raster thread that it should create a surface for
     // its rasterizer.
     if (should_post_gpu_task) {
-      fml::TaskRunner::RunNowOrPostTask(gpu_task_runner, gpu_task);
+      fml::TaskRunner::RunNowOrPostTask(raster_task_runner, gpu_task);
     } else {
       // See comment on should_post_gpu_task, in this case we just unblock
       // the platform thread.
@@ -721,24 +721,24 @@ void Shell::OnPlatformViewDestroyed() {
   // gpu_task to the raster thread triggers signaling the latch(on the IO
   // thread). If the GPU the and platform threads are the same this results in a
   // deadlock as the gpu_task will never be posted to the plaform/raster thread
-  // that is blocked on a latch.  To avoid the described deadlock, if the gpu
+  // that is blocked on a latch.  To avoid the described deadlock, if the raster
   // and the platform threads are the same, should_post_gpu_task will be false,
   // and then instead of posting a task to the raster thread, the ui thread just
   // signals the latch and the platform/raster thread follows with executing
   // gpu_task.
-  bool should_post_gpu_task =
-      task_runners_.GetGPUTaskRunner() != task_runners_.GetPlatformTaskRunner();
+  bool should_post_gpu_task = task_runners_.GetRasterTaskRunner() !=
+                              task_runners_.GetPlatformTaskRunner();
 
   auto ui_task = [engine = engine_->GetWeakPtr(),
-                  gpu_task_runner = task_runners_.GetGPUTaskRunner(), gpu_task,
-                  should_post_gpu_task, &latch]() {
+                  raster_task_runner = task_runners_.GetRasterTaskRunner(),
+                  gpu_task, should_post_gpu_task, &latch]() {
     if (engine) {
       engine->OnOutputSurfaceDestroyed();
     }
     // Step 1: Next, tell the raster thread that its rasterizer should suspend
     // access to the underlying surface.
     if (should_post_gpu_task) {
-      fml::TaskRunner::RunNowOrPostTask(gpu_task_runner, gpu_task);
+      fml::TaskRunner::RunNowOrPostTask(raster_task_runner, gpu_task);
     } else {
       // See comment on should_post_gpu_task, in this case we just unblock
       // the platform thread.
@@ -767,7 +767,7 @@ void Shell::OnPlatformViewSetViewportMetrics(const ViewportMetrics& metrics) {
   // This is the formula Android uses.
   // https://android.googlesource.com/platform/frameworks/base/+/master/libs/hwui/renderthread/CacheManager.cpp#41
   size_t max_bytes = metrics.physical_width * metrics.physical_height * 12 * 4;
-  task_runners_.GetGPUTaskRunner()->PostTask(
+  task_runners_.GetRasterTaskRunner()->PostTask(
       [rasterizer = rasterizer_->GetWeakPtr(), max_bytes] {
         if (rasterizer) {
           rasterizer->SetResourceCacheMaxBytes(max_bytes, false);
@@ -860,7 +860,7 @@ void Shell::OnPlatformViewRegisterTexture(
   FML_DCHECK(is_setup_);
   FML_DCHECK(task_runners_.GetPlatformTaskRunner()->RunsTasksOnCurrentThread());
 
-  task_runners_.GetGPUTaskRunner()->PostTask(
+  task_runners_.GetRasterTaskRunner()->PostTask(
       [rasterizer = rasterizer_->GetWeakPtr(), texture] {
         if (rasterizer) {
           if (auto* registry = rasterizer->GetTextureRegistry()) {
@@ -875,7 +875,7 @@ void Shell::OnPlatformViewUnregisterTexture(int64_t texture_id) {
   FML_DCHECK(is_setup_);
   FML_DCHECK(task_runners_.GetPlatformTaskRunner()->RunsTasksOnCurrentThread());
 
-  task_runners_.GetGPUTaskRunner()->PostTask(
+  task_runners_.GetRasterTaskRunner()->PostTask(
       [rasterizer = rasterizer_->GetWeakPtr(), texture_id]() {
         if (rasterizer) {
           if (auto* registry = rasterizer->GetTextureRegistry()) {
@@ -891,7 +891,7 @@ void Shell::OnPlatformViewMarkTextureFrameAvailable(int64_t texture_id) {
   FML_DCHECK(task_runners_.GetPlatformTaskRunner()->RunsTasksOnCurrentThread());
 
   // Tell the rasterizer that one of its textures has a new frame available.
-  task_runners_.GetGPUTaskRunner()->PostTask(
+  task_runners_.GetRasterTaskRunner()->PostTask(
       [rasterizer = rasterizer_->GetWeakPtr(), texture_id]() {
         auto* registry = rasterizer->GetTextureRegistry();
 
@@ -921,7 +921,7 @@ void Shell::OnPlatformViewSetNextFrameCallback(const fml::closure& closure) {
   FML_DCHECK(is_setup_);
   FML_DCHECK(task_runners_.GetPlatformTaskRunner()->RunsTasksOnCurrentThread());
 
-  task_runners_.GetGPUTaskRunner()->PostTask(
+  task_runners_.GetRasterTaskRunner()->PostTask(
       [rasterizer = rasterizer_->GetWeakPtr(), closure = closure]() {
         if (rasterizer) {
           rasterizer->SetNextFrameCallback(std::move(closure));
@@ -953,7 +953,7 @@ void Shell::OnAnimatorNotifyIdle(int64_t deadline) {
 void Shell::OnAnimatorDraw(fml::RefPtr<Pipeline<flutter::LayerTree>> pipeline) {
   FML_DCHECK(is_setup_);
 
-  task_runners_.GetGPUTaskRunner()->PostTask(
+  task_runners_.GetRasterTaskRunner()->PostTask(
       [& waiting_for_first_frame = waiting_for_first_frame_,
        &waiting_for_first_frame_condition = waiting_for_first_frame_condition_,
        rasterizer = rasterizer_->GetWeakPtr(),
@@ -973,7 +973,7 @@ void Shell::OnAnimatorDraw(fml::RefPtr<Pipeline<flutter::LayerTree>> pipeline) {
 void Shell::OnAnimatorDrawLastLayerTree() {
   FML_DCHECK(is_setup_);
 
-  task_runners_.GetGPUTaskRunner()->PostTask(
+  task_runners_.GetRasterTaskRunner()->PostTask(
       [rasterizer = rasterizer_->GetWeakPtr()]() {
         if (rasterizer) {
           rasterizer->DrawLastLayerTree();
@@ -1030,7 +1030,7 @@ void Shell::HandleEngineSkiaMessage(fml::RefPtr<PlatformMessage> message) {
   if (args == root.MemberEnd() || !args->value.IsInt())
     return;
 
-  task_runners_.GetGPUTaskRunner()->PostTask(
+  task_runners_.GetRasterTaskRunner()->PostTask(
       [rasterizer = rasterizer_->GetWeakPtr(), max_bytes = args->value.GetInt(),
        response = std::move(message->response())] {
         if (rasterizer) {
@@ -1079,7 +1079,7 @@ void Shell::SetNeedsReportTimings(bool value) {
 
 void Shell::ReportTimings() {
   FML_DCHECK(is_setup_);
-  FML_DCHECK(task_runners_.GetGPUTaskRunner()->RunsTasksOnCurrentThread());
+  FML_DCHECK(task_runners_.GetRasterTaskRunner()->RunsTasksOnCurrentThread());
 
   auto timings = std::move(unreported_timings_);
   unreported_timings_ = {};
@@ -1092,14 +1092,14 @@ void Shell::ReportTimings() {
 
 size_t Shell::UnreportedFramesCount() const {
   // Check that this is running on the raster thread to avoid race conditions.
-  FML_DCHECK(task_runners_.GetGPUTaskRunner()->RunsTasksOnCurrentThread());
+  FML_DCHECK(task_runners_.GetRasterTaskRunner()->RunsTasksOnCurrentThread());
   FML_DCHECK(unreported_timings_.size() % FrameTiming::kCount == 0);
   return unreported_timings_.size() / FrameTiming::kCount;
 }
 
 void Shell::OnFrameRasterized(const FrameTiming& timing) {
   FML_DCHECK(is_setup_);
-  FML_DCHECK(task_runners_.GetGPUTaskRunner()->RunsTasksOnCurrentThread());
+  FML_DCHECK(task_runners_.GetRasterTaskRunner()->RunsTasksOnCurrentThread());
 
   // The C++ callback defined in settings.h and set by Flutter runner. This is
   // independent of the timings report to the Dart side.
@@ -1142,7 +1142,7 @@ void Shell::OnFrameRasterized(const FrameTiming& timing) {
     // second. Otherwise, the timings of last few frames of an animation may
     // never be reported until the next animation starts.
     frame_timings_report_scheduled_ = true;
-    task_runners_.GetGPUTaskRunner()->PostDelayedTask(
+    task_runners_.GetRasterTaskRunner()->PostDelayedTask(
         [self = weak_factory_gpu_->GetWeakPtr()]() {
           if (!self.get()) {
             return;
@@ -1223,7 +1223,7 @@ static void ServiceProtocolFailureError(rapidjson::Document& response,
 bool Shell::OnServiceProtocolScreenshot(
     const ServiceProtocol::Handler::ServiceProtocolMap& params,
     rapidjson::Document& response) {
-  FML_DCHECK(task_runners_.GetGPUTaskRunner()->RunsTasksOnCurrentThread());
+  FML_DCHECK(task_runners_.GetRasterTaskRunner()->RunsTasksOnCurrentThread());
   auto screenshot = rasterizer_->ScreenshotLastLayerTree(
       Rasterizer::ScreenshotType::CompressedImage, true);
   if (screenshot.data) {
@@ -1244,7 +1244,7 @@ bool Shell::OnServiceProtocolScreenshot(
 bool Shell::OnServiceProtocolScreenshotSKP(
     const ServiceProtocol::Handler::ServiceProtocolMap& params,
     rapidjson::Document& response) {
-  FML_DCHECK(task_runners_.GetGPUTaskRunner()->RunsTasksOnCurrentThread());
+  FML_DCHECK(task_runners_.GetRasterTaskRunner()->RunsTasksOnCurrentThread());
   auto screenshot = rasterizer_->ScreenshotLastLayerTree(
       Rasterizer::ScreenshotType::SkiaPicture, true);
   if (screenshot.data) {
@@ -1418,11 +1418,11 @@ Rasterizer::Screenshot Shell::Screenshot(
   fml::AutoResetWaitableEvent latch;
   Rasterizer::Screenshot screenshot;
   fml::TaskRunner::RunNowOrPostTask(
-      task_runners_.GetGPUTaskRunner(), [&latch,                        //
-                                         rasterizer = GetRasterizer(),  //
-                                         &screenshot,                   //
-                                         screenshot_type,               //
-                                         base64_encode                  //
+      task_runners_.GetRasterTaskRunner(), [&latch,                        //
+                                            rasterizer = GetRasterizer(),  //
+                                            &screenshot,                   //
+                                            screenshot_type,               //
+                                            base64_encode                  //
   ]() {
         if (rasterizer) {
           screenshot = rasterizer->ScreenshotLastLayerTree(screenshot_type,
@@ -1437,7 +1437,7 @@ Rasterizer::Screenshot Shell::Screenshot(
 fml::Status Shell::WaitForFirstFrame(fml::TimeDelta timeout) {
   FML_DCHECK(is_setup_);
   if (task_runners_.GetUITaskRunner()->RunsTasksOnCurrentThread() ||
-      task_runners_.GetGPUTaskRunner()->RunsTasksOnCurrentThread()) {
+      task_runners_.GetRasterTaskRunner()->RunsTasksOnCurrentThread()) {
     return fml::Status(fml::StatusCode::kFailedPrecondition,
                        "WaitForFirstFrame called from thread that can't wait "
                        "because it is responsible for generating the frame.");

shell/common/shell_benchmarks.cc

@@ -48,7 +48,7 @@ static void StartupAndShutdownShell(benchmark::State& state,
 
     TaskRunners task_runners("test",
                              thread_host->platform_thread->GetTaskRunner(),
-                             thread_host->gpu_thread->GetTaskRunner(),
+                             thread_host->raster_thread->GetTaskRunner(),
                              thread_host->ui_thread->GetTaskRunner(),
                              thread_host->io_thread->GetTaskRunner());
 

shell/common/shell_test.cc

@@ -244,7 +244,7 @@ TaskRunners ShellTest::GetTaskRunnersForFixture() {
   return {
       "test",
       thread_host_.platform_thread->GetTaskRunner(),  // platform
-      thread_host_.gpu_thread->GetTaskRunner(),       // raster
+      thread_host_.raster_thread->GetTaskRunner(),    // raster
       thread_host_.ui_thread->GetTaskRunner(),        // ui
       thread_host_.io_thread->GetTaskRunner()         // io
   };

shell/common/shell_unittests.cc

@@ -75,7 +75,7 @@ TEST_F(ShellTest, InitializeWithDifferentThreads) {
                          ThreadHost::Type::Platform | ThreadHost::Type::GPU |
                              ThreadHost::Type::IO | ThreadHost::Type::UI);
   TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
-                           thread_host.gpu_thread->GetTaskRunner(),
+                           thread_host.raster_thread->GetTaskRunner(),
                            thread_host.ui_thread->GetTaskRunner(),
                            thread_host.io_thread->GetTaskRunner());
   auto shell = CreateShell(std::move(settings), std::move(task_runners));
@@ -124,7 +124,7 @@ TEST_F(ShellTest,
   fml::MessageLoop::EnsureInitializedForCurrentThread();
   TaskRunners task_runners("test",
                            fml::MessageLoop::GetCurrent().GetTaskRunner(),
-                           thread_host.gpu_thread->GetTaskRunner(),
+                           thread_host.raster_thread->GetTaskRunner(),
                            thread_host.ui_thread->GetTaskRunner(),
                            thread_host.io_thread->GetTaskRunner());
   auto shell = Shell::Create(
@@ -717,7 +717,7 @@ static size_t GetRasterizerResourceCacheBytesSync(Shell& shell) {
   size_t bytes = 0;
   fml::AutoResetWaitableEvent latch;
   fml::TaskRunner::RunNowOrPostTask(
-      shell.GetTaskRunners().GetGPUTaskRunner(), [&]() {
+      shell.GetTaskRunners().GetRasterTaskRunner(), [&]() {
         if (auto rasterizer = shell.GetRasterizer()) {
           bytes = rasterizer->GetResourceCacheMaxBytes().value_or(0U);
         }
@@ -938,7 +938,7 @@ TEST_F(ShellTest, TextureFrameMarkedAvailableAndUnregister) {
       std::make_shared<MockTexture>(0, latch);
 
   fml::TaskRunner::RunNowOrPostTask(
-      shell->GetTaskRunners().GetGPUTaskRunner(), [&]() {
+      shell->GetTaskRunners().GetRasterTaskRunner(), [&]() {
         shell->GetPlatformView()->RegisterTexture(mockTexture);
         shell->GetPlatformView()->MarkTextureFrameAvailable(0);
       });
@@ -947,7 +947,7 @@ TEST_F(ShellTest, TextureFrameMarkedAvailableAndUnregister) {
   EXPECT_EQ(mockTexture->frames_available(), 1);
 
   fml::TaskRunner::RunNowOrPostTask(
-      shell->GetTaskRunners().GetGPUTaskRunner(),
+      shell->GetTaskRunners().GetRasterTaskRunner(),
       [&]() { shell->GetPlatformView()->UnregisterTexture(0); });
   latch->Wait();
 
@@ -1032,7 +1032,7 @@ TEST_F(ShellTest, Screenshot) {
   auto screenshot_future = screenshot_promise.get_future();
 
   fml::TaskRunner::RunNowOrPostTask(
-      shell->GetTaskRunners().GetGPUTaskRunner(),
+      shell->GetTaskRunners().GetRasterTaskRunner(),
       [&screenshot_promise, &shell]() {
         auto rasterizer = shell->GetRasterizer();
         screenshot_promise.set_value(rasterizer->ScreenshotLastLayerTree(

shell/common/thread_host.cc

@@ -20,7 +20,7 @@ ThreadHost::ThreadHost(std::string name_prefix, uint64_t mask) {
   }
 
   if (mask & ThreadHost::Type::GPU) {
-    gpu_thread = std::make_unique<fml::Thread>(name_prefix + ".gpu");
+    raster_thread = std::make_unique<fml::Thread>(name_prefix + ".raster");
   }
 
   if (mask & ThreadHost::Type::IO) {
@@ -33,7 +33,7 @@ ThreadHost::~ThreadHost() = default;
 void ThreadHost::Reset() {
   platform_thread.reset();
   ui_thread.reset();
-  gpu_thread.reset();
+  raster_thread.reset();
   io_thread.reset();
 }
 

shell/common/thread_host.h

@@ -23,7 +23,7 @@ struct ThreadHost {
 
   std::unique_ptr<fml::Thread> platform_thread;
   std::unique_ptr<fml::Thread> ui_thread;
-  std::unique_ptr<fml::Thread> gpu_thread;
+  std::unique_ptr<fml::Thread> raster_thread;
   std::unique_ptr<fml::Thread> io_thread;
 
   ThreadHost();

shell/platform/android/android_shell_holder.cc

@@ -51,7 +51,7 @@ AndroidShellHolder::AndroidShellHolder(
   });
   thread_host_.ui_thread->GetTaskRunner()->PostTask(jni_exit_task);
   if (!is_background_view) {
-    thread_host_.gpu_thread->GetTaskRunner()->PostTask(jni_exit_task);
+    thread_host_.raster_thread->GetTaskRunner()->PostTask(jni_exit_task);
   }
 
   fml::WeakPtr<PlatformViewAndroid> weak_platform_view;
@@ -96,7 +96,7 @@ AndroidShellHolder::AndroidShellHolder(
     ui_runner = single_task_runner;
     io_runner = single_task_runner;
   } else {
-    gpu_runner = thread_host_.gpu_thread->GetTaskRunner();
+    gpu_runner = thread_host_.raster_thread->GetTaskRunner();
     ui_runner = thread_host_.ui_thread->GetTaskRunner();
     io_runner = thread_host_.io_thread->GetTaskRunner();
   }
@@ -121,7 +121,7 @@ AndroidShellHolder::AndroidShellHolder(
   is_valid_ = shell_ != nullptr;
 
   if (is_valid_) {
-    task_runners.GetGPUTaskRunner()->PostTask([]() {
+    task_runners.GetRasterTaskRunner()->PostTask([]() {
       // Android describes -8 as "most important display threads, for
       // compositing the screen and retrieving input events". Conservatively
       // set the raster thread to slightly lower priority than it.

shell/platform/android/platform_view_android.cc

@@ -48,7 +48,7 @@ void PlatformViewAndroid::NotifyCreated(
 
     fml::AutoResetWaitableEvent latch;
     fml::TaskRunner::RunNowOrPostTask(
-        task_runners_.GetGPUTaskRunner(),
+        task_runners_.GetRasterTaskRunner(),
         [&latch, surface = android_surface_.get(),
          native_window = std::move(native_window)]() {
           surface->SetNativeWindow(native_window);
@@ -66,7 +66,7 @@ void PlatformViewAndroid::NotifyDestroyed() {
   if (android_surface_) {
     fml::AutoResetWaitableEvent latch;
     fml::TaskRunner::RunNowOrPostTask(
-        task_runners_.GetGPUTaskRunner(),
+        task_runners_.GetRasterTaskRunner(),
         [&latch, surface = android_surface_.get()]() {
           surface->TeardownOnScreenContext();
           latch.Signal();
@@ -81,7 +81,7 @@ void PlatformViewAndroid::NotifyChanged(const SkISize& size) {
   }
   fml::AutoResetWaitableEvent latch;
   fml::TaskRunner::RunNowOrPostTask(
-      task_runners_.GetGPUTaskRunner(),  //
+      task_runners_.GetRasterTaskRunner(),  //
       [&latch, surface = android_surface_.get(), size]() {
         surface->OnScreenSurfaceResize(size);
         latch.Signal();

shell/platform/darwin/ios/framework/Source/FlutterEngine.mm

@@ -195,9 +195,9 @@ NSString* const FlutterDefaultDartEntrypoint = nil;
   return _shell->GetTaskRunners().GetPlatformTaskRunner();
 }
 
-- (fml::RefPtr<fml::TaskRunner>)GPUTaskRunner {
+- (fml::RefPtr<fml::TaskRunner>)RasterTaskRunner {
   FML_DCHECK(_shell);
-  return _shell->GetTaskRunners().GetGPUTaskRunner();
+  return _shell->GetTaskRunners().GetRasterTaskRunner();
 }
 
 - (void)ensureSemanticsEnabled {
@@ -476,7 +476,7 @@ NSString* const FlutterDefaultDartEntrypoint = nil;
   } else {
     flutter::TaskRunners task_runners(threadLabel.UTF8String,                          // label
                                       fml::MessageLoop::GetCurrent().GetTaskRunner(),  // platform
-                                      _threadHost.gpu_thread->GetTaskRunner(),         // raster
+                                      _threadHost.raster_thread->GetTaskRunner(),      // raster
                                       _threadHost.ui_thread->GetTaskRunner(),          // ui
                                       _threadHost.io_thread->GetTaskRunner()           // io
     );

shell/platform/darwin/ios/framework/Source/FlutterEngine_Internal.h

@@ -32,7 +32,7 @@
 - (void)dispatchPointerDataPacket:(std::unique_ptr<flutter::PointerDataPacket>)packet;
 
 - (fml::RefPtr<fml::TaskRunner>)platformTaskRunner;
-- (fml::RefPtr<fml::TaskRunner>)GPUTaskRunner;
+- (fml::RefPtr<fml::TaskRunner>)RasterTaskRunner;
 
 - (fml::WeakPtr<flutter::PlatformView>)platformView;
 

shell/platform/darwin/ios/framework/Source/FlutterPlatformViews.mm

@@ -261,14 +261,14 @@ bool FlutterPlatformViewsController::HasPendingViewOperations() {
 const int FlutterPlatformViewsController::kDefaultMergedLeaseDuration;
 
 PostPrerollResult FlutterPlatformViewsController::PostPrerollAction(
-    fml::RefPtr<fml::GpuThreadMerger> gpu_thread_merger) {
+    fml::RefPtr<fml::RasterThreadMerger> raster_thread_merger) {
   const bool uiviews_mutated = HasPendingViewOperations();
   if (uiviews_mutated) {
-    if (gpu_thread_merger->IsMerged()) {
-      gpu_thread_merger->ExtendLeaseTo(kDefaultMergedLeaseDuration);
+    if (raster_thread_merger->IsMerged()) {
+      raster_thread_merger->ExtendLeaseTo(kDefaultMergedLeaseDuration);
     } else {
       CancelFrame();
-      gpu_thread_merger->MergeWithLease(kDefaultMergedLeaseDuration);
+      raster_thread_merger->MergeWithLease(kDefaultMergedLeaseDuration);
       return PostPrerollResult::kResubmitFrame;
     }
   }

shell/platform/darwin/ios/framework/Source/FlutterPlatformViews_Internal.h

@@ -146,7 +146,7 @@ class FlutterPlatformViewsController {
   // returns nil.
   NSObject<FlutterPlatformView>* GetPlatformViewByID(int view_id);
 
-  PostPrerollResult PostPrerollAction(fml::RefPtr<fml::GpuThreadMerger> gpu_thread_merger);
+  PostPrerollResult PostPrerollAction(fml::RefPtr<fml::RasterThreadMerger> raster_thread_merger);
 
   std::vector<SkCanvas*> GetCurrentCanvases();
 

shell/platform/darwin/ios/framework/Source/FlutterViewController.mm

@@ -451,8 +451,8 @@ static void sendFakeTouchEvent(FlutterEngine* engine,
   // Start on the platform thread.
   weakPlatformView->SetNextFrameCallback([weakSelf = [self getWeakPtr],
                                           platformTaskRunner = [_engine.get() platformTaskRunner],
-                                          gpuTaskRunner = [_engine.get() GPUTaskRunner]]() {
-    FML_DCHECK(gpuTaskRunner->RunsTasksOnCurrentThread());
+                                          RasterTaskRunner = [_engine.get() RasterTaskRunner]]() {
+    FML_DCHECK(RasterTaskRunner->RunsTasksOnCurrentThread());
     // Get callback on raster thread and jump back to platform thread.
     platformTaskRunner->PostTask([weakSelf]() {
       fml::scoped_nsobject<FlutterViewController> flutterViewController(

shell/platform/darwin/ios/ios_surface.h

@@ -68,7 +68,8 @@ class IOSSurface : public ExternalViewEmbedder {
                                     std::unique_ptr<flutter::EmbeddedViewParams> params) override;
 
   // |ExternalViewEmbedder|
-  PostPrerollResult PostPrerollAction(fml::RefPtr<fml::GpuThreadMerger> gpu_thread_merger) override;
+  PostPrerollResult PostPrerollAction(
+      fml::RefPtr<fml::RasterThreadMerger> raster_thread_merger) override;
 
   // |ExternalViewEmbedder|
   std::vector<SkCanvas*> GetCurrentCanvases() override;

shell/platform/darwin/ios/ios_surface.mm

@@ -112,10 +112,10 @@ void IOSSurface::PrerollCompositeEmbeddedView(int view_id,
 
 // |ExternalViewEmbedder|
 PostPrerollResult IOSSurface::PostPrerollAction(
-    fml::RefPtr<fml::GpuThreadMerger> gpu_thread_merger) {
+    fml::RefPtr<fml::RasterThreadMerger> raster_thread_merger) {
   TRACE_EVENT0("flutter", "IOSSurface::PostPrerollAction");
   FML_CHECK(platform_views_controller_ != nullptr);
-  return platform_views_controller_->PostPrerollAction(gpu_thread_merger);
+  return platform_views_controller_->PostPrerollAction(raster_thread_merger);
 }
 
 // |ExternalViewEmbedder|

shell/platform/darwin/ios/platform_view_ios.mm

@@ -94,7 +94,7 @@ void PlatformViewIOS::RegisterExternalTexture(int64_t texture_id,
 
 // |PlatformView|
 std::unique_ptr<Surface> PlatformViewIOS::CreateRenderingSurface() {
-  FML_DCHECK(task_runners_.GetGPUTaskRunner()->RunsTasksOnCurrentThread());
+  FML_DCHECK(task_runners_.GetRasterTaskRunner()->RunsTasksOnCurrentThread());
   std::lock_guard<std::mutex> guard(ios_surface_mutex_);
   if (!ios_surface_) {
     FML_DLOG(INFO) << "Could not CreateRenderingSurface, this PlatformViewIOS "

shell/platform/embedder/embedder_engine.cc

@@ -232,7 +232,7 @@ bool EmbedderEngine::PostRenderThreadTask(const fml::closure& task) {
     return false;
   }
 
-  shell_->GetTaskRunners().GetGPUTaskRunner()->PostTask(task);
+  shell_->GetTaskRunners().GetRasterTaskRunner()->PostTask(task);
   return true;
 }
 
@@ -260,7 +260,8 @@ bool EmbedderEngine::PostTaskOnEngineManagedNativeThreads(
 
   // Post the task to all thread host threads.
   const auto& task_runners = shell_->GetTaskRunners();
-  trampoline(kFlutterNativeThreadTypeRender, task_runners.GetGPUTaskRunner());
+  trampoline(kFlutterNativeThreadTypeRender,
+             task_runners.GetRasterTaskRunner());
   trampoline(kFlutterNativeThreadTypeWorker, task_runners.GetIOTaskRunner());
   trampoline(kFlutterNativeThreadTypeUI, task_runners.GetUITaskRunner());
   trampoline(kFlutterNativeThreadTypePlatform,

shell/platform/embedder/embedder_thread_host.cc

@@ -168,7 +168,7 @@ EmbedderThreadHost::CreateEmbedderManagedThreadHost(
   auto render_task_runner = render_task_runner_pair.second
                                 ? static_cast<fml::RefPtr<fml::TaskRunner>>(
                                       render_task_runner_pair.second)
-                                : thread_host.gpu_thread->GetTaskRunner();
+                                : thread_host.raster_thread->GetTaskRunner();
 
   flutter::TaskRunners task_runners(
       kFlutterThreadName,
@@ -219,10 +219,10 @@ EmbedderThreadHost::CreateEngineManagedThreadHost() {
 
   flutter::TaskRunners task_runners(
       kFlutterThreadName,
-      platform_task_runner,                     // platform
-      thread_host.gpu_thread->GetTaskRunner(),  // raster
-      thread_host.ui_thread->GetTaskRunner(),   // ui
-      thread_host.io_thread->GetTaskRunner()    // io
+      platform_task_runner,                        // platform
+      thread_host.raster_thread->GetTaskRunner(),  // raster
+      thread_host.ui_thread->GetTaskRunner(),      // ui
+      thread_host.io_thread->GetTaskRunner()       // io
   );
 
   if (!task_runners.IsValid()) {

shell/platform/embedder/tests/embedder_unittests.cc

@@ -754,7 +754,7 @@ TEST_F(EmbedderTest, RasterCacheDisabledWithPlatformViews) {
 
   setup.Wait();
   const flutter::Shell& shell = ToEmbedderEngine(engine.get())->GetShell();
-  shell.GetTaskRunners().GetGPUTaskRunner()->PostTask([&] {
+  shell.GetTaskRunners().GetRasterTaskRunner()->PostTask([&] {
     const flutter::RasterCache& raster_cache =
         shell.GetRasterizer()->compositor_context()->raster_cache();
     // 3 layers total, but one of them had the platform view. So the cache
@@ -826,7 +826,7 @@ TEST_F(EmbedderTest, RasterCacheEnabled) {
 
   setup.Wait();
   const flutter::Shell& shell = ToEmbedderEngine(engine.get())->GetShell();
-  shell.GetTaskRunners().GetGPUTaskRunner()->PostTask([&] {
+  shell.GetTaskRunners().GetRasterTaskRunner()->PostTask([&] {
     const flutter::RasterCache& raster_cache =
         shell.GetRasterizer()->compositor_context()->raster_cache();
     ASSERT_EQ(raster_cache.GetCachedEntriesCount(), 1u);

shell/platform/fuchsia/flutter/compositor_context.cc

@@ -103,7 +103,7 @@ CompositorContext::AcquireFrame(
     const SkMatrix& root_surface_transformation,
     bool instrumentation_enabled,
     bool surface_supports_readback,
-    fml::RefPtr<fml::GpuThreadMerger> gpu_thread_merger) {
+    fml::RefPtr<fml::RasterThreadMerger> raster_thread_merger) {
   // TODO: The AcquireFrame interface is too broad and must be refactored to get
   // rid of the context and canvas arguments as those seem to be only used for
   // colorspace correctness purposes on the mobile shells.

shell/platform/fuchsia/flutter/compositor_context.h

@@ -49,7 +49,7 @@ class CompositorContext final : public flutter::CompositorContext {
       const SkMatrix& root_surface_transformation,
       bool instrumentation_enabled,
       bool surface_supports_readback,
-      fml::RefPtr<fml::GpuThreadMerger> gpu_thread_merger) override;
+      fml::RefPtr<fml::RasterThreadMerger> raster_thread_merger) override;
 
   FML_DISALLOW_COPY_AND_ASSIGN(CompositorContext);
 };

shell/platform/fuchsia/flutter/engine.cc

@@ -38,7 +38,7 @@ static void UpdateNativeThreadLabelNames(const std::string& label,
   };
   set_thread_name(runners.GetPlatformTaskRunner(), label, ".platform");
   set_thread_name(runners.GetUITaskRunner(), label, ".ui");
-  set_thread_name(runners.GetGPUTaskRunner(), label, ".gpu");
+  set_thread_name(runners.GetRasterTaskRunner(), label, ".raster");
   set_thread_name(runners.GetIOTaskRunner(), label, ".io");
 }
 
@@ -474,7 +474,7 @@ void Engine::OnSessionMetricsDidChange(
     return;
   }
 
-  shell_->GetTaskRunners().GetGPUTaskRunner()->PostTask(
+  shell_->GetTaskRunners().GetRasterTaskRunner()->PostTask(
       [rasterizer = shell_->GetRasterizer(), metrics]() {
         if (rasterizer) {
           auto compositor_context =
@@ -491,7 +491,7 @@ void Engine::OnDebugWireframeSettingsChanged(bool enabled) {
     return;
   }
 
-  shell_->GetTaskRunners().GetGPUTaskRunner()->PostTask(
+  shell_->GetTaskRunners().GetRasterTaskRunner()->PostTask(
       [rasterizer = shell_->GetRasterizer(), enabled]() {
         if (rasterizer) {
           auto compositor_context =
@@ -509,7 +509,7 @@ void Engine::OnSessionSizeChangeHint(float width_change_factor,
     return;
   }
 
-  shell_->GetTaskRunners().GetGPUTaskRunner()->PostTask(
+  shell_->GetTaskRunners().GetRasterTaskRunner()->PostTask(
       [rasterizer = shell_->GetRasterizer(), width_change_factor,
        height_change_factor]() {
         if (rasterizer) {

shell/testing/tester_main.cc

@@ -109,7 +109,7 @@ int RunTester(const flutter::Settings& settings,
 
   std::unique_ptr<ThreadHost> threadhost;
   fml::RefPtr<fml::TaskRunner> platform_task_runner;
-  fml::RefPtr<fml::TaskRunner> gpu_task_runner;
+  fml::RefPtr<fml::TaskRunner> raster_task_runner;
   fml::RefPtr<fml::TaskRunner> ui_task_runner;
   fml::RefPtr<fml::TaskRunner> io_task_runner;
 
@@ -118,17 +118,17 @@ int RunTester(const flutter::Settings& settings,
         thread_label, ThreadHost::Type::Platform | ThreadHost::Type::IO |
                           ThreadHost::Type::UI | ThreadHost::Type::GPU);
     platform_task_runner = current_task_runner;
-    gpu_task_runner = threadhost->gpu_thread->GetTaskRunner();
+    raster_task_runner = threadhost->raster_thread->GetTaskRunner();
     ui_task_runner = threadhost->ui_thread->GetTaskRunner();
     io_task_runner = threadhost->io_thread->GetTaskRunner();
   } else {
-    platform_task_runner = gpu_task_runner = ui_task_runner = io_task_runner =
-        current_task_runner;
+    platform_task_runner = raster_task_runner = ui_task_runner =
+        io_task_runner = current_task_runner;
   }
 
   const flutter::TaskRunners task_runners(thread_label,  // dart thread label
                                           platform_task_runner,  // platform
-                                          gpu_task_runner,       // raster
+                                          raster_task_runner,    // raster
                                           ui_task_runner,        // ui
                                           io_task_runner         // io
   );