Refactor renderer to support vulkan extensions

flutter/shell/platform/tizen/BUILD.gn

@@ -115,6 +115,7 @@ template("embedder") {
       "tizen_renderer.cc",
       "tizen_renderer_egl.cc",
       "tizen_renderer_evas_gl.cc",
+      "tizen_renderer_gl.cc",
       "tizen_view_elementary.cc",
       "tizen_vsync_waiter.cc",
       "tizen_window_ecore_wl2.cc",
@@ -171,6 +172,7 @@ template("embedder") {
       sources += [
         "flutter_tizen_nui.cc",
         "tizen_clipboard.cc",
+        "tizen_renderer_nui_gl.cc",
         "tizen_view_nui.cc",
       ]
 
@@ -229,7 +231,7 @@ embedder("flutter_tizen_common") {
 embedder("flutter_tizen_source") {
   target_type = "source_set"
 
-  defines = []
+  defines = [ "UNIT_TESTS" ]
 }
 
 executable("flutter_tizen_unittests") {

flutter/shell/platform/tizen/flutter_tizen.cc

@@ -214,12 +214,9 @@ FlutterDesktopViewRef FlutterDesktopViewCreateFromNewWindow(
 
   auto view = std::make_unique<flutter::FlutterTizenView>(
       flutter::kImplicitViewId, std::move(window),
-      window_properties.user_pixel_ratio);
+      std::unique_ptr<flutter::FlutterTizenEngine>(EngineFromHandle(engine)),
+      window_properties.renderer_type, window_properties.user_pixel_ratio);
 
-  // Take ownership of the engine, starting it if necessary.
-  view->SetEngine(
-      std::unique_ptr<flutter::FlutterTizenEngine>(EngineFromHandle(engine)));
-  view->CreateRenderSurface(window_properties.renderer_type);
   if (!view->engine()->IsRunning()) {
     if (!view->engine()->RunEngine()) {
       return nullptr;

flutter/shell/platform/tizen/flutter_tizen_elementary.cc

@@ -31,12 +31,10 @@ FlutterDesktopViewRef FlutterDesktopViewCreateFromElmParent(
           static_cast<Evas_Object*>(parent));
 
   auto view = std::make_unique<flutter::FlutterTizenView>(
-      flutter::kImplicitViewId, std::move(tizen_view));
+      flutter::kImplicitViewId, std::move(tizen_view),
+      std::unique_ptr<flutter::FlutterTizenEngine>(EngineFromHandle(engine)),
+      FlutterDesktopRendererType::kEvasGL);
 
-  // Take ownership of the engine, starting it if necessary.
-  view->SetEngine(
-      std::unique_ptr<flutter::FlutterTizenEngine>(EngineFromHandle(engine)));
-  view->CreateRenderSurface(FlutterDesktopRendererType::kEvasGL);
   if (!view->engine()->IsRunning()) {
     if (!view->engine()->RunEngine()) {
       return nullptr;

flutter/shell/platform/tizen/flutter_tizen_engine.cc

@@ -19,6 +19,11 @@
 #include "flutter/shell/platform/tizen/tizen_renderer_egl.h"
 #include "flutter/shell/platform/tizen/tizen_renderer_evas_gl.h"
 
+#ifdef NUI_SUPPORT
+#include "flutter/shell/platform/tizen/tizen_renderer_nui_gl.h"
+#include "flutter/shell/platform/tizen/tizen_view_nui.h"
+#endif
+
 namespace flutter {
 
 namespace {
@@ -79,23 +84,22 @@ FlutterTizenEngine::~FlutterTizenEngine() {
   StopEngine();
 }
 
-void FlutterTizenEngine::CreateRenderer(
+std::unique_ptr<TizenRenderer> FlutterTizenEngine::CreateRenderer(
     FlutterDesktopRendererType renderer_type) {
-  if (renderer_type == FlutterDesktopRendererType::kEvasGL) {
-    renderer_ = std::make_unique<TizenRendererEvasGL>();
-
-    render_loop_ = std::make_unique<TizenRenderEventLoop>(
-        std::this_thread::get_id(),  // main thread
-        embedder_api_.GetCurrentTime,
-        [this](const auto* task) {
-          if (embedder_api_.RunTask(this->engine_, task) != kSuccess) {
-            FT_LOG(Error) << "Could not post an engine task.";
-          }
-        },
-        renderer_.get());
-  } else {
-    renderer_ = std::make_unique<TizenRendererEgl>(
-        project_->HasArgument("--enable-impeller"));
+  switch (renderer_type) {
+    case FlutterDesktopRendererType::kEvasGL:
+      return std::make_unique<TizenRendererEvasGL>(view_->tizen_view());
+    case FlutterDesktopRendererType::kEGL:
+#ifdef NUI_SUPPORT
+      if (auto* nui_view =
+              dynamic_cast<flutter::TizenViewNui*>(view_->tizen_view())) {
+        return std::make_unique<TizenRendererNuiGL>(
+            dynamic_cast<flutter::TizenViewNui*>(view_->tizen_view()),
+            project_->HasArgument("--enable-impeller"));
+      }
+#endif
+      return std::make_unique<TizenRendererEgl>(
+          view_->tizen_view(), project_->HasArgument("--enable-impeller"));
   }
 }
 
@@ -244,8 +248,7 @@ bool FlutterTizenEngine::RunEngine() {
       internal_plugin_registrar_->messenger());
 
   if (IsHeaded()) {
-    texture_registrar_ = std::make_unique<FlutterTizenTextureRegistrar>(
-        this, project_->HasArgument("--enable-impeller"));
+    texture_registrar_ = std::make_unique<FlutterTizenTextureRegistrar>(this);
     keyboard_channel_ = std::make_unique<KeyboardChannel>(
         internal_plugin_registrar_->messenger(),
         [this](const FlutterKeyEvent& event, FlutterKeyEventCallback callback,
@@ -294,8 +297,22 @@ bool FlutterTizenEngine::StopEngine() {
   return false;
 }
 
-void FlutterTizenEngine::SetView(FlutterTizenView* view) {
+void FlutterTizenEngine::SetView(FlutterTizenView* view,
+                                 FlutterDesktopRendererType renderer_type) {
   view_ = view;
+  renderer_ = CreateRenderer(renderer_type);
+
+  if (renderer_type == FlutterDesktopRendererType::kEvasGL) {
+    render_loop_ = std::make_unique<TizenRenderEventLoop>(
+        std::this_thread::get_id(),  // main thread
+        embedder_api_.GetCurrentTime,
+        [this](const auto* task) {
+          if (embedder_api_.RunTask(this->engine_, task) != kSuccess) {
+            FT_LOG(Error) << "Could not post an engine task.";
+          }
+        },
+        renderer_.get());
+  }
 }
 
 void FlutterTizenEngine::AddPluginRegistrarDestructionCallback(
@@ -435,79 +452,17 @@ FlutterDesktopMessage FlutterTizenEngine::ConvertToDesktopMessage(
 }
 
 FlutterRendererConfig FlutterTizenEngine::GetRendererConfig() {
-  FlutterRendererConfig config = {};
   if (IsHeaded()) {
-    config.type = kOpenGL;
-    config.open_gl.struct_size = sizeof(config.open_gl);
-    config.open_gl.make_current = [](void* user_data) -> bool {
-      auto* engine = static_cast<FlutterTizenEngine*>(user_data);
-      if (!engine->view()) {
-        return false;
-      }
-      return engine->view()->OnMakeCurrent();
-    };
-    config.open_gl.make_resource_current = [](void* user_data) -> bool {
-      auto* engine = static_cast<FlutterTizenEngine*>(user_data);
-      if (!engine->view()) {
-        return false;
-      }
-      return engine->view()->OnMakeResourceCurrent();
-    };
-    config.open_gl.clear_current = [](void* user_data) -> bool {
-      auto* engine = static_cast<FlutterTizenEngine*>(user_data);
-      if (!engine->view()) {
-        return false;
-      }
-      return engine->view()->OnClearCurrent();
-    };
-    config.open_gl.present = [](void* user_data) -> bool {
-      auto* engine = static_cast<FlutterTizenEngine*>(user_data);
-      if (!engine->view()) {
-        return false;
-      }
-      return engine->view()->OnPresent();
-    };
-    config.open_gl.fbo_callback = [](void* user_data) -> uint32_t {
-      auto* engine = static_cast<FlutterTizenEngine*>(user_data);
-      if (!engine->view()) {
-        return false;
-      }
-      return engine->view()->OnGetFBO();
-    };
-    config.open_gl.surface_transformation =
-        [](void* user_data) -> FlutterTransformation {
-      auto* engine = static_cast<FlutterTizenEngine*>(user_data);
-      if (!engine->view()) {
-        return FlutterTransformation();
-      }
-      return engine->view()->GetFlutterTransformation();
-    };
-    config.open_gl.gl_proc_resolver = [](void* user_data,
-                                         const char* name) -> void* {
-      auto* engine = static_cast<FlutterTizenEngine*>(user_data);
-      if (!engine->view()) {
-        return nullptr;
-      }
-      return engine->view()->OnProcResolver(name);
-    };
-    config.open_gl.gl_external_texture_frame_callback =
-        [](void* user_data, int64_t texture_id, size_t width, size_t height,
-           FlutterOpenGLTexture* texture) -> bool {
-      auto* engine = static_cast<FlutterTizenEngine*>(user_data);
-      if (!engine->texture_registrar()) {
-        return false;
-      }
-      return engine->texture_registrar()->PopulateTexture(texture_id, width,
-                                                          height, texture);
-    };
+    return renderer()->GetRendererConfig();
   } else {
+    FlutterRendererConfig config = {};
     config.type = kSoftware;
     config.software.struct_size = sizeof(config.software);
     config.software.surface_present_callback =
         [](void* user_data, const void* allocation, size_t row_bytes,
            size_t height) -> bool { return true; };
+    return config;
   }
-  return config;
 }
 
 void FlutterTizenEngine::DispatchAccessibilityAction(

flutter/shell/platform/tizen/flutter_tizen_engine.h

@@ -63,7 +63,8 @@ class FlutterTizenEngine {
   FlutterTizenEngine& operator=(FlutterTizenEngine const&) = delete;
 
   // Creates a GL renderer from the given type.
-  void CreateRenderer(FlutterDesktopRendererType renderer_type);
+  std::unique_ptr<TizenRenderer> CreateRenderer(
+      FlutterDesktopRendererType renderer_type);
 
   // Starts running the engine with the given entrypoint. If null, defaults to
   // main().
@@ -78,7 +79,8 @@ class FlutterTizenEngine {
   bool StopEngine();
 
   // Sets the view that is displaying this engine's content.
-  void SetView(FlutterTizenView* view);
+  void SetView(FlutterTizenView* view,
+               FlutterDesktopRendererType renderer_type);
 
   // The view displaying this engine's content, if any. This will be null for
   // headless engines.

flutter/shell/platform/tizen/flutter_tizen_nui.cc

@@ -40,12 +40,10 @@ FlutterDesktopViewRef FlutterDesktopViewCreateFromImageView(
           default_window_id);
 
   auto view = std::make_unique<flutter::FlutterTizenView>(
-      flutter::kImplicitViewId, std::move(tizen_view));
+      flutter::kImplicitViewId, std::move(tizen_view),
+      std::unique_ptr<flutter::FlutterTizenEngine>(EngineFromHandle(engine)),
+      FlutterDesktopRendererType::kEGL);
 
-  // Take ownership of the engine, starting it if necessary.
-  view->SetEngine(
-      std::unique_ptr<flutter::FlutterTizenEngine>(EngineFromHandle(engine)));
-  view->CreateRenderSurface(FlutterDesktopRendererType::kEGL);
   if (!view->engine()->IsRunning()) {
     if (!view->engine()->RunEngine()) {
       return nullptr;

flutter/shell/platform/tizen/flutter_tizen_texture_registrar.cc

@@ -20,9 +20,8 @@
 namespace flutter {
 
 FlutterTizenTextureRegistrar::FlutterTizenTextureRegistrar(
-    FlutterTizenEngine* engine,
-    bool enable_impeller)
-    : engine_(engine), enable_impeller_(enable_impeller) {}
+    FlutterTizenEngine* engine)
+    : engine_(engine) {}
 
 int64_t FlutterTizenTextureRegistrar::RegisterTexture(
     const FlutterDesktopTextureInfo* texture_info) {
@@ -45,12 +44,19 @@ int64_t FlutterTizenTextureRegistrar::RegisterTexture(
       return -1;
     }
   }
-  FlutterDesktopRendererType renderer_type = FlutterDesktopRendererType::kEGL;
-  if (dynamic_cast<TizenRendererEvasGL*>(engine_->renderer())) {
-    renderer_type = FlutterDesktopRendererType::kEvasGL;
+  std::unique_ptr<ExternalTexture> texture_gl = nullptr;
+
+#ifndef UNIT_TESTS
+  if (engine_->renderer()) {
+    texture_gl = engine_->renderer()->CreateExternalTexture(texture_info);
   }
-  std::unique_ptr<ExternalTexture> texture_gl =
-      CreateExternalTexture(texture_info, renderer_type);
+#else
+  texture_gl = std::make_unique<ExternalTextureSurfaceEGL>(
+      ExternalTextureExtensionType::kDmaBuffer,
+      texture_info->gpu_surface_config.callback,
+      texture_info->gpu_surface_config.user_data);
+#endif
+
   if (!texture_gl) {
     FT_LOG(Error) << "Failed to create ExternalTexture.";
     return -1;
@@ -100,52 +106,4 @@ bool FlutterTizenTextureRegistrar::PopulateTexture(
   return texture->PopulateTexture(width, height, opengl_texture);
 }
 
-std::unique_ptr<ExternalTexture>
-FlutterTizenTextureRegistrar::CreateExternalTexture(
-    const FlutterDesktopTextureInfo* texture_info,
-    FlutterDesktopRendererType renderer_type) {
-  switch (texture_info->type) {
-    case kFlutterDesktopPixelBufferTexture:
-      if (renderer_type == FlutterDesktopRendererType::kEvasGL) {
-        return std::make_unique<ExternalTexturePixelEvasGL>(
-            texture_info->pixel_buffer_config.callback,
-            texture_info->pixel_buffer_config.user_data);
-      }
-      if (enable_impeller_) {
-        return std::make_unique<ExternalTexturePixelEGLImpeller>(
-            texture_info->pixel_buffer_config.callback,
-            texture_info->pixel_buffer_config.user_data);
-      } else {
-        return std::make_unique<ExternalTexturePixelEGL>(
-            texture_info->pixel_buffer_config.callback,
-            texture_info->pixel_buffer_config.user_data);
-      }
-    case kFlutterDesktopGpuSurfaceTexture:
-      ExternalTextureExtensionType gl_extension =
-          ExternalTextureExtensionType::kNone;
-      if (engine_->renderer() && engine_->renderer()->IsSupportedExtension(
-                                     "EGL_TIZEN_image_native_surface")) {
-        gl_extension = ExternalTextureExtensionType::kNativeSurface;
-      } else if (engine_->renderer() &&
-                 engine_->renderer()->IsSupportedExtension(
-                     "EGL_EXT_image_dma_buf_import")) {
-        gl_extension = ExternalTextureExtensionType::kDmaBuffer;
-      }
-      if (renderer_type == FlutterDesktopRendererType::kEvasGL) {
-        return std::make_unique<ExternalTextureSurfaceEvasGL>(
-            gl_extension, texture_info->gpu_surface_config.callback,
-            texture_info->gpu_surface_config.user_data);
-      }
-      if (enable_impeller_) {
-        return std::make_unique<ExternalTextureSurfaceEGLImpeller>(
-            gl_extension, texture_info->gpu_surface_config.callback,
-            texture_info->gpu_surface_config.user_data);
-      } else {
-        return std::make_unique<ExternalTextureSurfaceEGL>(
-            gl_extension, texture_info->gpu_surface_config.callback,
-            texture_info->gpu_surface_config.user_data);
-      }
-  }
-}
-
 }  // namespace flutter

flutter/shell/platform/tizen/flutter_tizen_texture_registrar.h

@@ -20,8 +20,7 @@ class FlutterTizenEngine;
 // Thread safety: All member methods are thread safe.
 class FlutterTizenTextureRegistrar {
  public:
-  explicit FlutterTizenTextureRegistrar(FlutterTizenEngine* engine,
-                                        bool enable_impeller);
+  explicit FlutterTizenTextureRegistrar(FlutterTizenEngine* engine);
 
   // Registers a texture described by the given |texture_info| object.
   //
@@ -47,17 +46,12 @@ class FlutterTizenTextureRegistrar {
                        size_t height,
                        FlutterOpenGLTexture* texture);
 
-  std::unique_ptr<ExternalTexture> CreateExternalTexture(
-      const FlutterDesktopTextureInfo* info,
-      FlutterDesktopRendererType renderer_type);
-
  private:
   FlutterTizenEngine* engine_ = nullptr;
 
   // All registered textures, keyed by their IDs.
   std::unordered_map<int64_t, std::unique_ptr<ExternalTexture>> textures_;
   std::mutex map_mutex_;
-  bool enable_impeller_ = false;
 };
 
 }  // namespace flutter