[Optimize][Clay] Precompile skity default shaders on clay.

This patch let clay pre-compile some default skity shaders immediately when
gl context is just created. This will reduce the first rasterizer task burdens.

AutoLand: release/3.8, release/3.9, release/4.0

SkipChecks:macro

issue: m-7336681683

Author: ci_lynx

clay/gfx/rendering_backend.h

@@ -90,6 +90,7 @@
 #include "skity/include/skity/text/font_manager.hpp"
 #include "skity/recorder/picture_recorder.hpp"
 #include "skity/render/canvas.hpp"
+#include "skity/render/precompile_context.hpp"
 #include "skity/text/font.hpp"
 #include "skity/text/text_blob.hpp"
 #endif  // ENABLE_SKITY

clay/shell/common/output_surface.cc

@@ -4,6 +4,9 @@
 
 #include "clay/shell/common/output_surface.h"
 
+#include "base/trace/native/trace_event.h"
+#include "clay/common/graphics/gl_context_switch.h"
+
 namespace clay {
 
 OutputSurface::~OutputSurface() = default;
@@ -12,4 +15,42 @@ void OutputSurface::CreateMainGrContext() {}
 
 clay::GrContextPtr OutputSurface::GetMainGrContext() { return nullptr; }
 
+std::unique_ptr<GLContextResult> OutputSurface::MakeCurrent() {
+  return std::make_unique<GLContextDefaultResult>(true);
+}
+
+#ifdef ENABLE_SKITY
+void OutputSurface::PrecompileDefaultSkityShaders() {
+  auto config = GetSkityPrecompileConfig();
+  if (!config) {
+    TRACE_EVENT("clay", "PrecompileDefaultSkityShaders config is null");
+    return;
+  }
+
+  clay::GrContextPtr main_context = GetMainGrContext();
+  if (!main_context) {
+    TRACE_EVENT("clay", "PrecompileDefaultSkityShaders main_context is null");
+    return;
+  }
+
+  auto context_switch = MakeCurrent();
+  if (!context_switch || !context_switch->GetResult()) {
+    TRACE_EVENT("clay", "PrecompileDefaultSkityShaders make current failed");
+    return;
+  }
+
+  TRACE_EVENT("clay", "PrecompileDefaultSkityShaders");
+  auto precompile_context = main_context->CreatePrecompileContext(
+      config->color_type, config->enable_msaa);
+  if (precompile_context) {
+    precompile_context->PrecompileDefaultShaders();
+  }
+}
+
+std::optional<OutputSurface::SkityPrecompileConfig>
+OutputSurface::GetSkityPrecompileConfig() const {
+  return std::nullopt;
+}
+#endif  // ENABLE_SKITY
+
 }  // namespace clay

clay/shell/common/output_surface.h

@@ -6,11 +6,13 @@
 #define CLAY_SHELL_COMMON_OUTPUT_SURFACE_H_
 
 #include <memory>
+#include <optional>
 
 #include "base/include/fml/memory/ref_counted.h"
 #include "clay/gfx/rendering_backend.h"
 
 namespace clay {
+class GLContextResult;
 class Surface;
 
 // OutputSurface is a ref counted object which is owned by platform thread and
@@ -24,10 +26,25 @@ class OutputSurface : public fml::RefCountedThreadSafe<OutputSurface> {
 
   virtual clay::GrContextPtr GetMainGrContext();
 
+  virtual std::unique_ptr<GLContextResult> MakeCurrent();
+
+#ifdef ENABLE_SKITY
+  void PrecompileDefaultSkityShaders();
+#endif
+
   virtual std::unique_ptr<Surface> CreateGPUSurface(
       clay::GrContext* gr_context = nullptr) = 0;
 
   virtual bool IsValid() const = 0;
+
+ protected:
+#ifdef ENABLE_SKITY
+  struct SkityPrecompileConfig {
+    skity::PrecompileColorType color_type;
+    bool enable_msaa = false;
+  };
+  virtual std::optional<SkityPrecompileConfig> GetSkityPrecompileConfig() const;
+#endif
 };
 
 }  // namespace clay

clay/shell/common/shell.cc

