[fuchsia] implement SKP based shader warmup

Make Engine load all .skp files from persistent cache and draw them on
an offscreen surface to warm up shaders.

Author: freiling

shell/platform/fuchsia/flutter/compositor_context.cc

@@ -145,7 +145,13 @@ CompositorContext::CompositorContext(
     flutter::SceneUpdateContext& scene_update_context)
     : session_connection_(session_connection),
       surface_producer_(surface_producer),
-      scene_update_context_(scene_update_context) {}
+      scene_update_context_(scene_update_context) {
+        SkISize size = SkISize::Make(1024, 600);
+        skp_warmup_surface_ = surface_producer_.ProduceOffscreenSurface(size);
+        if (!skp_warmup_surface_) {
+          FML_LOG(ERROR) << "SkSurface::MakeRenderTarget returned null";
+  }
+      }
 
 CompositorContext::~CompositorContext() = default;
 
@@ -164,4 +170,9 @@ CompositorContext::AcquireFrame(
       session_connection_, surface_producer_, scene_update_context_);
 }
 
+void CompositorContext::WarmupSkp(const sk_sp<SkPicture> picture) {
+  skp_warmup_surface_->getCanvas()->drawPicture(picture);
+  surface_producer_.gr_context()->flush();
+}
+
 }  // namespace flutter_runner

shell/platform/fuchsia/flutter/compositor_context.h

@@ -26,11 +26,14 @@ class CompositorContext final : public flutter::CompositorContext {
                     flutter::SceneUpdateContext& scene_update_context);
 
   ~CompositorContext() override;
+  void WarmupSkp(sk_sp<SkPicture> picture);
 
  private:
   SessionConnection& session_connection_;
   VulkanSurfaceProducer& surface_producer_;
   flutter::SceneUpdateContext& scene_update_context_;
+  sk_sp<SkSurface> skp_warmup_surface_;
+
 
   // |flutter::CompositorContext|
   std::unique_ptr<ScopedFrame> AcquireFrame(

shell/platform/fuchsia/flutter/engine.cc

@@ -13,13 +13,16 @@
 #include "flutter/fml/synchronization/waitable_event.h"
 #include "flutter/fml/task_runner.h"
 #include "flutter/runtime/dart_vm_lifecycle.h"
+#include "flutter/shell/common/persistent_cache.h"
 #include "flutter/shell/common/rasterizer.h"
 #include "flutter/shell/common/run_configuration.h"
 #include "third_party/skia/include/ports/SkFontMgr_fuchsia.h"
-
+#include "flutter/shell/common/serialization_callbacks.h"
 #include "flutter_runner_product_configuration.h"
 #include "fuchsia_external_view_embedder.h"
 #include "fuchsia_intl.h"
+#include "include/core/SkPicture.h"
+#include "include/core/SkSerialProcs.h"
 #include "platform_view.h"
 #include "surface.h"
 #include "task_runner_adapter.h"
@@ -237,14 +240,95 @@ Engine::Engine(Delegate& delegate,
           std::make_unique<flutter_runner::CompositorContext>(
               session_connection_.value(), surface_producer_.value(),
               legacy_external_view_embedder_.value());
+
+      // tell concurrent task runner to deserialize all skps available from
+      // the asset manager
+      shell.GetDartVM()->GetConcurrentMessageLoop()->GetTaskRunner()->PostTask([raster_task_runner =
+                      shell.GetTaskRunners().GetRasterTaskRunner(),
+                  compositor_context = compositor_context.get()]() {
+        TRACE_DURATION("flutter", "DeserializeSkps");
+        std::vector<std::unique_ptr<fml::Mapping>> skp_mappings =
+            flutter::PersistentCache::GetCacheForProcess()
+                ->GetSkpsFromAssetManager();
+        std::vector<sk_sp<SkPicture>> pictures;
+        int i = 0;
+        for (auto& mapping : skp_mappings) {
+          
+          std::unique_ptr<SkMemoryStream> stream =
+              SkMemoryStream::MakeDirect(mapping->GetMapping(),
+                                          mapping->GetSize());
+          SkDeserialProcs procs = {0};
+          procs.fImageProc = flutter::DeserializeImageWithoutData;
+          procs.fTypefaceProc = flutter::DeserializeTypefaceWithoutData;
+          sk_sp<SkPicture> picture =
+              SkPicture::MakeFromStream(stream.get(), &procs);
+          if (!picture) {
+            FML_LOG(ERROR) << "Failed to deserialize picture " << i;
+            continue;
+          }
+
+          // Tell raster task runner to warmup have the compositor
+          // context warm up the newly deserialized picture
+          raster_task_runner->PostTask([compositor_context, picture] {
+            TRACE_DURATION("flutter", "WarmupSkp");
+            compositor_context->WarmupSkp(picture);
+          });
+          i++;
+        }
+      });
+
       return std::make_unique<flutter::Rasterizer>(
           shell, std::move(compositor_context));
     } else {
       return std::make_unique<flutter::Rasterizer>(shell);
     }
   };
 #else
