[Tizen] Re-implemented render external texture gl for impeller to avoid change FlutterOpenGLTexture and use deprecated api (#26)

We have supported render external texture gl for Impeller
flutter-tizen/engine#368
But this PR has two issues:
1. It modify FlutterOpenGLTexture, it added additional variables, not a
good design.
```C++
  /// The pixel data buffer.
  const uint8_t* buffer;
  /// The size of pixel buffer.
  size_t buffer_size;
  /// Callback invoked that the gpu surface texture start binding.
  BoolCallback bind_callback;
  /// The type of the texture.
  FlutterGLImpellerTextureType impeller_texture_type;
```
2. It uses Deprecated API
```C++
  // Deprecated: use BlitPass::AddCopy instead.
  [[nodiscard]] bool SetContents(const uint8_t* contents,
                                 size_t length,
                                 size_t slice = 0,
                                 bool is_opaque = false);

```

So I tried to revert offical PR to render external gl for impeller
flutter/engine#56277
But this PR doesn't work on Tizen platform, I think This PR may not have
been verified.
To avoid change FlutterOpenGLTexture and use deprecated api, so I
re-implemented render external texture gl for impeller based on this
offical PR.
Fix flutter-tizen/embedder#131

<!--
Thanks for filing a pull request!
Reviewers are typically assigned within a week of filing a request.
To learn more about code review, see our documentation on Tree Hygiene:
https://github.com/flutter/flutter/blob/main/docs/contributing/Tree-hygiene.md
-->

*Replace this paragraph with a description of what this PR is changing
or adding, and why. Consider including before/after screenshots.*

*List which issues are fixed by this PR. You must list at least one
issue. An issue is not required if the PR fixes something trivial like a
typo.*

*If you had to change anything in the [flutter/tests] repo, include a
link to the migration guide as per the [breaking change policy].*

## Pre-launch Checklist

- [ ] I read the [Contributor Guide] and followed the process outlined
there for submitting PRs.
- [ ] I read the [Tree Hygiene] wiki page, which explains my
responsibilities.
- [ ] I read and followed the [Flutter Style Guide], including [Features
we expect every widget to implement].
- [ ] I signed the [CLA].
- [ ] I listed at least one issue that this PR fixes in the description
above.
- [ ] I updated/added relevant documentation (doc comments with `///`).
- [ ] I added new tests to check the change I am making, or this PR is
[test-exempt].
- [ ] I followed the [breaking change policy] and added [Data Driven
Fixes] where supported.
- [ ] All existing and new tests are passing.

If you need help, consider asking for advice on the #hackers-new channel
on [Discord].

**Note**: The Flutter team is currently trialing the use of [Gemini Code
Assist for
GitHub](https://developers.google.com/gemini-code-assist/docs/review-github-code).
Comments from the `gemini-code-assist` bot should not be taken as
authoritative feedback from the Flutter team. If you find its comments
useful you can update your code accordingly, but if you are unsure or
disagree with the feedback, please feel free to wait for a Flutter team
member's review for guidance on which automated comments should be
addressed.

<!-- Links -->
[Contributor Guide]:
https://github.com/flutter/flutter/blob/main/docs/contributing/Tree-hygiene.md#overview
[Tree Hygiene]:
https://github.com/flutter/flutter/blob/main/docs/contributing/Tree-hygiene.md
[test-exempt]:
https://github.com/flutter/flutter/blob/main/docs/contributing/Tree-hygiene.md#tests
[Flutter Style Guide]:
https://github.com/flutter/flutter/blob/main/docs/contributing/Style-guide-for-Flutter-repo.md
[Features we expect every widget to implement]:
https://github.com/flutter/flutter/blob/main/docs/contributing/Style-guide-for-Flutter-repo.md#features-we-expect-every-widget-to-implement
[CLA]: https://cla.developers.google.com/
[flutter/tests]: https://github.com/flutter/tests
[breaking change policy]:
https://github.com/flutter/flutter/blob/main/docs/contributing/Tree-hygiene.md#handling-breaking-changes
[Discord]:
https://github.com/flutter/flutter/blob/main/docs/contributing/Chat.md
[Data Driven Fixes]:
https://github.com/flutter/flutter/blob/main/docs/contributing/Data-driven-Fixes.md

Author: xiaowei-guan

engine/src/flutter/shell/platform/embedder/embedder.h

@@ -405,7 +405,6 @@ typedef struct {
 } FlutterTransformation;
 
 typedef void (*VoidCallback)(void* /* user data */);
-typedef bool (*BoolCallback)(void* /* user data */);
 
 typedef enum {
   /// Specifies an OpenGL texture target type. Textures are specified using
@@ -513,13 +512,6 @@ typedef struct {
   uint32_t name;
   /// The texture format (example GL_RGBA8).
   uint32_t format;
-  /// The pixel data buffer.
-  const uint8_t* buffer;
-  /// The size of pixel buffer.
-  size_t buffer_size;
-  /// Callback invoked that the gpu surface texture start binding.
-  BoolCallback bind_callback;
-
   /// User data to be returned on the invocation of the destruction callback.
   void* user_data;
   /// Callback invoked (on an engine managed thread) that asks the embedder to
@@ -613,6 +605,7 @@ typedef struct {
   uint32_t format;
 } FlutterOpenGLSurface;
 
+typedef bool (*BoolCallback)(void* /* user data */);
 typedef FlutterTransformation (*TransformationCallback)(void* /* user data */);
 typedef uint32_t (*UIntCallback)(void* /* user data */);
 typedef bool (*SoftwareSurfacePresentCallback)(void* /* user data */,

engine/src/flutter/shell/platform/embedder/embedder_external_texture_gl.cc

@@ -27,6 +27,88 @@
 
 namespace flutter {
 
+std::optional<TextureLRU::Data> TextureLRU::FindTexture(
+    std::optional<GLuint> key) {
+  if (!key.has_value()) {
+    return std::nullopt;
+  }
+  auto key_value = key.value();
+  for (size_t i = 0u; i < kTextureMaxSize; i++) {
+    if (textures_[i].key == key_value) {
+      UpdateTexture(Data{.key = key_value,
+                         .texture = textures_[i].texture,
+                         .width = textures_[i].width,
+                         .height = textures_[i].height});
+      return std::make_optional(textures_[i]);
+    }
+  }
+  return std::nullopt;
+}
+
+void TextureLRU::UpdateTexture(Data data) {
+  if (textures_[0].key == data.key) {
+    textures_[0] = data;
+    return;
+  }
+  size_t i = 1u;
+  for (; i < kTextureMaxSize; i++) {
+    if (textures_[i].key == data.key) {
+      break;
+    }
+  }
+
+  if (i == kTextureMaxSize) {
+    return;
+  }
+
+  for (auto j = i; j > 0; j--) {
+    textures_[j] = textures_[j - 1];
+  }
+  textures_[0] = data;
+}
+
+GLuint TextureLRU::AddTexture(Data data) {
+  GLuint lru_key = textures_[kTextureMaxSize - 1].key;
+  bool updated_image = false;
+  for (size_t i = 0u; i < kTextureMaxSize; i++) {
+    if (textures_[i].key == lru_key) {
+      updated_image = true;
+      textures_[i] = data;
+      break;
+    }
+  }
+  if (!updated_image) {
+    textures_[0] = data;
+  }
+  UpdateTexture(data);
+  return lru_key;
+}
+
+void TextureLRU::Clear() {
+  for (size_t i = 0u; i < kTextureMaxSize; i++) {
+    textures_[i] = Data{.key = 0u, .texture = nullptr};
+  }
+}
+
+void TextureLRU::RemoveTexture(GLuint key) {
+  size_t i = 0u;
+  for (; i < kTextureMaxSize; i++) {
+    if (textures_[i].key == key) {
+      break;
+    }
+  }
+
+  if (i == kTextureMaxSize) {
+    return;
+  }
+
+  for (; i < kTextureMaxSize - 1; i++) {
+    textures_[i] = textures_[i + 1];
+  }
+
+  textures_[kTextureMaxSize - 1] = Data{.key = 0u, .texture = nullptr};
+}
+
 EmbedderExternalTextureGL::EmbedderExternalTextureGL(
     int64_t texture_identifier,
     const ExternalTextureCallback& callback)
@@ -129,46 +211,27 @@ sk_sp<DlImage> EmbedderExternalTextureGL::ResolveTextureSkia(
   return DlImage::Make(std::move(image));
 }
 
-sk_sp<DlImage> EmbedderExternalTextureGL::ResolveTextureImpeller(
-    int64_t texture_id,
-    impeller::AiksContext* aiks_context,
-    const SkISize& size) {
-  std::unique_ptr<FlutterOpenGLTexture> texture =
-      external_texture_callback_(texture_id, size.width(), size.height());
-
-  if (!texture) {
-    return nullptr;
-  }
-
-  if (texture->bind_callback != nullptr) {
-    return ResolveTextureImpellerSurface(aiks_context, std::move(texture));
-  } else {
-    return ResolveTextureImpellerPixelbuffer(aiks_context, std::move(texture));
-  }
-}
-
-sk_sp<DlImage> EmbedderExternalTextureGL::ResolveTextureImpellerPixelbuffer(
+std::shared_ptr<impeller::TextureGLES>
+EmbedderExternalTextureGL::CreateTextureGLES(
     impeller::AiksContext* aiks_context,
-    std::unique_ptr<FlutterOpenGLTexture> texture) {
+    FlutterOpenGLTexture* texture) {
   impeller::TextureDescriptor desc;
   desc.size = impeller::ISize(texture->width, texture->height);
-  desc.type = impeller::TextureType::kTexture2D;
   desc.storage_mode = impeller::StorageMode::kDevicePrivate;
   desc.format = impeller::PixelFormat::kR8G8B8A8UNormInt;
+  if (texture->target == GL_TEXTURE_EXTERNAL_OES) {
+    desc.type = impeller::TextureType::kTextureExternalOES;
+  } else {
+    desc.type = impeller::TextureType::kTexture2D;
+  }
   impeller::ContextGLES& context =
       impeller::ContextGLES::Cast(*aiks_context->GetContext());
-  std::shared_ptr<impeller::TextureGLES> image =
-      std::make_shared<impeller::TextureGLES>(context.GetReactor(), desc);
+  impeller::HandleGLES handle = context.GetReactor()->CreateHandle(
+      impeller::HandleType::kTexture, texture->name);
 
-  image->MarkContentsInitialized();
-  if (!image->SetContents(texture->buffer, texture->buffer_size)) {
-    if (texture->destruction_callback) {
-      texture->destruction_callback(texture->user_data);
-    }
-    return nullptr;
-  }
-
-  if (!image) {
+  auto gles_texture =
+      impeller::TextureGLES::WrapTexture(context.GetReactor(), desc, handle);
+  if (!gles_texture) {
     // In case Skia rejects the image, call the release proc so that
     // embedders can perform collection of intermediates.
     if (texture->destruction_callback) {
@@ -178,58 +241,74 @@ sk_sp<DlImage> EmbedderExternalTextureGL::ResolveTextureImpellerPixelbuffer(
     return nullptr;
   }
 
-  if (texture->destruction_callback) {
-    texture->destruction_callback(texture->user_data);
-  }
+  gles_texture->SetCoordinateSystem(
+      impeller::TextureCoordinateSystem::kUploadFromHost);
 
-  return impeller::DlImageImpeller::Make(image);
+  if (texture->destruction_callback &&
+      !context.GetReactor()->RegisterCleanupCallback(
+          handle,
+          [callback = texture->destruction_callback,
+           user_data = texture->user_data]() { callback(user_data); })) {
+    FML_LOG(ERROR) << "Could not register destruction callback";
+    return nullptr;
+  }
+  return gles_texture;
 }
 
-sk_sp<DlImage> EmbedderExternalTextureGL::ResolveTextureImpellerSurface(
+sk_sp<DlImage> EmbedderExternalTextureGL::ResolveTextureImpeller(
+    int64_t texture_id,
     impeller::AiksContext* aiks_context,
-    std::unique_ptr<FlutterOpenGLTexture> texture) {
-  impeller::TextureDescriptor desc;
-  desc.size = impeller::ISize(texture->width, texture->height);
-  desc.storage_mode = impeller::StorageMode::kDevicePrivate;
-  desc.format = impeller::PixelFormat::kR8G8B8A8UNormInt;
-  desc.type = impeller::TextureType::kTextureExternalOES;
-  impeller::ContextGLES& context =
-      impeller::ContextGLES::Cast(*aiks_context->GetContext());
-  std::shared_ptr<impeller::TextureGLES> image =
-      std::make_shared<impeller::TextureGLES>(context.GetReactor(), desc);
-  image->MarkContentsInitialized();
-  image->SetCoordinateSystem(
-      impeller::TextureCoordinateSystem::kUploadFromHost);
-  if (!image->Bind()) {
-    if (texture->destruction_callback) {
-      texture->destruction_callback(texture->user_data);
-    }
-    FML_LOG(ERROR) << "Could not bind texture";
-    return nullptr;
-  }
+    const SkISize& size) {
+  std::unique_ptr<FlutterOpenGLTexture> texture =
+      external_texture_callback_(texture_id, size.width(), size.height());
 
-  if (!image) {
-    // In case Skia rejects the image, call the release proc so that
-    // embedders can perform collection of intermediates.
-    if (texture->destruction_callback) {
-      texture->destruction_callback(texture->user_data);
-    }
-    FML_LOG(ERROR) << "Could not create external texture";
+  if (!texture) {
     return nullptr;
   }
 
-  if (!texture->bind_callback(texture->user_data)) {
-    if (texture->destruction_callback) {
-      texture->destruction_callback(texture->user_data);
-    }
-    return nullptr;
-  }
+  std::optional<TextureLRU::Data> texture_data =
+      texture_lru_.FindTexture(texture->name);
+
+  bool size_change = false;
 
-  if (texture->destruction_callback) {
-    texture->destruction_callback(texture->user_data);
+  if (texture_data.has_value() &&
+      (texture_data.value().width != texture->width ||
+       texture_data.value().height != texture->height)) {
+    size_change = true;
   }
 
-  return impeller::DlImageImpeller::Make(image);
+  if (texture_data.has_value() && !size_change) {
+    return impeller::DlImageImpeller::Make(texture_data.value().texture);
+  } else if (texture_data.has_value() && size_change) {
+    std::shared_ptr<impeller::TextureGLES> old_gles_texture =
+        texture_data.value().texture;
+    old_gles_texture->Leak();
+    std::shared_ptr<impeller::TextureGLES> new_gles_texture =
+        CreateTextureGLES(aiks_context, texture.get());
+    if (new_gles_texture) {
+      texture_lru_.UpdateTexture(TextureLRU::Data{.key = texture->name,
+                                                  .texture = new_gles_texture,
+                                                  .width = texture->width,
+                                                  .height = texture->height});
+
+      return impeller::DlImageImpeller::Make(new_gles_texture);
+    } else {
+      texture_lru_.RemoveTexture(texture->name);
+      return nullptr;
+    }
+  } else {
+    std::shared_ptr<impeller::TextureGLES> new_gles_texture =
+        CreateTextureGLES(aiks_context, texture.get());
+    if (new_gles_texture) {
+      texture_lru_.AddTexture(TextureLRU::Data{.key = texture->name,
+                                               .texture = new_gles_texture,
+                                               .width = texture->width,
+                                               .height = texture->height});
+      return impeller::DlImageImpeller::Make(new_gles_texture);
+    } else {
+      return nullptr;
+    }
+  }
 }
 
 // |flutter::Texture|
@@ -244,6 +323,8 @@ void EmbedderExternalTextureGL::MarkNewFrameAvailable() {
 }
 
 // |flutter::Texture|
-void EmbedderExternalTextureGL::OnTextureUnregistered() {}
+void EmbedderExternalTextureGL::OnTextureUnregistered() {
+  texture_lru_.Clear();
+}
 
 }  // namespace flutter

engine/src/flutter/shell/platform/embedder/embedder_external_texture_gl.h

@@ -5,12 +5,52 @@
 #ifndef FLUTTER_SHELL_PLATFORM_EMBEDDER_EMBEDDER_EXTERNAL_TEXTURE_GL_H_
 #define FLUTTER_SHELL_PLATFORM_EMBEDDER_EMBEDDER_EXTERNAL_TEXTURE_GL_H_
 
+#include <list>
+#include <memory>
+#include <unordered_map>
 #include "flutter/common/graphics/texture.h"
 #include "flutter/fml/macros.h"
 #include "flutter/shell/platform/embedder/embedder.h"
+#include "impeller/renderer/backend/gles/texture_gles.h"
 #include "third_party/skia/include/core/SkSize.h"
 
 namespace flutter {
+static constexpr size_t kTextureMaxSize = 6u;
+
+class TextureLRU {
+ public:
+  struct Data {
+    GLuint key = 0u;
+    std::shared_ptr<impeller::TextureGLES> texture;
+    size_t width = 0;
+    size_t height = 0;
+  };
+
+  TextureLRU() = default;
+
+  ~TextureLRU() = default;
+
+  /// @brief Retrieve the Texture associated with the given [key], or nullptr.
+  std::optional<Data> FindTexture(std::optional<GLuint> key);
+
+  /// @brief Add a new texture to the cache with a key, returning the key of the
+  ///        LRU entry that was removed.
+  ///
+  /// The value may be `0`, in which case nothing was removed.
+  GLuint AddTexture(Data data);
+
+  /// @brief Remove all entires from the image cache.
+  void Clear();
+
+  /// @brief Remove a texture from the cache by key.
+  void RemoveTexture(GLuint key);
+
+  /// @brief Marks [key] as the most recently used.
+  void UpdateTexture(Data data);
+
+ private:
+  std::array<Data, kTextureMaxSize> textures_;
+};
 
 class EmbedderExternalTextureGL : public flutter::Texture {
  public:
@@ -25,7 +65,7 @@ class EmbedderExternalTextureGL : public flutter::Texture {
  private:
   const ExternalTextureCallback& external_texture_callback_;
   sk_sp<DlImage> last_image_;
-
+  TextureLRU texture_lru_ = TextureLRU();
   sk_sp<DlImage> ResolveTexture(int64_t texture_id,
                                 GrDirectContext* context,
                                 impeller::AiksContext* aiks_context,
@@ -39,13 +79,9 @@ class EmbedderExternalTextureGL : public flutter::Texture {
                                         impeller::AiksContext* aiks_context,
                                         const SkISize& size);
 
-  sk_sp<DlImage> ResolveTextureImpellerPixelbuffer(
-      impeller::AiksContext* aiks_context,
-      std::unique_ptr<FlutterOpenGLTexture> texture);
-
-  sk_sp<DlImage> ResolveTextureImpellerSurface(
+  std::shared_ptr<impeller::TextureGLES> CreateTextureGLES(
       impeller::AiksContext* aiks_context,
-      std::unique_ptr<FlutterOpenGLTexture> texture);
+      FlutterOpenGLTexture* texture);
 
   // |flutter::Texture|
   void Paint(PaintContext& context,