From 682ab9cd3b7a9dd172ea1c7901944dd7233aa7b3 Mon Sep 17 00:00:00 2001
From: Aaron Clarke <aaclarke@google.com>
Date: Thu, 5 Dec 2024 11:24:59 -0800
Subject: [PATCH 01/11] Migrated mock_gles to be able to use gmock

---
 .../renderer/backend/gles/test/mock_gles.cc   | 29 +++++++++++++++----
 .../renderer/backend/gles/test/mock_gles.h    | 23 +++++++++++++--
 .../backend/gles/test/reactor_unittests.cc    | 23 ++++++++-------
 3 files changed, 56 insertions(+), 19 deletions(-)

diff --git a/impeller/renderer/backend/gles/test/mock_gles.cc b/impeller/renderer/backend/gles/test/mock_gles.cc
index 9b1965ab2b026..38fb1ecb9e4a4 100644
--- a/impeller/renderer/backend/gles/test/mock_gles.cc
+++ b/impeller/renderer/backend/gles/test/mock_gles.cc
@@ -164,7 +164,13 @@ void mockDeleteQueriesEXT(GLsizei size, const GLuint* queries) {
 }
 
 void mockDeleteTextures(GLsizei size, const GLuint* queries) {
-  RecordGLCall("glDeleteTextures");
+  if (auto mock_gles = g_mock_gles.lock()) {
+    if (mock_gles->GetImpl()) {
+      mock_gles->GetImpl()->DeleteTextures(size, queries);
+    } else {
+      RecordGLCall("glDeleteTextures");
+    }
+  }
 }
 
 static_assert(CheckSameSignature<decltype(mockDeleteQueriesEXT),  //
@@ -177,12 +183,11 @@ static_assert(CheckSameSignature<decltype(mockUniform1fv),  //
                                  decltype(glUniform1fv)>::value);
 
 void mockGenTextures(GLsizei n, GLuint* textures) {
-  RecordGLCall("glGenTextures");
   if (auto mock_gles = g_mock_gles.lock()) {
-    std::optional<uint64_t> next_texture;
-    std::swap(mock_gles->next_texture_, next_texture);
-    if (next_texture.has_value()) {
-      textures[0] = next_texture.value();
+    if (mock_gles->GetImpl()) {
+      mock_gles->GetImpl()->GenTextures(n, textures);
+    } else {
+      RecordGLCall("glGenTextures");
     }
   }
 }
@@ -199,6 +204,18 @@ void mockObjectLabelKHR(GLenum identifier,
 static_assert(CheckSameSignature<decltype(mockObjectLabelKHR),  //
                                  decltype(glObjectLabelKHR)>::value);
 
+// static
+std::shared_ptr<MockGLES> MockGLES::Init(std::unique_ptr<MockGLESImpl> impl) {
+  FML_CHECK(g_test_lock.try_lock())
+      << "MockGLES is already being used by another test.";
+  auto mock_gles = std::shared_ptr<MockGLES>(new MockGLES());
+  mock_gles->impl_ = std::move(impl);
+  g_version = reinterpret_cast<const unsigned char*>("OpenGL ES 3.0");
+  g_extensions = kExtensions;
+  g_mock_gles = mock_gles;
+  return mock_gles;
+}
+
 std::shared_ptr<MockGLES> MockGLES::Init(
     const std::optional<std::vector<const unsigned char*>>& extensions,
     const char* version_string,
diff --git a/impeller/renderer/backend/gles/test/mock_gles.h b/impeller/renderer/backend/gles/test/mock_gles.h
index aa5a66c29650c..b08dc617f333f 100644
--- a/impeller/renderer/backend/gles/test/mock_gles.h
+++ b/impeller/renderer/backend/gles/test/mock_gles.h
@@ -8,6 +8,7 @@
 #include <memory>
 #include <optional>
 
+#include "gmock/gmock.h"
 #include "impeller/renderer/backend/gles/proc_table_gles.h"
 
 namespace impeller {
@@ -15,6 +16,22 @@ namespace testing {
 
 extern const ProcTableGLES::Resolver kMockResolverGLES;
 
+class IMockGLESImpl {
+ public:
+  virtual ~IMockGLESImpl() = default;
+  virtual void DeleteTextures(GLsizei size, const GLuint* queries) {}
+  virtual void GenTextures(GLsizei n, GLuint* textures) {}
+};
+
+class MockGLESImpl : public IMockGLESImpl {
+ public:
+  MOCK_METHOD(void,
+              DeleteTextures,
+              (GLsizei size, const GLuint* queries),
+              (override));
+  MOCK_METHOD(void, GenTextures, (GLsizei n, GLuint* textures), (override));
+};
+
 /// @brief      Provides a mocked version of the |ProcTableGLES| class.
 ///
 /// Typically, Open GLES at runtime will be provided the host's GLES bindings
@@ -25,6 +42,8 @@ extern const ProcTableGLES::Resolver kMockResolverGLES;
 /// See `README.md` for more information.
 class MockGLES final {
  public:
+  static std::shared_ptr<MockGLES> Init(std::unique_ptr<MockGLESImpl> impl);
+
   /// @brief      Returns an initialized |MockGLES| instance.
   ///
   /// This method overwrites mocked global GLES function pointers to record
@@ -50,7 +69,7 @@ class MockGLES final {
 
   ~MockGLES();
 
-  void SetNextTexture(uint64_t next_texture) { next_texture_ = next_texture; }
+  IMockGLESImpl* GetImpl() { return impl_.get(); }
 
  private:
   friend void RecordGLCall(const char* name);
@@ -62,7 +81,7 @@ class MockGLES final {
 
   ProcTableGLES proc_table_;
   std::vector<std::string> captured_calls_;
-  std::optional<uint64_t> next_texture_;
+  std::unique_ptr<IMockGLESImpl> impl_;
 
   MockGLES(const MockGLES&) = delete;
 
diff --git a/impeller/renderer/backend/gles/test/reactor_unittests.cc b/impeller/renderer/backend/gles/test/reactor_unittests.cc
index e2c49fb27cad4..f1656150f4087 100644
--- a/impeller/renderer/backend/gles/test/reactor_unittests.cc
+++ b/impeller/renderer/backend/gles/test/reactor_unittests.cc
@@ -6,6 +6,7 @@
 #include <memory>
 #include "flutter/fml/synchronization/waitable_event.h"
 #include "flutter/testing/testing.h"  // IWYU pragma: keep
+#include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include "impeller/renderer/backend/gles/handle_gles.h"
 #include "impeller/renderer/backend/gles/proc_table_gles.h"
@@ -15,6 +16,8 @@
 namespace impeller {
 namespace testing {
 
+using ::testing::_;
+
 class TestWorker : public ReactorGLES::Worker {
  public:
   bool CanReactorReactOnCurrentThreadNow(
@@ -63,14 +66,21 @@ TEST(ReactorGLES, DeletesHandlesDuringShutdown) {
 }
 
 TEST(ReactorGLES, UntrackedHandle) {
-  std::shared_ptr<MockGLES> mock_gles = MockGLES::Init();
+  auto mock_gles_impl = std::make_unique<MockGLESImpl>();
+
+  EXPECT_CALL(*mock_gles_impl, GenTextures(1, _))
+      .WillOnce([](GLsizei size, GLuint* queries) { queries[0] = 1234; });
+  EXPECT_CALL(*mock_gles_impl, DeleteTextures(1, ::testing::Pointee(1234)))
+      .Times(1);
+
+  std::shared_ptr<MockGLES> mock_gles =
+      MockGLES::Init(std::move(mock_gles_impl));
   ProcTableGLES::Resolver resolver = kMockResolverGLES;
   auto proc_table = std::make_unique<ProcTableGLES>(resolver);
   auto worker = std::make_shared<TestWorker>();
   auto reactor = std::make_shared<ReactorGLES>(std::move(proc_table));
   reactor->AddWorker(worker);
 
-  mock_gles->SetNextTexture(1234u);
   HandleGLES handle = reactor->CreateUntrackedHandle(HandleType::kTexture);
   EXPECT_FALSE(handle.IsDead());
   std::optional<GLuint> glint = reactor->GetGLHandle(handle);
@@ -78,17 +88,9 @@ TEST(ReactorGLES, UntrackedHandle) {
   if (glint.has_value()) {
     EXPECT_EQ(1234u, *glint);
   }
-  mock_gles->GetCapturedCalls();
   reactor->CollectHandle(handle);
-  std::vector<std::string> calls = mock_gles->GetCapturedCalls();
-  EXPECT_TRUE(std::find(calls.begin(), calls.end(), "glDeleteTextures") ==
-              calls.end());
-  // Without an operation nothing is cleaned up.
   EXPECT_TRUE(reactor->AddOperation([&](const ReactorGLES&) {}));
   EXPECT_TRUE(reactor->React());
-  calls = mock_gles->GetCapturedCalls();
-  EXPECT_FALSE(std::find(calls.begin(), calls.end(), "glDeleteTextures") ==
-               calls.end());
 }
 
 TEST(ReactorGLES, NameUntrackedHandle) {
@@ -99,7 +101,6 @@ TEST(ReactorGLES, NameUntrackedHandle) {
   auto reactor = std::make_shared<ReactorGLES>(std::move(proc_table));
   reactor->AddWorker(worker);
 
-  mock_gles->SetNextTexture(1234u);
   HandleGLES handle = reactor->CreateUntrackedHandle(HandleType::kTexture);
   mock_gles->GetCapturedCalls();
   reactor->SetDebugLabel(handle, "hello, joe!");

From 52ed40900625567aaba5c848fc18ccd58cd9c497 Mon Sep 17 00:00:00 2001
From: Aaron Clarke <aaclarke@google.com>
Date: Thu, 5 Dec 2024 12:52:51 -0800
Subject: [PATCH 02/11] migrated another test

---
 impeller/renderer/backend/gles/test/mock_gles.cc  |  8 +++++++-
 impeller/renderer/backend/gles/test/mock_gles.h   |  9 +++++++++
 .../backend/gles/test/reactor_unittests.cc        | 15 ++++++++++-----
 3 files changed, 26 insertions(+), 6 deletions(-)

diff --git a/impeller/renderer/backend/gles/test/mock_gles.cc b/impeller/renderer/backend/gles/test/mock_gles.cc
index 38fb1ecb9e4a4..5300feea4e8ac 100644
--- a/impeller/renderer/backend/gles/test/mock_gles.cc
+++ b/impeller/renderer/backend/gles/test/mock_gles.cc
@@ -199,7 +199,13 @@ void mockObjectLabelKHR(GLenum identifier,
                         GLuint name,
                         GLsizei length,
                         const GLchar* label) {
-  RecordGLCall("glObjectLabelKHR");
+  if (auto mock_gles = g_mock_gles.lock()) {
+    if (mock_gles->GetImpl()) {
+      mock_gles->GetImpl()->ObjectLabelKHR(identifier, name, length, label);
+    } else {
+      RecordGLCall("glObjectLabelKHR");
+    }
+  }
 }
 static_assert(CheckSameSignature<decltype(mockObjectLabelKHR),  //
                                  decltype(glObjectLabelKHR)>::value);
diff --git a/impeller/renderer/backend/gles/test/mock_gles.h b/impeller/renderer/backend/gles/test/mock_gles.h
index b08dc617f333f..0c37f510856a1 100644
--- a/impeller/renderer/backend/gles/test/mock_gles.h
+++ b/impeller/renderer/backend/gles/test/mock_gles.h
@@ -21,6 +21,10 @@ class IMockGLESImpl {
   virtual ~IMockGLESImpl() = default;
   virtual void DeleteTextures(GLsizei size, const GLuint* queries) {}
   virtual void GenTextures(GLsizei n, GLuint* textures) {}
+  virtual void ObjectLabelKHR(GLenum identifier,
+                              GLuint name,
+                              GLsizei length,
+                              const GLchar* label) {}
 };
 
 class MockGLESImpl : public IMockGLESImpl {
@@ -30,6 +34,11 @@ class MockGLESImpl : public IMockGLESImpl {
               (GLsizei size, const GLuint* queries),
               (override));
   MOCK_METHOD(void, GenTextures, (GLsizei n, GLuint* textures), (override));
+  MOCK_METHOD(
+      void,
+      ObjectLabelKHR,
+      (GLenum identifier, GLuint name, GLsizei length, const GLchar* label),
+      (override));
 };
 
 /// @brief      Provides a mocked version of the |ProcTableGLES| class.
diff --git a/impeller/renderer/backend/gles/test/reactor_unittests.cc b/impeller/renderer/backend/gles/test/reactor_unittests.cc
index f1656150f4087..c95765cb98c1b 100644
--- a/impeller/renderer/backend/gles/test/reactor_unittests.cc
+++ b/impeller/renderer/backend/gles/test/reactor_unittests.cc
@@ -94,7 +94,16 @@ TEST(ReactorGLES, UntrackedHandle) {
 }
 
 TEST(ReactorGLES, NameUntrackedHandle) {
-  std::shared_ptr<MockGLES> mock_gles = MockGLES::Init();
+  auto mock_gles_impl = std::make_unique<MockGLESImpl>();
+
+  EXPECT_CALL(*mock_gles_impl, GenTextures(1, _))
+      .WillOnce([](GLsizei size, GLuint* queries) { queries[0] = 1234; });
+  EXPECT_CALL(*mock_gles_impl,
+              ObjectLabelKHR(_, 1234, _, ::testing::StrEq("hello, joe!")))
+      .Times(1);
+
+  std::shared_ptr<MockGLES> mock_gles =
+      MockGLES::Init(std::move(mock_gles_impl));
   ProcTableGLES::Resolver resolver = kMockResolverGLES;
   auto proc_table = std::make_unique<ProcTableGLES>(resolver);
   auto worker = std::make_shared<TestWorker>();
@@ -102,11 +111,7 @@ TEST(ReactorGLES, NameUntrackedHandle) {
   reactor->AddWorker(worker);
 
   HandleGLES handle = reactor->CreateUntrackedHandle(HandleType::kTexture);
-  mock_gles->GetCapturedCalls();
   reactor->SetDebugLabel(handle, "hello, joe!");
-  std::vector<std::string> calls = mock_gles->GetCapturedCalls();
-  EXPECT_TRUE(std::find(calls.begin(), calls.end(), "glObjectLabelKHR") !=
-              calls.end());
 }
 
 TEST(ReactorGLES, PerThreadOperationQueues) {

From c29cf9057c5b4e6107554cf6e59c21ec918901e1 Mon Sep 17 00:00:00 2001
From: Aaron Clarke <aaclarke@google.com>
Date: Thu, 5 Dec 2024 13:40:55 -0800
Subject: [PATCH 03/11] removed 2 globals

---
 .../gles/test/capabilities_unittests.cc       | 19 ++++---
 .../gles/test/gpu_tracer_gles_unittests.cc    |  6 +--
 .../renderer/backend/gles/test/mock_gles.cc   | 53 +++++++++++--------
 .../renderer/backend/gles/test/mock_gles.h    | 12 ++++-
 4 files changed, 55 insertions(+), 35 deletions(-)

diff --git a/impeller/renderer/backend/gles/test/capabilities_unittests.cc b/impeller/renderer/backend/gles/test/capabilities_unittests.cc
index f93eab8605635..fbbf2b6315b30 100644
--- a/impeller/renderer/backend/gles/test/capabilities_unittests.cc
+++ b/impeller/renderer/backend/gles/test/capabilities_unittests.cc
@@ -33,9 +33,9 @@ TEST(CapabilitiesGLES, CanInitializeWithDefaults) {
 }
 
 TEST(CapabilitiesGLES, SupportsDecalSamplerAddressMode) {
-  auto const extensions = std::vector<const unsigned char*>{
-      reinterpret_cast<const unsigned char*>("GL_KHR_debug"),                 //
-      reinterpret_cast<const unsigned char*>("GL_EXT_texture_border_clamp"),  //
+  auto const extensions = std::vector<const char*>{
+      "GL_KHR_debug",                 //
+      "GL_EXT_texture_border_clamp",  //
   };
   auto mock_gles = MockGLES::Init(extensions);
   auto capabilities = mock_gles->GetProcTable().GetCapabilities();
@@ -43,9 +43,9 @@ TEST(CapabilitiesGLES, SupportsDecalSamplerAddressMode) {
 }
 
 TEST(CapabilitiesGLES, SupportsDecalSamplerAddressModeNotOES) {
-  auto const extensions = std::vector<const unsigned char*>{
-      reinterpret_cast<const unsigned char*>("GL_KHR_debug"),                 //
-      reinterpret_cast<const unsigned char*>("GL_OES_texture_border_clamp"),  //
+  auto const extensions = std::vector<const char*>{
+      "GL_KHR_debug",                 //
+      "GL_OES_texture_border_clamp",  //
   };
   auto mock_gles = MockGLES::Init(extensions);
   auto capabilities = mock_gles->GetProcTable().GetCapabilities();
@@ -53,10 +53,9 @@ TEST(CapabilitiesGLES, SupportsDecalSamplerAddressModeNotOES) {
 }
 
 TEST(CapabilitiesGLES, SupportsFramebufferFetch) {
-  auto const extensions = std::vector<const unsigned char*>{
-      reinterpret_cast<const unsigned char*>("GL_KHR_debug"),  //
-      reinterpret_cast<const unsigned char*>(
-          "GL_EXT_shader_framebuffer_fetch"),  //
+  auto const extensions = std::vector<const char*>{
+      "GL_KHR_debug",  //
+      "GL_EXT_shader_framebuffer_fetch",  //
   };
   auto mock_gles = MockGLES::Init(extensions);
   auto capabilities = mock_gles->GetProcTable().GetCapabilities();
diff --git a/impeller/renderer/backend/gles/test/gpu_tracer_gles_unittests.cc b/impeller/renderer/backend/gles/test/gpu_tracer_gles_unittests.cc
index d0579a2091b23..f54dce690ebe7 100644
--- a/impeller/renderer/backend/gles/test/gpu_tracer_gles_unittests.cc
+++ b/impeller/renderer/backend/gles/test/gpu_tracer_gles_unittests.cc
@@ -12,9 +12,9 @@ namespace testing {
 
 #ifdef IMPELLER_DEBUG
 TEST(GPUTracerGLES, CanFormatFramebufferErrorMessage) {
-  auto const extensions = std::vector<const unsigned char*>{
-      reinterpret_cast<const unsigned char*>("GL_KHR_debug"),                 //
-      reinterpret_cast<const unsigned char*>("GL_EXT_disjoint_timer_query"),  //
+  auto const extensions = std::vector<const char*>{
+      "GL_KHR_debug",                 //
+      "GL_EXT_disjoint_timer_query",  //
   };
   auto mock_gles = MockGLES::Init(extensions);
   auto tracer =
diff --git a/impeller/renderer/backend/gles/test/mock_gles.cc b/impeller/renderer/backend/gles/test/mock_gles.cc
index 5300feea4e8ac..94b9e36253183 100644
--- a/impeller/renderer/backend/gles/test/mock_gles.cc
+++ b/impeller/renderer/backend/gles/test/mock_gles.cc
@@ -21,10 +21,6 @@ static std::weak_ptr<MockGLES> g_mock_gles;
 
 static ProcTableGLES::Resolver g_resolver;
 
-static std::vector<const unsigned char*> g_extensions;
-
-static const unsigned char* g_version;
-
 // Has friend visibility into MockGLES to record calls.
 void RecordGLCall(const char* name) {
   if (auto mock_gles = g_mock_gles.lock()) {
@@ -41,22 +37,29 @@ struct CheckSameSignature<Ret(Args...), Ret(Args...)> : std::true_type {};
 // This is a stub function that does nothing/records nothing.
 void doNothing() {}
 
-auto const kMockVendor = (unsigned char*)"MockGLES";
-const auto kMockShadingLanguageVersion = (unsigned char*)"GLSL ES 1.0";
-auto const kExtensions = std::vector<const unsigned char*>{
-    (unsigned char*)"GL_KHR_debug"  //
+auto const kMockVendor = "MockGLES";
+const auto kMockShadingLanguageVersion = "GLSL ES 1.0";
+auto const kExtensions = std::vector<const char*>{
+    "GL_KHR_debug"  //
 };
 
 const unsigned char* mockGetString(GLenum name) {
   switch (name) {
     case GL_VENDOR:
-      return kMockVendor;
-    case GL_VERSION:
-      return g_version;
+      return reinterpret_cast<const unsigned char*>(kMockVendor);
+    case GL_VERSION: {
+      std::vector<const char*> extensions;
+      if (auto mock_gles = g_mock_gles.lock()) {
+        return reinterpret_cast<const unsigned char*>(mock_gles->GetVersion());
+      } else {
+        return reinterpret_cast<const unsigned char*>("");
+      }
+    }
     case GL_SHADING_LANGUAGE_VERSION:
-      return kMockShadingLanguageVersion;
+      return reinterpret_cast<const unsigned char*>(
+          kMockShadingLanguageVersion);
     default:
-      return (unsigned char*)"";
+      return reinterpret_cast<const unsigned char*>("");
   }
 }
 
@@ -64,11 +67,15 @@ static_assert(CheckSameSignature<decltype(mockGetString),  //
                                  decltype(glGetString)>::value);
 
 const unsigned char* mockGetStringi(GLenum name, GLuint index) {
+  std::vector<const char*> extensions;
+  if (auto mock_gles = g_mock_gles.lock()) {
+    extensions = mock_gles->GetExtensions();
+  }
   switch (name) {
     case GL_EXTENSIONS:
-      return g_extensions[index];
+      return reinterpret_cast<const unsigned char*>(extensions[index]);
     default:
-      return (unsigned char*)"";
+      return reinterpret_cast<const unsigned char*>("");
   }
 }
 
@@ -76,9 +83,13 @@ static_assert(CheckSameSignature<decltype(mockGetStringi),  //
                                  decltype(glGetStringi)>::value);
 
 void mockGetIntegerv(GLenum name, int* value) {
+  std::vector<const char*> extensions;
+  if (auto mock_gles = g_mock_gles.lock()) {
+    extensions = mock_gles->GetExtensions();
+  }
   switch (name) {
     case GL_NUM_EXTENSIONS: {
-      *value = g_extensions.size();
+      *value = extensions.size();
     } break;
     case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
       *value = 8;
@@ -216,22 +227,22 @@ std::shared_ptr<MockGLES> MockGLES::Init(std::unique_ptr<MockGLESImpl> impl) {
       << "MockGLES is already being used by another test.";
   auto mock_gles = std::shared_ptr<MockGLES>(new MockGLES());
   mock_gles->impl_ = std::move(impl);
-  g_version = reinterpret_cast<const unsigned char*>("OpenGL ES 3.0");
-  g_extensions = kExtensions;
+  mock_gles->extensions_ = kExtensions;
+  mock_gles->version_ = "OpenGL ES 3.0";
   g_mock_gles = mock_gles;
   return mock_gles;
 }
 
 std::shared_ptr<MockGLES> MockGLES::Init(
-    const std::optional<std::vector<const unsigned char*>>& extensions,
+    const std::optional<std::vector<const char*>>& extensions,
     const char* version_string,
     ProcTableGLES::Resolver resolver) {
   // If we cannot obtain a lock, MockGLES is already being used elsewhere.
   FML_CHECK(g_test_lock.try_lock())
       << "MockGLES is already being used by another test.";
-  g_version = (unsigned char*)version_string;
-  g_extensions = extensions.value_or(kExtensions);
   auto mock_gles = std::shared_ptr<MockGLES>(new MockGLES(std::move(resolver)));
+  mock_gles->extensions_ = extensions.value_or(kExtensions);
+  mock_gles->version_ = version_string;
   g_mock_gles = mock_gles;
   return mock_gles;
 }
diff --git a/impeller/renderer/backend/gles/test/mock_gles.h b/impeller/renderer/backend/gles/test/mock_gles.h
index 0c37f510856a1..2caab40028958 100644
--- a/impeller/renderer/backend/gles/test/mock_gles.h
+++ b/impeller/renderer/backend/gles/test/mock_gles.h
@@ -59,7 +59,7 @@ class MockGLES final {
   /// invocations on this instance of |MockGLES|. As such, it should only be
   /// called once per test.
   static std::shared_ptr<MockGLES> Init(
-      const std::optional<std::vector<const unsigned char*>>& extensions =
+      const std::optional<std::vector<const char*>>& extensions =
           std::nullopt,
       const char* version_string = "OpenGL ES 3.0",
       ProcTableGLES::Resolver resolver = kMockResolverGLES);
@@ -80,6 +80,14 @@ class MockGLES final {
 
   IMockGLESImpl* GetImpl() { return impl_.get(); }
 
+  const std::vector<const char*>& GetExtensions() const {
+    return extensions_;
+  }
+
+  const char* GetVersion() const {
+    return version_;
+  }
+
  private:
   friend void RecordGLCall(const char* name);
   friend void mockGenTextures(GLsizei n, GLuint* textures);
@@ -91,6 +99,8 @@ class MockGLES final {
   ProcTableGLES proc_table_;
   std::vector<std::string> captured_calls_;
   std::unique_ptr<IMockGLESImpl> impl_;
+  std::vector<const char*> extensions_;
+  const char* version_;
 
   MockGLES(const MockGLES&) = delete;
 

From 6c14733fdbce01373b847e72e6fba038338fd9d3 Mon Sep 17 00:00:00 2001
From: Aaron Clarke <aaclarke@google.com>
Date: Thu, 5 Dec 2024 13:46:43 -0800
Subject: [PATCH 04/11] migrated another test

---
 .../renderer/backend/gles/test/mock_gles.cc    |  2 --
 .../backend/gles/test/reactor_unittests.cc     | 18 ++++++++++--------
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/impeller/renderer/backend/gles/test/mock_gles.cc b/impeller/renderer/backend/gles/test/mock_gles.cc
index 94b9e36253183..9bde0887527c3 100644
--- a/impeller/renderer/backend/gles/test/mock_gles.cc
+++ b/impeller/renderer/backend/gles/test/mock_gles.cc
@@ -19,8 +19,6 @@ static std::mutex g_test_lock;
 
 static std::weak_ptr<MockGLES> g_mock_gles;
 
-static ProcTableGLES::Resolver g_resolver;
-
 // Has friend visibility into MockGLES to record calls.
 void RecordGLCall(const char* name) {
   if (auto mock_gles = g_mock_gles.lock()) {
diff --git a/impeller/renderer/backend/gles/test/reactor_unittests.cc b/impeller/renderer/backend/gles/test/reactor_unittests.cc
index c95765cb98c1b..48ee45dd3a3be 100644
--- a/impeller/renderer/backend/gles/test/reactor_unittests.cc
+++ b/impeller/renderer/backend/gles/test/reactor_unittests.cc
@@ -49,20 +49,22 @@ TEST(ReactorGLES, CanAttachCleanupCallbacksToHandles) {
 }
 
 TEST(ReactorGLES, DeletesHandlesDuringShutdown) {
-  auto mock_gles = MockGLES::Init();
+  auto mock_gles_impl = std::make_unique<MockGLESImpl>();
+
+  EXPECT_CALL(*mock_gles_impl, GenTextures(1, _))
+      .WillOnce([](GLsizei size, GLuint* queries) { queries[0] = 1234; });
+  EXPECT_CALL(*mock_gles_impl, DeleteTextures(1, ::testing::Pointee(1234)))
+      .Times(1);
+
+  std::shared_ptr<MockGLES> mock_gles =
+      MockGLES::Init(std::move(mock_gles_impl));
   ProcTableGLES::Resolver resolver = kMockResolverGLES;
   auto proc_table = std::make_unique<ProcTableGLES>(resolver);
   auto worker = std::make_shared<TestWorker>();
   auto reactor = std::make_shared<ReactorGLES>(std::move(proc_table));
   reactor->AddWorker(worker);
-
-  reactor->CreateHandle(HandleType::kTexture, 123);
-
+  reactor->CreateHandle(HandleType::kTexture);
   reactor.reset();
-
-  auto calls = mock_gles->GetCapturedCalls();
-  EXPECT_TRUE(std::find(calls.begin(), calls.end(), "glDeleteTextures") !=
-              calls.end());
 }
 
 TEST(ReactorGLES, UntrackedHandle) {

From 742e9e8c6a7e261192b875821e8369a0288fc82e Mon Sep 17 00:00:00 2001
From: Aaron Clarke <aaclarke@google.com>
Date: Thu, 5 Dec 2024 13:53:41 -0800
Subject: [PATCH 05/11] migrated another test

---
 .../gles/buffer_bindings_gles_unittests.cc      | 11 +++++++----
 .../renderer/backend/gles/test/mock_gles.cc     |  8 +++++++-
 impeller/renderer/backend/gles/test/mock_gles.h | 17 +++++++++--------
 3 files changed, 23 insertions(+), 13 deletions(-)

diff --git a/impeller/renderer/backend/gles/buffer_bindings_gles_unittests.cc b/impeller/renderer/backend/gles/buffer_bindings_gles_unittests.cc
index 9078447433b43..45a342bfcbd06 100644
--- a/impeller/renderer/backend/gles/buffer_bindings_gles_unittests.cc
+++ b/impeller/renderer/backend/gles/buffer_bindings_gles_unittests.cc
@@ -12,12 +12,18 @@
 namespace impeller {
 namespace testing {
 
+using ::testing::_;
+
 TEST(BufferBindingsGLESTest, BindUniformData) {
   BufferBindingsGLES bindings;
   absl::flat_hash_map<std::string, GLint> uniform_bindings;
   uniform_bindings["SHADERMETADATA.FOOBAR"] = 1;
   bindings.SetUniformBindings(std::move(uniform_bindings));
-  std::shared_ptr<MockGLES> mock_gl = MockGLES::Init();
+  auto mock_gles_impl = std::make_unique<MockGLESImpl>();
+
+  EXPECT_CALL(*mock_gles_impl, Uniform1fv(_, _, _)).Times(1);
+
+  std::shared_ptr<MockGLES> mock_gl = MockGLES::Init(std::move(mock_gles_impl));
   std::vector<BufferResource> bound_buffers;
   std::vector<TextureAndSampler> bound_textures;
 
@@ -39,9 +45,6 @@ TEST(BufferBindingsGLESTest, BindUniformData) {
   EXPECT_TRUE(bindings.BindUniformData(mock_gl->GetProcTable(), bound_textures,
                                        bound_buffers, Range{0, 0},
                                        Range{0, 1}));
-  std::vector<std::string> captured_calls = mock_gl->GetCapturedCalls();
-  EXPECT_TRUE(std::find(captured_calls.begin(), captured_calls.end(),
-                        "glUniform1fv") != captured_calls.end());
 }
 
 }  // namespace testing
diff --git a/impeller/renderer/backend/gles/test/mock_gles.cc b/impeller/renderer/backend/gles/test/mock_gles.cc
index 9bde0887527c3..224a0070d9848 100644
--- a/impeller/renderer/backend/gles/test/mock_gles.cc
+++ b/impeller/renderer/backend/gles/test/mock_gles.cc
@@ -186,7 +186,13 @@ static_assert(CheckSameSignature<decltype(mockDeleteQueriesEXT),  //
                                  decltype(glDeleteQueriesEXT)>::value);
 
 void mockUniform1fv(GLint location, GLsizei count, const GLfloat* value) {
-  RecordGLCall("glUniform1fv");
+  if (auto mock_gles = g_mock_gles.lock()) {
+    if (mock_gles->GetImpl()) {
+      mock_gles->GetImpl()->Uniform1fv(location, count, value);
+    } else {
+      RecordGLCall("glUniform1fv");
+    }
+  }
 }
 static_assert(CheckSameSignature<decltype(mockUniform1fv),  //
                                  decltype(glUniform1fv)>::value);
diff --git a/impeller/renderer/backend/gles/test/mock_gles.h b/impeller/renderer/backend/gles/test/mock_gles.h
index 2caab40028958..94991c3c82292 100644
--- a/impeller/renderer/backend/gles/test/mock_gles.h
+++ b/impeller/renderer/backend/gles/test/mock_gles.h
@@ -25,6 +25,8 @@ class IMockGLESImpl {
                               GLuint name,
                               GLsizei length,
                               const GLchar* label) {}
+  virtual void Uniform1fv(GLint location, GLsizei count, const GLfloat* value) {
+  }
 };
 
 class MockGLESImpl : public IMockGLESImpl {
@@ -39,6 +41,10 @@ class MockGLESImpl : public IMockGLESImpl {
       ObjectLabelKHR,
       (GLenum identifier, GLuint name, GLsizei length, const GLchar* label),
       (override));
+  MOCK_METHOD(void,
+              Uniform1fv,
+              (GLint location, GLsizei count, const GLfloat* value),
+              (override));
 };
 
 /// @brief      Provides a mocked version of the |ProcTableGLES| class.
@@ -59,8 +65,7 @@ class MockGLES final {
   /// invocations on this instance of |MockGLES|. As such, it should only be
   /// called once per test.
   static std::shared_ptr<MockGLES> Init(
-      const std::optional<std::vector<const char*>>& extensions =
-          std::nullopt,
+      const std::optional<std::vector<const char*>>& extensions = std::nullopt,
       const char* version_string = "OpenGL ES 3.0",
       ProcTableGLES::Resolver resolver = kMockResolverGLES);
 
@@ -80,13 +85,9 @@ class MockGLES final {
 
   IMockGLESImpl* GetImpl() { return impl_.get(); }
 
-  const std::vector<const char*>& GetExtensions() const {
-    return extensions_;
-  }
+  const std::vector<const char*>& GetExtensions() const { return extensions_; }
 
-  const char* GetVersion() const {
-    return version_;
-  }
+  const char* GetVersion() const { return version_; }
 
  private:
   friend void RecordGLCall(const char* name);

From 7111fe8294239fd55ed07e53de8e1d16dd46f370 Mon Sep 17 00:00:00 2001
From: Aaron Clarke <aaclarke@google.com>
Date: Thu, 5 Dec 2024 14:00:03 -0800
Subject: [PATCH 06/11] migrated more tests

---
 .../backend/gles/unique_handle_gles_unittests.cc    | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/impeller/renderer/backend/gles/unique_handle_gles_unittests.cc b/impeller/renderer/backend/gles/unique_handle_gles_unittests.cc
index 6a01fefbc47df..01ddf037f1187 100644
--- a/impeller/renderer/backend/gles/unique_handle_gles_unittests.cc
+++ b/impeller/renderer/backend/gles/unique_handle_gles_unittests.cc
@@ -11,6 +11,8 @@
 namespace impeller {
 namespace testing {
 
+using ::testing::_;
+
 namespace {
 class TestWorker : public ReactorGLES::Worker {
  public:
@@ -22,20 +24,21 @@ class TestWorker : public ReactorGLES::Worker {
 }  // namespace
 
 TEST(UniqueHandleGLES, MakeUntracked) {
-  auto mock_gles = MockGLES::Init();
+  auto mock_gles_impl = std::make_unique<MockGLESImpl>();
+
+  EXPECT_CALL(*mock_gles_impl, GenTextures(1, _)).Times(1);
+
+  std::shared_ptr<MockGLES> mock_gled =
+      MockGLES::Init(std::move(mock_gles_impl));
   ProcTableGLES::Resolver resolver = kMockResolverGLES;
   auto proc_table = std::make_unique<ProcTableGLES>(resolver);
   auto worker = std::make_shared<TestWorker>();
   auto reactor = std::make_shared<ReactorGLES>(std::move(proc_table));
   reactor->AddWorker(worker);
 
-  mock_gles->GetCapturedCalls();
   UniqueHandleGLES handle =
       UniqueHandleGLES::MakeUntracked(reactor, HandleType::kTexture);
   EXPECT_FALSE(handle.Get().IsDead());
-  std::vector<std::string> calls = mock_gles->GetCapturedCalls();
-  EXPECT_TRUE(std::find(calls.begin(), calls.end(), "glGenTextures") !=
-              calls.end());
 }
 
 }  // namespace testing

From 3580cee0fac134ff136722de9fd719b0107477e8 Mon Sep 17 00:00:00 2001
From: Aaron Clarke <aaclarke@google.com>
Date: Thu, 5 Dec 2024 15:00:53 -0800
Subject: [PATCH 07/11] migrated last calls test

---
 .../gles/test/gpu_tracer_gles_unittests.cc    | 49 ++++++++----
 .../renderer/backend/gles/test/mock_gles.cc   | 77 +++++++++++--------
 .../renderer/backend/gles/test/mock_gles.h    | 42 ++++++----
 .../backend/gles/test/mock_gles_unittests.cc  | 13 ----
 4 files changed, 105 insertions(+), 76 deletions(-)

diff --git a/impeller/renderer/backend/gles/test/gpu_tracer_gles_unittests.cc b/impeller/renderer/backend/gles/test/gpu_tracer_gles_unittests.cc
index f54dce690ebe7..f51c148854ad9 100644
--- a/impeller/renderer/backend/gles/test/gpu_tracer_gles_unittests.cc
+++ b/impeller/renderer/backend/gles/test/gpu_tracer_gles_unittests.cc
@@ -10,38 +10,59 @@
 namespace impeller {
 namespace testing {
 
+using ::testing::_;
+
 #ifdef IMPELLER_DEBUG
 TEST(GPUTracerGLES, CanFormatFramebufferErrorMessage) {
   auto const extensions = std::vector<const char*>{
       "GL_KHR_debug",                 //
       "GL_EXT_disjoint_timer_query",  //
   };
-  auto mock_gles = MockGLES::Init(extensions);
+  auto mock_gles_impl = std::make_unique<MockGLESImpl>();
+
+  EXPECT_CALL(*mock_gles_impl, GenQueriesEXT(_, _))
+      .WillRepeatedly([](GLsizei n, GLuint* ids) {
+        for (int i = 0; i < n; ++i) {
+          ids[i] = i + 1;
+        }
+      });
+  EXPECT_CALL(*mock_gles_impl, BeginQueryEXT(_, _)).Times(2);
+  EXPECT_CALL(*mock_gles_impl, EndQueryEXT(_));
+  EXPECT_CALL(*mock_gles_impl, GetQueryObjectuivEXT(_, _, _))
+      .WillRepeatedly(
+          [](GLuint id, GLenum target, GLuint* result) { *result = GL_TRUE; });
+  EXPECT_CALL(*mock_gles_impl, GetQueryObjectui64vEXT(_, _, _))
+      .WillRepeatedly(
+          [](GLuint id, GLenum target, GLuint64* result) { *result = 1000u; });
+  EXPECT_CALL(*mock_gles_impl, DeleteQueriesEXT(_, _));
+
+  std::shared_ptr<MockGLES> mock_gles =
+      MockGLES::Init(std::move(mock_gles_impl), extensions);
   auto tracer =
       std::make_shared<GPUTracerGLES>(mock_gles->GetProcTable(), true);
   tracer->RecordRasterThread();
   tracer->MarkFrameStart(mock_gles->GetProcTable());
   tracer->MarkFrameEnd(mock_gles->GetProcTable());
 
-  auto calls = mock_gles->GetCapturedCalls();
+  // auto calls = mock_gles->GetCapturedCalls();
 
-  std::vector<std::string> expected = {"glGenQueriesEXT", "glBeginQueryEXT",
-                                       "glEndQueryEXT"};
-  for (auto i = 0; i < 3; i++) {
-    EXPECT_EQ(calls[i], expected[i]);
-  }
+  // std::vector<std::string> expected = {"glGenQueriesEXT", "glBeginQueryEXT",
+  //                                      "glEndQueryEXT"};
+  // for (auto i = 0; i < 3; i++) {
+  //   EXPECT_EQ(calls[i], expected[i]);
+  // }
 
   // Begin second frame, which prompts the tracer to query the result
   // from the previous frame.
   tracer->MarkFrameStart(mock_gles->GetProcTable());
 
-  calls = mock_gles->GetCapturedCalls();
-  std::vector<std::string> expected_b = {"glGetQueryObjectuivEXT",
-                                         "glGetQueryObjectui64vEXT",
-                                         "glDeleteQueriesEXT"};
-  for (auto i = 0; i < 3; i++) {
-    EXPECT_EQ(calls[i], expected_b[i]);
-  }
+  // calls = mock_gles->GetCapturedCalls();
+  // std::vector<std::string> expected_b = {"glGetQueryObjectuivEXT",
+  //                                        "glGetQueryObjectui64vEXT",
+  //                                        "glDeleteQueriesEXT"};
+  // for (auto i = 0; i < 3; i++) {
+  //   EXPECT_EQ(calls[i], expected_b[i]);
+  // }
 }
 
 #endif  // IMPELLER_DEBUG
diff --git a/impeller/renderer/backend/gles/test/mock_gles.cc b/impeller/renderer/backend/gles/test/mock_gles.cc
index 224a0070d9848..b74ed80a2dab6 100644
--- a/impeller/renderer/backend/gles/test/mock_gles.cc
+++ b/impeller/renderer/backend/gles/test/mock_gles.cc
@@ -19,6 +19,10 @@ static std::mutex g_test_lock;
 
 static std::weak_ptr<MockGLES> g_mock_gles;
 
+static std::vector<const char*> g_extensions;
+
+static const char* g_version;
+
 // Has friend visibility into MockGLES to record calls.
 void RecordGLCall(const char* name) {
   if (auto mock_gles = g_mock_gles.lock()) {
@@ -45,14 +49,8 @@ const unsigned char* mockGetString(GLenum name) {
   switch (name) {
     case GL_VENDOR:
       return reinterpret_cast<const unsigned char*>(kMockVendor);
-    case GL_VERSION: {
-      std::vector<const char*> extensions;
-      if (auto mock_gles = g_mock_gles.lock()) {
-        return reinterpret_cast<const unsigned char*>(mock_gles->GetVersion());
-      } else {
-        return reinterpret_cast<const unsigned char*>("");
-      }
-    }
+    case GL_VERSION:
+      return reinterpret_cast<const unsigned char*>(g_version);
     case GL_SHADING_LANGUAGE_VERSION:
       return reinterpret_cast<const unsigned char*>(
           kMockShadingLanguageVersion);
@@ -65,13 +63,9 @@ static_assert(CheckSameSignature<decltype(mockGetString),  //
                                  decltype(glGetString)>::value);
 
 const unsigned char* mockGetStringi(GLenum name, GLuint index) {
-  std::vector<const char*> extensions;
-  if (auto mock_gles = g_mock_gles.lock()) {
-    extensions = mock_gles->GetExtensions();
-  }
   switch (name) {
     case GL_EXTENSIONS:
-      return reinterpret_cast<const unsigned char*>(extensions[index]);
+      return reinterpret_cast<const unsigned char*>(g_extensions[index]);
     default:
       return reinterpret_cast<const unsigned char*>("");
   }
@@ -81,13 +75,9 @@ static_assert(CheckSameSignature<decltype(mockGetStringi),  //
                                  decltype(glGetStringi)>::value);
 
 void mockGetIntegerv(GLenum name, int* value) {
-  std::vector<const char*> extensions;
-  if (auto mock_gles = g_mock_gles.lock()) {
-    extensions = mock_gles->GetExtensions();
-  }
   switch (name) {
     case GL_NUM_EXTENSIONS: {
-      *value = extensions.size();
+      *value = g_extensions.size();
     } break;
     case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
       *value = 8;
@@ -129,9 +119,10 @@ static_assert(CheckSameSignature<decltype(mockPushDebugGroupKHR),  //
                                  decltype(glPushDebugGroupKHR)>::value);
 
 void mockGenQueriesEXT(GLsizei n, GLuint* ids) {
-  RecordGLCall("glGenQueriesEXT");
-  for (auto i = 0; i < n; i++) {
-    ids[i] = i + 1;
+  if (auto mock_gles = g_mock_gles.lock()) {
+    if (mock_gles->GetImpl()) {
+      mock_gles->GetImpl()->GenQueriesEXT(n, ids);
+    }
   }
 }
 
@@ -139,37 +130,55 @@ static_assert(CheckSameSignature<decltype(mockGenQueriesEXT),  //
                                  decltype(glGenQueriesEXT)>::value);
 
 void mockBeginQueryEXT(GLenum target, GLuint id) {
-  RecordGLCall("glBeginQueryEXT");
+  if (auto mock_gles = g_mock_gles.lock()) {
+    if (mock_gles->GetImpl()) {
+      mock_gles->GetImpl()->BeginQueryEXT(target, id);
+    }
+  }
 }
 
 static_assert(CheckSameSignature<decltype(mockBeginQueryEXT),  //
                                  decltype(glBeginQueryEXT)>::value);
 
 void mockEndQueryEXT(GLuint id) {
-  RecordGLCall("glEndQueryEXT");
+  if (auto mock_gles = g_mock_gles.lock()) {
+    if (mock_gles->GetImpl()) {
+      mock_gles->GetImpl()->EndQueryEXT(id);
+    }
+  }
 }
 
 static_assert(CheckSameSignature<decltype(mockEndQueryEXT),  //
                                  decltype(glEndQueryEXT)>::value);
 
 void mockGetQueryObjectuivEXT(GLuint id, GLenum target, GLuint* result) {
-  RecordGLCall("glGetQueryObjectuivEXT");
-  *result = GL_TRUE;
+  if (auto mock_gles = g_mock_gles.lock()) {
+    if (mock_gles->GetImpl()) {
+      mock_gles->GetImpl()->GetQueryObjectuivEXT(id, target, result);
+    }
+  }
 }
 
 static_assert(CheckSameSignature<decltype(mockGetQueryObjectuivEXT),  //
                                  decltype(glGetQueryObjectuivEXT)>::value);
 
 void mockGetQueryObjectui64vEXT(GLuint id, GLenum target, GLuint64* result) {
-  RecordGLCall("glGetQueryObjectui64vEXT");
-  *result = 1000u;
+  if (auto mock_gles = g_mock_gles.lock()) {
+    if (mock_gles->GetImpl()) {
+      mock_gles->GetImpl()->GetQueryObjectui64vEXT(id, target, result);
+    }
+  }
 }
 
 static_assert(CheckSameSignature<decltype(mockGetQueryObjectui64vEXT),  //
                                  decltype(glGetQueryObjectui64vEXT)>::value);
 
 void mockDeleteQueriesEXT(GLsizei size, const GLuint* queries) {
-  RecordGLCall("glDeleteQueriesEXT");
+  if (auto mock_gles = g_mock_gles.lock()) {
+    if (mock_gles->GetImpl()) {
+      mock_gles->GetImpl()->DeleteQueriesEXT(size, queries);
+    }
+  }
 }
 
 void mockDeleteTextures(GLsizei size, const GLuint* queries) {
@@ -226,13 +235,15 @@ static_assert(CheckSameSignature<decltype(mockObjectLabelKHR),  //
                                  decltype(glObjectLabelKHR)>::value);
 
 // static
-std::shared_ptr<MockGLES> MockGLES::Init(std::unique_ptr<MockGLESImpl> impl) {
+std::shared_ptr<MockGLES> MockGLES::Init(
+    std::unique_ptr<MockGLESImpl> impl,
+    const std::optional<std::vector<const char*>>& extensions) {
   FML_CHECK(g_test_lock.try_lock())
       << "MockGLES is already being used by another test.";
+  g_extensions = extensions.value_or(kExtensions);
+  g_version = "OpenGL ES 3.0";
   auto mock_gles = std::shared_ptr<MockGLES>(new MockGLES());
   mock_gles->impl_ = std::move(impl);
-  mock_gles->extensions_ = kExtensions;
-  mock_gles->version_ = "OpenGL ES 3.0";
   g_mock_gles = mock_gles;
   return mock_gles;
 }
@@ -244,9 +255,9 @@ std::shared_ptr<MockGLES> MockGLES::Init(
   // If we cannot obtain a lock, MockGLES is already being used elsewhere.
   FML_CHECK(g_test_lock.try_lock())
       << "MockGLES is already being used by another test.";
+  g_extensions = extensions.value_or(kExtensions);
+  g_version = version_string;
   auto mock_gles = std::shared_ptr<MockGLES>(new MockGLES(std::move(resolver)));
-  mock_gles->extensions_ = extensions.value_or(kExtensions);
-  mock_gles->version_ = version_string;
   g_mock_gles = mock_gles;
   return mock_gles;
 }
diff --git a/impeller/renderer/backend/gles/test/mock_gles.h b/impeller/renderer/backend/gles/test/mock_gles.h
index 94991c3c82292..43fc2be8f97be 100644
--- a/impeller/renderer/backend/gles/test/mock_gles.h
+++ b/impeller/renderer/backend/gles/test/mock_gles.h
@@ -27,6 +27,14 @@ class IMockGLESImpl {
                               const GLchar* label) {}
   virtual void Uniform1fv(GLint location, GLsizei count, const GLfloat* value) {
   }
+  virtual void GenQueriesEXT(GLsizei n, GLuint* ids) {}
+  virtual void BeginQueryEXT(GLenum target, GLuint id) {}
+  virtual void EndQueryEXT(GLuint id) {}
+  virtual void GetQueryObjectuivEXT(GLuint id, GLenum target, GLuint* result) {}
+  virtual void GetQueryObjectui64vEXT(GLuint id,
+                                      GLenum target,
+                                      GLuint64* result) {}
+  virtual void DeleteQueriesEXT(GLsizei size, const GLuint* queries) {}
 };
 
 class MockGLESImpl : public IMockGLESImpl {
@@ -45,6 +53,21 @@ class MockGLESImpl : public IMockGLESImpl {
               Uniform1fv,
               (GLint location, GLsizei count, const GLfloat* value),
               (override));
+  MOCK_METHOD(void, GenQueriesEXT, (GLsizei n, GLuint* ids), (override));
+  MOCK_METHOD(void, BeginQueryEXT, (GLenum target, GLuint id), (override));
+  MOCK_METHOD(void, EndQueryEXT, (GLuint id), (override));
+  MOCK_METHOD(void,
+              GetQueryObjectuivEXT,
+              (GLuint id, GLenum target, GLuint* result),
+              (override));
+  MOCK_METHOD(void,
+              GetQueryObjectui64vEXT,
+              (GLuint id, GLenum target, GLuint64* result),
+              (override));
+  MOCK_METHOD(void,
+              DeleteQueriesEXT,
+              (GLsizei size, const GLuint* queries),
+              (override));
 };
 
 /// @brief      Provides a mocked version of the |ProcTableGLES| class.
@@ -57,7 +80,9 @@ class MockGLESImpl : public IMockGLESImpl {
 /// See `README.md` for more information.
 class MockGLES final {
  public:
-  static std::shared_ptr<MockGLES> Init(std::unique_ptr<MockGLESImpl> impl);
+  static std::shared_ptr<MockGLES> Init(
+      std::unique_ptr<MockGLESImpl> impl,
+      const std::optional<std::vector<const char*>>& extensions = std::nullopt);
 
   /// @brief      Returns an initialized |MockGLES| instance.
   ///
@@ -72,23 +97,10 @@ class MockGLES final {
   /// @brief      Returns a configured |ProcTableGLES| instance.
   const ProcTableGLES& GetProcTable() const { return proc_table_; }
 
-  /// @brief      Returns a vector of the names of all recorded calls.
-  ///
-  /// Calls are cleared after this method is called.
-  std::vector<std::string> GetCapturedCalls() {
-    std::vector<std::string> calls = captured_calls_;
-    captured_calls_.clear();
-    return calls;
-  }
-
   ~MockGLES();
 
   IMockGLESImpl* GetImpl() { return impl_.get(); }
 
-  const std::vector<const char*>& GetExtensions() const { return extensions_; }
-
-  const char* GetVersion() const { return version_; }
-
  private:
   friend void RecordGLCall(const char* name);
   friend void mockGenTextures(GLsizei n, GLuint* textures);
@@ -100,8 +112,6 @@ class MockGLES final {
   ProcTableGLES proc_table_;
   std::vector<std::string> captured_calls_;
   std::unique_ptr<IMockGLESImpl> impl_;
-  std::vector<const char*> extensions_;
-  const char* version_;
 
   MockGLES(const MockGLES&) = delete;
 
diff --git a/impeller/renderer/backend/gles/test/mock_gles_unittests.cc b/impeller/renderer/backend/gles/test/mock_gles_unittests.cc
index 5345cdbd0054e..96dea6bffcbd9 100644
--- a/impeller/renderer/backend/gles/test/mock_gles_unittests.cc
+++ b/impeller/renderer/backend/gles/test/mock_gles_unittests.cc
@@ -21,19 +21,6 @@ TEST(MockGLES, CanInitialize) {
   EXPECT_EQ(vendor, "MockGLES");
 }
 
-// Tests we can call two functions and capture the calls.
-TEST(MockGLES, CapturesPushAndPopDebugGroup) {
-  auto mock_gles = MockGLES::Init();
-
-  auto& gl = mock_gles->GetProcTable();
-  gl.PushDebugGroupKHR(GL_DEBUG_SOURCE_APPLICATION_KHR, 0, -1, "test");
-  gl.PopDebugGroupKHR();
-
-  auto calls = mock_gles->GetCapturedCalls();
-  EXPECT_EQ(calls, std::vector<std::string>(
-                       {"PushDebugGroupKHR", "PopDebugGroupKHR"}));
-}
-
 // Tests that if we call a function we have not mocked, it's OK.
 TEST(MockGLES, CanCallUnmockedFunction) {
   auto mock_gles = MockGLES::Init();

From 0dbda59b184555e6d4743b6cc212691c0accd129 Mon Sep 17 00:00:00 2001
From: Aaron Clarke <aaclarke@google.com>
Date: Thu, 5 Dec 2024 15:03:15 -0800
Subject: [PATCH 08/11] removed captured calls

---
 .../gles/test/capabilities_unittests.cc       |  2 +-
 .../renderer/backend/gles/test/mock_gles.cc   | 23 ++-----------------
 .../renderer/backend/gles/test/mock_gles.h    |  3 ---
 3 files changed, 3 insertions(+), 25 deletions(-)

diff --git a/impeller/renderer/backend/gles/test/capabilities_unittests.cc b/impeller/renderer/backend/gles/test/capabilities_unittests.cc
index fbbf2b6315b30..ce2c1a44c84c1 100644
--- a/impeller/renderer/backend/gles/test/capabilities_unittests.cc
+++ b/impeller/renderer/backend/gles/test/capabilities_unittests.cc
@@ -54,7 +54,7 @@ TEST(CapabilitiesGLES, SupportsDecalSamplerAddressModeNotOES) {
 
 TEST(CapabilitiesGLES, SupportsFramebufferFetch) {
   auto const extensions = std::vector<const char*>{
-      "GL_KHR_debug",  //
+      "GL_KHR_debug",                     //
       "GL_EXT_shader_framebuffer_fetch",  //
   };
   auto mock_gles = MockGLES::Init(extensions);
diff --git a/impeller/renderer/backend/gles/test/mock_gles.cc b/impeller/renderer/backend/gles/test/mock_gles.cc
index b74ed80a2dab6..f2f30b8a496d0 100644
--- a/impeller/renderer/backend/gles/test/mock_gles.cc
+++ b/impeller/renderer/backend/gles/test/mock_gles.cc
@@ -23,13 +23,6 @@ static std::vector<const char*> g_extensions;
 
 static const char* g_version;
 
-// Has friend visibility into MockGLES to record calls.
-void RecordGLCall(const char* name) {
-  if (auto mock_gles = g_mock_gles.lock()) {
-    mock_gles->RecordCall(name);
-  }
-}
-
 template <typename T, typename U>
 struct CheckSameSignature : std::false_type {};
 
@@ -101,9 +94,7 @@ GLenum mockGetError() {
 static_assert(CheckSameSignature<decltype(mockGetError),  //
                                  decltype(glGetError)>::value);
 
-void mockPopDebugGroupKHR() {
-  RecordGLCall("PopDebugGroupKHR");
-}
+void mockPopDebugGroupKHR() {}
 
 static_assert(CheckSameSignature<decltype(mockPopDebugGroupKHR),  //
                                  decltype(glPopDebugGroupKHR)>::value);
@@ -111,9 +102,7 @@ static_assert(CheckSameSignature<decltype(mockPopDebugGroupKHR),  //
 void mockPushDebugGroupKHR(GLenum source,
                            GLuint id,
                            GLsizei length,
-                           const GLchar* message) {
-  RecordGLCall("PushDebugGroupKHR");
-}
+                           const GLchar* message) {}
 
 static_assert(CheckSameSignature<decltype(mockPushDebugGroupKHR),  //
                                  decltype(glPushDebugGroupKHR)>::value);
@@ -185,8 +174,6 @@ void mockDeleteTextures(GLsizei size, const GLuint* queries) {
   if (auto mock_gles = g_mock_gles.lock()) {
     if (mock_gles->GetImpl()) {
       mock_gles->GetImpl()->DeleteTextures(size, queries);
-    } else {
-      RecordGLCall("glDeleteTextures");
     }
   }
 }
@@ -198,8 +185,6 @@ void mockUniform1fv(GLint location, GLsizei count, const GLfloat* value) {
   if (auto mock_gles = g_mock_gles.lock()) {
     if (mock_gles->GetImpl()) {
       mock_gles->GetImpl()->Uniform1fv(location, count, value);
-    } else {
-      RecordGLCall("glUniform1fv");
     }
   }
 }
@@ -210,8 +195,6 @@ void mockGenTextures(GLsizei n, GLuint* textures) {
   if (auto mock_gles = g_mock_gles.lock()) {
     if (mock_gles->GetImpl()) {
       mock_gles->GetImpl()->GenTextures(n, textures);
-    } else {
-      RecordGLCall("glGenTextures");
     }
   }
 }
@@ -226,8 +209,6 @@ void mockObjectLabelKHR(GLenum identifier,
   if (auto mock_gles = g_mock_gles.lock()) {
     if (mock_gles->GetImpl()) {
       mock_gles->GetImpl()->ObjectLabelKHR(identifier, name, length, label);
-    } else {
-      RecordGLCall("glObjectLabelKHR");
     }
   }
 }
diff --git a/impeller/renderer/backend/gles/test/mock_gles.h b/impeller/renderer/backend/gles/test/mock_gles.h
index 43fc2be8f97be..35b041b13d5e2 100644
--- a/impeller/renderer/backend/gles/test/mock_gles.h
+++ b/impeller/renderer/backend/gles/test/mock_gles.h
@@ -107,10 +107,7 @@ class MockGLES final {
 
   explicit MockGLES(ProcTableGLES::Resolver resolver = kMockResolverGLES);
 
-  void RecordCall(const char* name) { captured_calls_.emplace_back(name); }
-
   ProcTableGLES proc_table_;
-  std::vector<std::string> captured_calls_;
   std::unique_ptr<IMockGLESImpl> impl_;
 
   MockGLES(const MockGLES&) = delete;

From 47929c5fa7d46002d060e705373ef0f471eeba3b Mon Sep 17 00:00:00 2001
From: Aaron Clarke <aaclarke@google.com>
Date: Thu, 5 Dec 2024 15:16:46 -0800
Subject: [PATCH 09/11] cleaned up gpu tracer

---
 .../gles/test/gpu_tracer_gles_unittests.cc    | 29 ++++---------------
 1 file changed, 6 insertions(+), 23 deletions(-)

diff --git a/impeller/renderer/backend/gles/test/gpu_tracer_gles_unittests.cc b/impeller/renderer/backend/gles/test/gpu_tracer_gles_unittests.cc
index f51c148854ad9..6714879993cdb 100644
--- a/impeller/renderer/backend/gles/test/gpu_tracer_gles_unittests.cc
+++ b/impeller/renderer/backend/gles/test/gpu_tracer_gles_unittests.cc
@@ -26,12 +26,14 @@ TEST(GPUTracerGLES, CanFormatFramebufferErrorMessage) {
           ids[i] = i + 1;
         }
       });
-  EXPECT_CALL(*mock_gles_impl, BeginQueryEXT(_, _)).Times(2);
-  EXPECT_CALL(*mock_gles_impl, EndQueryEXT(_));
-  EXPECT_CALL(*mock_gles_impl, GetQueryObjectuivEXT(_, _, _))
+  EXPECT_CALL(*mock_gles_impl, BeginQueryEXT(GL_TIME_ELAPSED_EXT, _)).Times(2);
+  EXPECT_CALL(*mock_gles_impl, EndQueryEXT(GL_TIME_ELAPSED_EXT));
+  EXPECT_CALL(*mock_gles_impl,
+              GetQueryObjectuivEXT(_, GL_QUERY_RESULT_AVAILABLE_EXT, _))
       .WillRepeatedly(
           [](GLuint id, GLenum target, GLuint* result) { *result = GL_TRUE; });
-  EXPECT_CALL(*mock_gles_impl, GetQueryObjectui64vEXT(_, _, _))
+  EXPECT_CALL(*mock_gles_impl,
+              GetQueryObjectui64vEXT(_, GL_QUERY_RESULT_EXT, _))
       .WillRepeatedly(
           [](GLuint id, GLenum target, GLuint64* result) { *result = 1000u; });
   EXPECT_CALL(*mock_gles_impl, DeleteQueriesEXT(_, _));
@@ -43,26 +45,7 @@ TEST(GPUTracerGLES, CanFormatFramebufferErrorMessage) {
   tracer->RecordRasterThread();
   tracer->MarkFrameStart(mock_gles->GetProcTable());
   tracer->MarkFrameEnd(mock_gles->GetProcTable());
-
-  // auto calls = mock_gles->GetCapturedCalls();
-
-  // std::vector<std::string> expected = {"glGenQueriesEXT", "glBeginQueryEXT",
-  //                                      "glEndQueryEXT"};
-  // for (auto i = 0; i < 3; i++) {
-  //   EXPECT_EQ(calls[i], expected[i]);
-  // }
-
-  // Begin second frame, which prompts the tracer to query the result
-  // from the previous frame.
   tracer->MarkFrameStart(mock_gles->GetProcTable());
-
-  // calls = mock_gles->GetCapturedCalls();
-  // std::vector<std::string> expected_b = {"glGetQueryObjectuivEXT",
-  //                                        "glGetQueryObjectui64vEXT",
-  //                                        "glDeleteQueriesEXT"};
-  // for (auto i = 0; i < 3; i++) {
-  //   EXPECT_EQ(calls[i], expected_b[i]);
-  // }
 }
 
 #endif  // IMPELLER_DEBUG

From 84333d147132a3ba113f0951be45aac1b8383fc1 Mon Sep 17 00:00:00 2001
From: Aaron Clarke <aaclarke@google.com>
Date: Thu, 5 Dec 2024 15:23:50 -0800
Subject: [PATCH 10/11] readded timing assert

---
 .../gles/test/gpu_tracer_gles_unittests.cc    | 42 +++++++++++--------
 1 file changed, 24 insertions(+), 18 deletions(-)

diff --git a/impeller/renderer/backend/gles/test/gpu_tracer_gles_unittests.cc b/impeller/renderer/backend/gles/test/gpu_tracer_gles_unittests.cc
index 6714879993cdb..2ee1da6c1b386 100644
--- a/impeller/renderer/backend/gles/test/gpu_tracer_gles_unittests.cc
+++ b/impeller/renderer/backend/gles/test/gpu_tracer_gles_unittests.cc
@@ -20,24 +20,30 @@ TEST(GPUTracerGLES, CanFormatFramebufferErrorMessage) {
   };
   auto mock_gles_impl = std::make_unique<MockGLESImpl>();
 
-  EXPECT_CALL(*mock_gles_impl, GenQueriesEXT(_, _))
-      .WillRepeatedly([](GLsizei n, GLuint* ids) {
-        for (int i = 0; i < n; ++i) {
-          ids[i] = i + 1;
-        }
-      });
-  EXPECT_CALL(*mock_gles_impl, BeginQueryEXT(GL_TIME_ELAPSED_EXT, _)).Times(2);
-  EXPECT_CALL(*mock_gles_impl, EndQueryEXT(GL_TIME_ELAPSED_EXT));
-  EXPECT_CALL(*mock_gles_impl,
-              GetQueryObjectuivEXT(_, GL_QUERY_RESULT_AVAILABLE_EXT, _))
-      .WillRepeatedly(
-          [](GLuint id, GLenum target, GLuint* result) { *result = GL_TRUE; });
-  EXPECT_CALL(*mock_gles_impl,
-              GetQueryObjectui64vEXT(_, GL_QUERY_RESULT_EXT, _))
-      .WillRepeatedly(
-          [](GLuint id, GLenum target, GLuint64* result) { *result = 1000u; });
-  EXPECT_CALL(*mock_gles_impl, DeleteQueriesEXT(_, _));
-
+  {
+    ::testing::InSequence seq;
+    auto gen_queries = [](GLsizei n, GLuint* ids) {
+      for (int i = 0; i < n; ++i) {
+        ids[i] = i + 1;
+      }
+    };
+    EXPECT_CALL(*mock_gles_impl, GenQueriesEXT(_, _)).WillOnce(gen_queries);
+    EXPECT_CALL(*mock_gles_impl, BeginQueryEXT(GL_TIME_ELAPSED_EXT, _));
+    EXPECT_CALL(*mock_gles_impl, EndQueryEXT(GL_TIME_ELAPSED_EXT));
+    EXPECT_CALL(*mock_gles_impl,
+                GetQueryObjectuivEXT(_, GL_QUERY_RESULT_AVAILABLE_EXT, _))
+        .WillOnce([](GLuint id, GLenum target, GLuint* result) {
+          *result = GL_TRUE;
+        });
+    EXPECT_CALL(*mock_gles_impl,
+                GetQueryObjectui64vEXT(_, GL_QUERY_RESULT_EXT, _))
+        .WillOnce([](GLuint id, GLenum target, GLuint64* result) {
+          *result = 1000u;
+        });
+    EXPECT_CALL(*mock_gles_impl, DeleteQueriesEXT(_, _));
+    EXPECT_CALL(*mock_gles_impl, GenQueriesEXT(_, _)).WillOnce(gen_queries);
+    EXPECT_CALL(*mock_gles_impl, BeginQueryEXT(GL_TIME_ELAPSED_EXT, _));
+  }
   std::shared_ptr<MockGLES> mock_gles =
       MockGLES::Init(std::move(mock_gles_impl), extensions);
   auto tracer =

From ef9387e2b86abeecbe551c8cf680b8a46f149c71 Mon Sep 17 00:00:00 2001
From: Aaron Clarke <aaclarke@google.com>
Date: Thu, 5 Dec 2024 15:35:14 -0800
Subject: [PATCH 11/11] removed redundancy

---
 .../renderer/backend/gles/test/mock_gles.cc   | 72 ++++++-------------
 1 file changed, 22 insertions(+), 50 deletions(-)

diff --git a/impeller/renderer/backend/gles/test/mock_gles.cc b/impeller/renderer/backend/gles/test/mock_gles.cc
index f2f30b8a496d0..5b890d989f37a 100644
--- a/impeller/renderer/backend/gles/test/mock_gles.cc
+++ b/impeller/renderer/backend/gles/test/mock_gles.cc
@@ -38,6 +38,17 @@ auto const kExtensions = std::vector<const char*>{
     "GL_KHR_debug"  //
 };
 
+namespace {
+template <typename Func, typename... Args>
+void CallMockMethod(Func func, Args&&... args) {
+  if (auto mock_gles = g_mock_gles.lock()) {
+    if (mock_gles->GetImpl()) {
+      (mock_gles->GetImpl()->*func)(std::forward<Args>(args)...);
+    }
+  }
+}
+}  // namespace
+
 const unsigned char* mockGetString(GLenum name) {
   switch (name) {
     case GL_VENDOR:
@@ -108,95 +119,59 @@ static_assert(CheckSameSignature<decltype(mockPushDebugGroupKHR),  //
                                  decltype(glPushDebugGroupKHR)>::value);
 
 void mockGenQueriesEXT(GLsizei n, GLuint* ids) {
-  if (auto mock_gles = g_mock_gles.lock()) {
-    if (mock_gles->GetImpl()) {
-      mock_gles->GetImpl()->GenQueriesEXT(n, ids);
-    }
-  }
+  CallMockMethod(&IMockGLESImpl::GenQueriesEXT, n, ids);
 }
 
 static_assert(CheckSameSignature<decltype(mockGenQueriesEXT),  //
                                  decltype(glGenQueriesEXT)>::value);
 
 void mockBeginQueryEXT(GLenum target, GLuint id) {
-  if (auto mock_gles = g_mock_gles.lock()) {
-    if (mock_gles->GetImpl()) {
-      mock_gles->GetImpl()->BeginQueryEXT(target, id);
-    }
-  }
+  CallMockMethod(&IMockGLESImpl::BeginQueryEXT, target, id);
 }
 
 static_assert(CheckSameSignature<decltype(mockBeginQueryEXT),  //
                                  decltype(glBeginQueryEXT)>::value);
 
 void mockEndQueryEXT(GLuint id) {
-  if (auto mock_gles = g_mock_gles.lock()) {
-    if (mock_gles->GetImpl()) {
-      mock_gles->GetImpl()->EndQueryEXT(id);
-    }
-  }
+  CallMockMethod(&IMockGLESImpl::EndQueryEXT, id);
 }
 
 static_assert(CheckSameSignature<decltype(mockEndQueryEXT),  //
                                  decltype(glEndQueryEXT)>::value);
 
 void mockGetQueryObjectuivEXT(GLuint id, GLenum target, GLuint* result) {
-  if (auto mock_gles = g_mock_gles.lock()) {
-    if (mock_gles->GetImpl()) {
-      mock_gles->GetImpl()->GetQueryObjectuivEXT(id, target, result);
-    }
-  }
+  CallMockMethod(&IMockGLESImpl::GetQueryObjectuivEXT, id, target, result);
 }
 
 static_assert(CheckSameSignature<decltype(mockGetQueryObjectuivEXT),  //
                                  decltype(glGetQueryObjectuivEXT)>::value);
 
 void mockGetQueryObjectui64vEXT(GLuint id, GLenum target, GLuint64* result) {
-  if (auto mock_gles = g_mock_gles.lock()) {
-    if (mock_gles->GetImpl()) {
-      mock_gles->GetImpl()->GetQueryObjectui64vEXT(id, target, result);
-    }
-  }
+  CallMockMethod(&IMockGLESImpl::GetQueryObjectui64vEXT, id, target, result);
 }
 
 static_assert(CheckSameSignature<decltype(mockGetQueryObjectui64vEXT),  //
                                  decltype(glGetQueryObjectui64vEXT)>::value);
 
 void mockDeleteQueriesEXT(GLsizei size, const GLuint* queries) {
-  if (auto mock_gles = g_mock_gles.lock()) {
-    if (mock_gles->GetImpl()) {
-      mock_gles->GetImpl()->DeleteQueriesEXT(size, queries);
-    }
-  }
+  CallMockMethod(&IMockGLESImpl::DeleteQueriesEXT, size, queries);
 }
 
 void mockDeleteTextures(GLsizei size, const GLuint* queries) {
-  if (auto mock_gles = g_mock_gles.lock()) {
-    if (mock_gles->GetImpl()) {
-      mock_gles->GetImpl()->DeleteTextures(size, queries);
-    }
-  }
+  CallMockMethod(&IMockGLESImpl::DeleteTextures, size, queries);
 }
 
 static_assert(CheckSameSignature<decltype(mockDeleteQueriesEXT),  //
                                  decltype(glDeleteQueriesEXT)>::value);
 
 void mockUniform1fv(GLint location, GLsizei count, const GLfloat* value) {
-  if (auto mock_gles = g_mock_gles.lock()) {
-    if (mock_gles->GetImpl()) {
-      mock_gles->GetImpl()->Uniform1fv(location, count, value);
-    }
-  }
+  CallMockMethod(&IMockGLESImpl::Uniform1fv, location, count, value);
 }
 static_assert(CheckSameSignature<decltype(mockUniform1fv),  //
                                  decltype(glUniform1fv)>::value);
 
 void mockGenTextures(GLsizei n, GLuint* textures) {
-  if (auto mock_gles = g_mock_gles.lock()) {
-    if (mock_gles->GetImpl()) {
-      mock_gles->GetImpl()->GenTextures(n, textures);
-    }
-  }
+  CallMockMethod(&IMockGLESImpl::GenTextures, n, textures);
 }
 
 static_assert(CheckSameSignature<decltype(mockGenTextures),  //
@@ -206,11 +181,8 @@ void mockObjectLabelKHR(GLenum identifier,
                         GLuint name,
                         GLsizei length,
                         const GLchar* label) {
-  if (auto mock_gles = g_mock_gles.lock()) {
-    if (mock_gles->GetImpl()) {
-      mock_gles->GetImpl()->ObjectLabelKHR(identifier, name, length, label);
-    }
-  }
+  CallMockMethod(&IMockGLESImpl::ObjectLabelKHR, identifier, name, length,
+                 label);
 }
 static_assert(CheckSameSignature<decltype(mockObjectLabelKHR),  //
                                  decltype(glObjectLabelKHR)>::value);