@@ -561,8 +561,13 @@ bool Shell::Setup(std::unique_ptr<PlatformView> platform_view,
         if (output_surface) {
           output_surface->CreateMainGrContext();
           clay::GrContextPtr main_context = output_surface->GetMainGrContext();
-          if (main_context && unref_queue) {
-            unref_queue->SetContext(main_context);
+          if (main_context) {
+#ifdef ENABLE_SKITY
+            output_surface->PrecompileDefaultSkityShaders();
+#endif  // ENABLE_SKITY
+            if (unref_queue) {
+              unref_queue->SetContext(main_context);
+            }
           }
         }
       });

clay/shell/platform/embedder/embedder_surface_gl.cc

@@ -99,4 +99,15 @@ clay::GrContextPtr EmbedderSurfaceGL::GetMainGrContext() {
   return main_context_;
 }
 
+std::unique_ptr<GLContextResult> EmbedderSurfaceGL::MakeCurrent() {
+  return GLContextMakeCurrent();
+}
+
+#ifdef ENABLE_SKITY
+std::optional<OutputSurface::SkityPrecompileConfig>
+EmbedderSurfaceGL::GetSkityPrecompileConfig() const {
+  return SkityPrecompileConfig{skity::PrecompileColorType::kRGBA, false};
+}
+#endif
+
 }  // namespace clay

clay/shell/platform/embedder/embedder_surface_gl.h

@@ -41,6 +41,15 @@ class EmbedderSurfaceGL final : public EmbedderSurface,
   // |GPUSurfaceGLDelegate|
   std::unique_ptr<GLContextResult> GLContextMakeCurrent() override;
 
+  // |OutputSurface|
+  std::unique_ptr<GLContextResult> MakeCurrent() override;
+
+#ifdef ENABLE_SKITY
+  // |OutputSurface|
+  std::optional<SkityPrecompileConfig> GetSkityPrecompileConfig()
+      const override;
+#endif
+
   // |GPUSurfaceGLDelegate|
   bool GLContextClearCurrent() override;
 

clay/shell/platform/embedder/embedder_surface_metal.h

@@ -53,6 +53,12 @@ class EmbedderSurfaceMetal final : public EmbedderSurface,
   // |OutputSurface|
   clay::GrContextPtr GetMainGrContext() override;
 
+#ifdef ENABLE_SKITY
+  // |OutputSurface|
+  std::optional<SkityPrecompileConfig> GetSkityPrecompileConfig()
+      const override;
+#endif
+
   // |GPUSurfaceMetalDelegate|
   GPUCAMetalLayerHandle GetCAMetalLayer(
       const skity::Vec2& frame_size) const override;

clay/shell/platform/embedder/embedder_surface_metal.mm

@@ -25,6 +25,20 @@
 FLUTTER_ASSERT_ARC
 namespace clay {
 
+namespace {
+
+#ifdef ENABLE_SKITY
+constexpr MsaaSampleCount GetSkityMetalMsaaSampleCount() {
+#if defined(OS_OSX)
+  return MsaaSampleCount::kFour;
+#else
+  return MsaaSampleCount::kNone;
+#endif
+}
+#endif  // ENABLE_SKITY
+
+}  // namespace
+
 EmbedderSurfaceMetal::EmbedderSurfaceMetal(EmbedderSurfaceMetalDelegate* delegate)
     : GPUSurfaceMetalDelegate(MTLRenderTargetType::kMTLTexture), delegate_(delegate) {
 #ifndef ENABLE_SKITY
@@ -45,6 +59,14 @@
 
 clay::GrContextPtr EmbedderSurfaceMetal::GetMainGrContext() { return main_context_; }
 
+#ifdef ENABLE_SKITY
+std::optional<OutputSurface::SkityPrecompileConfig> EmbedderSurfaceMetal::GetSkityPrecompileConfig()
+    const {
+  return SkityPrecompileConfig{skity::PrecompileColorType::kBGRA,
+                               GetSkityMetalMsaaSampleCount() != MsaaSampleCount::kNone};
+}
+#endif  // ENABLE_SKITY
+
 EmbedderSurfaceMetal::~EmbedderSurfaceMetal() = default;
 
 bool EmbedderSurfaceMetal::IsValid() const { return valid_; }
@@ -74,12 +96,7 @@
   }
   auto surface = std::make_unique<GPUSurfaceMetalSkity>(
       this, context ? std::shared_ptr<clay::GrContext>(context) : main_context_,
-#if defined(OS_OSX)
-      MsaaSampleCount::kFour,
-#else
-      MsaaSampleCount::kNone,
-#endif
-      true);
+      GetSkityMetalMsaaSampleCount(), true);
 
   if (!surface->IsValid()) {
     return nullptr;