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

This PR touches variable names, class names, and file names so it's significantly more risky than its predecessor flutter#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,15 +51,15 @@ 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),
       view_embedder_(view_embedder),
       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,31 +4,31 @@
 
 #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()),
       lease_term_(kLeaseNotSet) {
   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_);
     lease_term_ = 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