Revert "Use AChoreographer methods to await vsync when available (#31859)"

This reverts commit 266d336.

Author: Emmanuel Garcia

ci/licenses_golden/licenses_flutter

@@ -1146,8 +1146,6 @@ FILE: ../../../flutter/shell/gpu/gpu_surface_vulkan.h
 FILE: ../../../flutter/shell/gpu/gpu_surface_vulkan_delegate.cc
 FILE: ../../../flutter/shell/gpu/gpu_surface_vulkan_delegate.h
 FILE: ../../../flutter/shell/platform/android/AndroidManifest.xml
-FILE: ../../../flutter/shell/platform/android/android_choreographer.cc
-FILE: ../../../flutter/shell/platform/android/android_choreographer.h
 FILE: ../../../flutter/shell/platform/android/android_context_gl.cc
 FILE: ../../../flutter/shell/platform/android/android_context_gl.h
 FILE: ../../../flutter/shell/platform/android/android_context_gl_unittests.cc

shell/platform/android/BUILD.gn

@@ -62,8 +62,6 @@ source_set("flutter_shell_native_src") {
 
   sources = [
     "$root_build_dir/flutter_icu/icudtl.o",
-    "android_choreographer.cc",
-    "android_choreographer.h",
     "android_context_gl.cc",
     "android_context_gl.h",
     "android_display.cc",

shell/platform/android/android_choreographer.cc

@@ -257,18 +257,8 @@ public void setRefreshRateFPS(float refreshRateFPS) {
     // on Android we will need to refactor this. Static lookup makes things a
     // bit easier on the C++ side.
     FlutterJNI.refreshRateFPS = refreshRateFPS;
-    updateRefreshRate();
   }
 
-  public void updateRefreshRate() {
-    if (!FlutterJNI.loadLibraryCalled) {
-      return;
-    }
-    nativeUpdateRefreshRate(refreshRateFPS);
-  }
-
-  private native void nativeUpdateRefreshRate(float refreshRateFPS);
-
   /**
    * The Android vsync waiter implementation in C++ needs to know when a vsync signal arrives, which
    * is obtained via Java API. The delegate set here is called on the C++ side when the engine is

shell/platform/android/android_choreographer.h

@@ -183,7 +183,6 @@ public InitResult call() {
                 ResourceExtractor resourceExtractor = initResources(appContext);
 
                 flutterJNI.loadLibrary();
-                flutterJNI.updateRefreshRate();
 
                 // Prefetch the default font manager as soon as possible on a background thread.
                 // It helps to reduce time cost of engine setup that blocks the platform thread.

shell/platform/android/io/flutter/embedding/engine/FlutterJNI.java

@@ -2,7 +2,6 @@
 
 import static org.junit.Assert.assertEquals;
 import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
@@ -246,13 +245,4 @@ public void invokePlatformMessageResponseCallback__wantsDirectBuffer() {
     ByteBuffer buffer = ByteBuffer.allocate(4);
     flutterJNI.invokePlatformMessageResponseCallback(0, buffer, buffer.position());
   }
-
-  @Test
-  public void setRefreshRateFPS__callsUpdateRefreshRate() {
-    FlutterJNI flutterJNI = spy(new FlutterJNI());
-    // --- Execute Test ---
-    flutterJNI.setRefreshRateFPS(120.0f);
-    // --- Verify Results ---
-    verify(flutterJNI, times(1)).updateRefreshRate();
-  }
 }

shell/platform/android/io/flutter/embedding/engine/loader/FlutterLoader.java

@@ -55,7 +55,6 @@ public void itReportsInitializedAfterInitializing() {
     shadowOf(getMainLooper()).idle();
     assertTrue(flutterLoader.initialized());
     verify(mockFlutterJNI, times(1)).loadLibrary();
-    verify(mockFlutterJNI, times(1)).updateRefreshRate();
   }
 
   @Test

shell/platform/android/test/io/flutter/embedding/engine/FlutterJNITest.java

@@ -13,81 +13,53 @@
 #include "flutter/fml/platform/android/scoped_java_ref.h"
 #include "flutter/fml/size.h"
 #include "flutter/fml/trace_event.h"
-#include "flutter/shell/platform/android/android_choreographer.h"
 
 namespace flutter {
 
 static fml::jni::ScopedJavaGlobalRef<jclass>* g_vsync_waiter_class = nullptr;
 static jmethodID g_async_wait_for_vsync_method_ = nullptr;
-static std::atomic_uint g_refresh_rate_ = 60;
 
 VsyncWaiterAndroid::VsyncWaiterAndroid(flutter::TaskRunners task_runners)
-    : VsyncWaiter(std::move(task_runners)),
-      use_ndk_choreographer_(
-          AndroidChoreographer::ShouldUseNDKChoreographer()) {}
+    : VsyncWaiter(std::move(task_runners)) {}
 
 VsyncWaiterAndroid::~VsyncWaiterAndroid() = default;
 
 // |VsyncWaiter|
 void VsyncWaiterAndroid::AwaitVSync() {
-  if (use_ndk_choreographer_) {
-    auto* weak_this = new std::weak_ptr<VsyncWaiter>(shared_from_this());
-    fml::TaskRunner::RunNowOrPostTask(
-        task_runners_.GetUITaskRunner(), [weak_this]() {
-          AndroidChoreographer::PostFrameCallback(&OnVsyncFromNDK, weak_this);
-        });
-  } else {
-    // TODO(99798): Remove it when we drop support for API level < 29.
-    auto* weak_this = new std::weak_ptr<VsyncWaiter>(shared_from_this());
-    jlong java_baton = reinterpret_cast<jlong>(weak_this);
-    task_runners_.GetPlatformTaskRunner()->PostTask([java_baton]() {
-      JNIEnv* env = fml::jni::AttachCurrentThread();
-      env->CallStaticVoidMethod(g_vsync_waiter_class->obj(),     //
-                                g_async_wait_for_vsync_method_,  //
-                                java_baton                       //
-      );
-    });
-  }
-}
-
-// static
-void VsyncWaiterAndroid::OnVsyncFromNDK(int64_t frame_nanos, void* data) {
-  TRACE_EVENT0("flutter", "VSYNC");
-
-  auto frame_time = fml::TimePoint::FromEpochDelta(
-      fml::TimeDelta::FromNanoseconds(frame_nanos));
-  auto now = fml::TimePoint::Now();
-  if (frame_time > now) {
-    frame_time = now;
-  }
-  auto target_time = frame_time + fml::TimeDelta::FromNanoseconds(
-                                      1000000000.0 / g_refresh_rate_);
-  auto* weak_this = reinterpret_cast<std::weak_ptr<VsyncWaiter>*>(data);
-  ConsumePendingCallback(weak_this, frame_time, target_time);
+  auto* weak_this = new std::weak_ptr<VsyncWaiter>(shared_from_this());
+  jlong java_baton = reinterpret_cast<jlong>(weak_this);
+
+  task_runners_.GetPlatformTaskRunner()->PostTask([java_baton]() {
+    JNIEnv* env = fml::jni::AttachCurrentThread();
+    env->CallStaticVoidMethod(g_vsync_waiter_class->obj(),     //
+                              g_async_wait_for_vsync_method_,  //
+                              java_baton                       //
+    );
+  });
 }
 
 // static
-void VsyncWaiterAndroid::OnVsyncFromJava(JNIEnv* env,
-                                         jclass jcaller,
-                                         jlong frameDelayNanos,
-                                         jlong refreshPeriodNanos,
-                                         jlong java_baton) {
+void VsyncWaiterAndroid::OnNativeVsync(JNIEnv* env,
+                                       jclass jcaller,
+                                       jlong frameDelayNanos,
+                                       jlong refreshPeriodNanos,
+                                       jlong java_baton) {
   TRACE_EVENT0("flutter", "VSYNC");
 
   auto frame_time =
       fml::TimePoint::Now() - fml::TimeDelta::FromNanoseconds(frameDelayNanos);
   auto target_time =
       frame_time + fml::TimeDelta::FromNanoseconds(refreshPeriodNanos);
 
-  auto* weak_this = reinterpret_cast<std::weak_ptr<VsyncWaiter>*>(java_baton);
-  ConsumePendingCallback(weak_this, frame_time, target_time);
+  ConsumePendingCallback(java_baton, frame_time, target_time);
 }
 
 // static
 void VsyncWaiterAndroid::ConsumePendingCallback(
-    std::weak_ptr<VsyncWaiter>* weak_this,
+    jlong java_baton,
     fml::TimePoint frame_start_time,
     fml::TimePoint frame_target_time) {
+  auto* weak_this = reinterpret_cast<std::weak_ptr<VsyncWaiter>*>(java_baton);
   auto shared_this = weak_this->lock();
   delete weak_this;
 
@@ -96,27 +68,13 @@ void VsyncWaiterAndroid::ConsumePendingCallback(
   }
 }
 
-// static
-void VsyncWaiterAndroid::OnUpdateRefreshRate(JNIEnv* env,
-                                             jclass jcaller,
-                                             jfloat refresh_rate) {
-  FML_DCHECK(refresh_rate > 0);
-  g_refresh_rate_ = static_cast<uint>(refresh_rate);
-}
-
 // static
 bool VsyncWaiterAndroid::Register(JNIEnv* env) {
-  static const JNINativeMethod methods[] = {
-      {
-          .name = "nativeOnVsync",
-          .signature = "(JJJ)V",
-          .fnPtr = reinterpret_cast<void*>(&OnVsyncFromJava),
-      },
-      {
-          .name = "nativeUpdateRefreshRate",
-          .signature = "(F)V",
-          .fnPtr = reinterpret_cast<void*>(&OnUpdateRefreshRate),
-      }};
+  static const JNINativeMethod methods[] = {{
+      .name = "nativeOnVsync",
+      .signature = "(JJJ)V",
+      .fnPtr = reinterpret_cast<void*>(&OnNativeVsync),
+  }};
 
   jclass clazz = env->FindClass("io/flutter/embedding/engine/FlutterJNI");
 
@@ -125,10 +83,12 @@ bool VsyncWaiterAndroid::Register(JNIEnv* env) {
   }
 
   g_vsync_waiter_class = new fml::jni::ScopedJavaGlobalRef<jclass>(env, clazz);
+
   FML_CHECK(!g_vsync_waiter_class->is_null());
 
   g_async_wait_for_vsync_method_ = env->GetStaticMethodID(
       g_vsync_waiter_class->obj(), "asyncWaitForVsync", "(J)V");
+
   FML_CHECK(g_async_wait_for_vsync_method_ != nullptr);
 
   return env->RegisterNatives(clazz, methods, fml::size(methods)) == 0;

shell/platform/android/test/io/flutter/embedding/engine/loader/FlutterLoaderTest.java

@@ -14,8 +14,6 @@
 
 namespace flutter {
 
-class AndroidChoreographer;
-
 class VsyncWaiterAndroid final : public VsyncWaiter {
  public:
   static bool Register(JNIEnv* env);
@@ -28,23 +26,16 @@ class VsyncWaiterAndroid final : public VsyncWaiter {
   // |VsyncWaiter|
   void AwaitVSync() override;
 
-  static void OnVsyncFromNDK(int64_t frame_nanos, void* data);
-
-  static void OnVsyncFromJava(JNIEnv* env,
-                              jclass jcaller,
-                              jlong frameDelayNanos,
-                              jlong refreshPeriodNanos,
-                              jlong java_baton);
+  static void OnNativeVsync(JNIEnv* env,
+                            jclass jcaller,
+                            jlong frameDelayNanos,
+                            jlong refreshPeriodNanos,
+                            jlong java_baton);
 
-  static void ConsumePendingCallback(std::weak_ptr<VsyncWaiter>* weak_this,
+  static void ConsumePendingCallback(jlong java_baton,
                                      fml::TimePoint frame_start_time,
                                      fml::TimePoint frame_target_time);
 
-  static void OnUpdateRefreshRate(JNIEnv* env,
-                                  jclass jcaller,
-                                  jfloat refresh_rate);
-
-  const bool use_ndk_choreographer_;
   FML_DISALLOW_COPY_AND_ASSIGN(VsyncWaiterAndroid);
 };