-  on_create_rasterizer = [](flutter::Shell& shell) {
+  on_create_rasterizer = [this](flutter::Shell& shell) {
+      FML_DCHECK(surface_producer_);
+
+      SkISize size = SkISize::Make(1024, 600);
+      auto skp_warmup_surface = surface_producer_->ProduceOffscreenSurface(size);
+      if (!skp_warmup_surface) {
+        FML_LOG(ERROR) << "SkSurface::MakeRenderTarget returned null";
+        return std::make_unique<flutter::Rasterizer>(shell);
+      }
+
+      // tell concurrent task runner to deserialize all skps available from
+      // the asset manager
+      shell.GetDartVM()->GetConcurrentMessageLoop()->GetTaskRunner()->PostTask([raster_task_runner =
+                      shell.GetTaskRunners().GetRasterTaskRunner(), skp_warmup_surface, this]() {
+        TRACE_DURATION("flutter", "DeserializeSkps");
+        std::vector<std::unique_ptr<fml::Mapping>> skp_mappings =
+            flutter::PersistentCache::GetCacheForProcess()
+                ->GetSkpsFromAssetManager();
+        std::vector<sk_sp<SkPicture>> pictures;
+        int i = 0;
+        for (auto& mapping : skp_mappings) {
+          std::unique_ptr<SkMemoryStream> stream =
+              SkMemoryStream::MakeDirect(mapping->GetMapping(),
+                                          mapping->GetSize());
+          SkDeserialProcs procs = {0};
+          procs.fImageProc = flutter::DeserializeImageWithoutData;
+          procs.fTypefaceProc = flutter::DeserializeTypefaceWithoutData;
+          sk_sp<SkPicture> picture =
+              SkPicture::MakeFromStream(stream.get(), &procs);
+          if (!picture) {
+            FML_LOG(ERROR) << "Failed to deserialize picture " << i;
+            continue;
+          }
+
+          // Tell raster task runner to warmup have the compositor
+          // context warm up the newly deserialized picture
+          raster_task_runner->PostTask([skp_warmup_surface, picture, this] {
+            TRACE_DURATION("flutter", "WarmupSkp");
+            skp_warmup_surface->getCanvas()->drawPicture(picture);
+            surface_producer_->gr_context()->flush();
+          });
+          i++;
+        }
+      });
+      
     return std::make_unique<flutter::Rasterizer>(shell);
   };
 #endif

shell/platform/fuchsia/flutter/vulkan_surface_pool.h

@@ -26,6 +26,7 @@ class VulkanSurfacePool final {
 
   ~VulkanSurfacePool();
 
+  std::unique_ptr<VulkanSurface> CreateSurface(const SkISize& size);
   std::unique_ptr<VulkanSurface> AcquireSurface(const SkISize& size);
 
   void SubmitSurface(std::unique_ptr<SurfaceProducerSurface> surface);
@@ -49,7 +50,6 @@ class VulkanSurfacePool final {
 
   std::unique_ptr<VulkanSurface> GetCachedOrCreateSurface(const SkISize& size);
 
-  std::unique_ptr<VulkanSurface> CreateSurface(const SkISize& size);
 
   void RecycleSurface(std::unique_ptr<VulkanSurface> surface);
 

shell/platform/fuchsia/flutter/vulkan_surface_producer.cc

@@ -271,4 +271,9 @@ void VulkanSurfaceProducer::SubmitSurface(
   surface_pool_->SubmitSurface(std::move(surface));
 }
 
+sk_sp<SkSurface> VulkanSurfaceProducer::ProduceOffscreenSurface(const SkISize& size){
+  return surface_pool_->CreateSurface(size)->GetSkiaSurface();
+}
+
+
 }  // namespace flutter_runner

shell/platform/fuchsia/flutter/vulkan_surface_producer.h

@@ -34,6 +34,9 @@ class VulkanSurfaceProducer final : public SurfaceProducer,
   // |SurfaceProducer|
   std::unique_ptr<SurfaceProducerSurface> ProduceSurface(
       const SkISize& size) override;
+  
+  sk_sp<SkSurface> ProduceOffscreenSurface(const SkISize& size);
+
 
   // |SurfaceProducer|
   void SubmitSurface(std::unique_ptr<SurfaceProducerSurface> surface) override;