re-implement VsyncWaiter - all tests and rebased

Author: farchond

ci/licenses_golden/licenses_flutter

@@ -1366,7 +1366,6 @@ FILE: ../../../flutter/shell/platform/fuchsia/flutter/vsync_recorder.cc
 FILE: ../../../flutter/shell/platform/fuchsia/flutter/vsync_recorder.h
 FILE: ../../../flutter/shell/platform/fuchsia/flutter/vsync_waiter.cc
 FILE: ../../../flutter/shell/platform/fuchsia/flutter/vsync_waiter.h
-FILE: ../../../flutter/shell/platform/fuchsia/flutter/vsync_waiter_unittests.cc
 FILE: ../../../flutter/shell/platform/fuchsia/flutter/vulkan_surface.cc
 FILE: ../../../flutter/shell/platform/fuchsia/flutter/vulkan_surface.h
 FILE: ../../../flutter/shell/platform/fuchsia/flutter/vulkan_surface_pool.cc

shell/common/animator.cc

@@ -124,6 +124,7 @@ void Animator::BeginFrame(
       // If we still don't have valid continuation, the pipeline is currently
       // full because the consumer is being too slow. Try again at the next
       // frame interval.
+      TRACE_EVENT0("flutter", "PipelineFull");
       RequestFrame();
       return;
     }

shell/platform/fuchsia/flutter/BUILD.gn

@@ -456,7 +456,8 @@ executable("flutter_runner_unittests") {
     "tests/engine_unittests.cc",
     "tests/flutter_runner_product_configuration_unittests.cc",
     "tests/vsync_recorder_unittests.cc",
-    "vsync_waiter_unittests.cc",
+    "tests/vsync_waiter_unittests.cc",
+    "tests/fake_session_connection.h",
   ]
 
   # This is needed for //third_party/googletest for linking zircon symbols.

shell/platform/fuchsia/flutter/default_session_connection.cc

@@ -17,30 +17,28 @@ DefaultSessionConnection::DefaultSessionConnection(
     fidl::InterfaceHandle<fuchsia::ui::scenic::Session> session,
     fml::closure session_error_callback,
     on_frame_presented_event on_frame_presented_callback,
-    zx_handle_t vsync_event_handle,
     uint64_t max_frames_in_flight)
     : session_wrapper_(session.Bind(), nullptr),
       on_frame_presented_callback_(std::move(on_frame_presented_callback)),
-      vsync_event_handle_(vsync_event_handle),
       kMaxFramesInFlight(max_frames_in_flight) {
   session_wrapper_.set_error_handler(
       [callback = session_error_callback](zx_status_t status) { callback(); });
 
   // Set the |fuchsia::ui::scenic::OnFramePresented()| event handler that will
   // fire every time a set of one or more frames is presented.
   session_wrapper_.set_on_frame_presented_handler(
-      [this, handle = vsync_event_handle_](
-          fuchsia::scenic::scheduling::FramePresentedInfo info) {
+      [this](fuchsia::scenic::scheduling::FramePresentedInfo info) {
         // Update Scenic's limit for our remaining frames in flight allowed.
         size_t num_presents_handled = info.presentation_infos.size();
         frames_in_flight_allowed_ = info.num_presents_allowed;
 
         // A frame was presented: Update our |frames_in_flight| to match the
         // updated unfinalized present requests.
         frames_in_flight_ -= num_presents_handled;
-        TRACE_EVENT2("gfx", "DSC::OnFramePresented", "frames_in_flight",
-                     frames_in_flight_, "max_frames_in_flight",
-                     kMaxFramesInFlight);
+        TRACE_DURATION("gfx", "OnFramePresented", "frames_in_flight",
+                       frames_in_flight_, "max_frames_in_flight",
+                       kMaxFramesInFlight, "num_presents_handled",
+                       num_presents_handled);
         FML_DCHECK(frames_in_flight_ >= 0);
 
         VsyncRecorder::GetInstance().UpdateFramePresentedInfo(
@@ -52,7 +50,10 @@ DefaultSessionConnection::DefaultSessionConnection(
         if (present_session_pending_) {
           PresentSession();
         }
-        ToggleSignal(handle, true);
+
+        if (vsync_waiter_initialized_) {
+          vsync_waiter_callback_();
+        }
       }  // callback
   );
 
@@ -70,8 +71,6 @@ DefaultSessionConnection::DefaultSessionConnection(
         VsyncRecorder::GetInstance().UpdateNextPresentationInfo(
             std::move(info));
 
-        // Signal is initially high indicating availability of the session.
-        ToggleSignal(vsync_event_handle_, true);
         initialized_ = true;
 
         PresentSession();
@@ -101,7 +100,6 @@ void DefaultSessionConnection::Present() {
     FML_CHECK(frames_in_flight_ <= kMaxFramesInFlight);
 
     present_session_pending_ = true;
-    ToggleSignal(vsync_event_handle_, false);
   }
 }
 
@@ -197,15 +195,12 @@ void DefaultSessionConnection::PresentSession() {
       });
 }
 
-void DefaultSessionConnection::ToggleSignal(zx_handle_t handle, bool set) {
-  const auto signal = VsyncWaiter::SessionPresentSignal;
-  auto status = zx_object_signal(handle,            // handle
-                                 set ? 0 : signal,  // clear mask
-                                 set ? signal : 0   // set mask
-  );
-  if (status != ZX_OK) {
-    FML_LOG(ERROR) << "Could not toggle vsync signal: " << set;
-  }
+void DefaultSessionConnection::InitializeVsyncWaiterCallback(
+    VsyncWaiterCallback callback) {
+  FML_CHECK(!vsync_waiter_initialized_);
+
+  vsync_waiter_callback_ = callback;
+  vsync_waiter_initialized_ = true;
 }
 
 }  // namespace flutter_runner

shell/platform/fuchsia/flutter/default_session_connection.h

@@ -14,21 +14,24 @@
 #include "flutter/fml/closure.h"
 #include "flutter/fml/macros.h"
 
+#include "session_connection.h"
+
 namespace flutter_runner {
 
 using on_frame_presented_event =
     std::function<void(fuchsia::scenic::scheduling::FramePresentedInfo)>;
 
 // The component residing on the raster thread that is responsible for
 // maintaining the Scenic session connection and presenting node updates.
-class DefaultSessionConnection final : public flutter::SessionWrapper {
+class DefaultSessionConnection final
+    : public flutter::SessionWrapper,
+      public flutter_runner::SessionConnection {
  public:
   DefaultSessionConnection(
       std::string debug_label,
       fidl::InterfaceHandle<fuchsia::ui::scenic::Session> session,
       fml::closure session_error_callback,
       on_frame_presented_event on_frame_presented_callback,
-      zx_handle_t vsync_event_handle,
       uint64_t max_frames_in_flight);
 
   ~DefaultSessionConnection();
@@ -45,6 +48,12 @@ class DefaultSessionConnection final : public flutter::SessionWrapper {
       std::deque<std::pair<fml::TimePoint, fml::TimePoint>>&
           future_presentation_infos);
 
+  void InitializeVsyncWaiterCallback(VsyncWaiterCallback callback) override;
+
+  bool CanRequestNewFrames() override {
+    return frames_in_flight_ < kMaxFramesInFlight;
+  }
+
  private:
   scenic::Session session_wrapper_;
 
@@ -80,6 +89,9 @@ class DefaultSessionConnection final : public flutter::SessionWrapper {
 
   bool present_session_pending_ = false;
 
+  bool vsync_waiter_initialized_ = false;
+  VsyncWaiterCallback vsync_waiter_callback_;
+
   void PresentSession();
 
   static void ToggleSignal(zx_handle_t handle, bool raise);

shell/platform/fuchsia/flutter/engine.cc

@@ -76,10 +76,6 @@ Engine::Engine(Delegate& delegate,
 #endif
       intercept_all_input_(product_config.get_intercept_all_input()),
       weak_factory_(this) {
-  if (zx::event::create(0, &vsync_event_) != ZX_OK) {
-    FML_DLOG(ERROR) << "Could not create the vsync event.";
-    return;
-  }
 
   // Get the task runners from the managed threads. The current thread will be
   // used as the "platform" thread.
@@ -138,26 +134,27 @@ Engine::Engine(Delegate& delegate,
        view_token = std::move(view_token),
        view_ref_pair = std::move(view_ref_pair),
        max_frames_in_flight = product_config.get_max_frames_in_flight(),
-       vsync_handle = vsync_event_.get(), &view_embedder_latch]() mutable {
-        session_connection_.emplace(
+       &view_embedder_latch]() mutable {
+        FML_LOG(INFO) << "FELIPE: made shared";
+        session_connection_ = std::make_shared<DefaultSessionConnection>(
             thread_label_, std::move(session),
-            std::move(session_error_callback), [](auto) {}, vsync_handle,
+            std::move(session_error_callback), [](auto) {},
             max_frames_in_flight);
         surface_producer_.emplace(session_connection_->get());
 #if defined(LEGACY_FUCHSIA_EMBEDDER)
         if (use_legacy_renderer_) {
           legacy_external_view_embedder_ =
               std::make_shared<flutter::SceneUpdateContext>(
                   thread_label_, std::move(view_token),
-                  std::move(view_ref_pair), session_connection_.value(),
+                  std::move(view_ref_pair), *(session_connection_.get()),
                   intercept_all_input_);
         } else
 #endif
         {
           external_view_embedder_ =
               std::make_shared<FuchsiaExternalViewEmbedder>(
                   thread_label_, std::move(view_token),
-                  std::move(view_ref_pair), session_connection_.value(),
+                  std::move(view_ref_pair), *session_connection_.get(),
                   surface_producer_.value(), intercept_all_input_);
         }
         view_embedder_latch.Signal();
@@ -232,8 +229,8 @@ Engine::Engine(Delegate& delegate,
   // Setup the callback that will instantiate the platform view.
   flutter::Shell::CreateCallback<flutter::PlatformView>
       on_create_platform_view = fml::MakeCopyable(
-          [debug_label = thread_label_, view_ref = std::move(platform_view_ref),
-           runner_services,
+          [this, debug_label = thread_label_,
+           view_ref = std::move(platform_view_ref), runner_services,
            parent_environment_service_provider =
                std::move(parent_environment_service_provider),
            session_listener_request = std::move(session_listener_request),
@@ -248,7 +245,6 @@ Engine::Engine(Delegate& delegate,
            on_create_surface_callback = std::move(on_create_surface_callback),
            external_view_embedder = GetExternalViewEmbedder(),
            vsync_offset = product_config.get_vsync_offset(),
-           vsync_handle = vsync_event_.get(),
            keyboard_listener_request = std::move(keyboard_listener_request)](
               flutter::Shell& shell) mutable {
             return std::make_unique<flutter_runner::PlatformView>(
@@ -271,7 +267,7 @@ Engine::Engine(Delegate& delegate,
                 std::move(on_create_surface_callback),
                 external_view_embedder,   // external view embedder
                 std::move(vsync_offset),  // vsync offset
-                vsync_handle);
+                session_connection_);
           });
 
   // Setup the callback that will instantiate the rasterizer.
@@ -295,7 +291,7 @@ Engine::Engine(Delegate& delegate,
 
       auto compositor_context =
           std::make_unique<flutter_runner::CompositorContext>(
-              session_connection_.value(), surface_producer_.value(),
+              *(session_connection_.get()), surface_producer_.value(),
               legacy_external_view_embedder_);
       return std::make_unique<flutter::Rasterizer>(
           shell, std::move(compositor_context));

shell/platform/fuchsia/flutter/engine.h

@@ -74,7 +74,7 @@ class Engine final {
   const std::string thread_label_;
   std::array<Thread, 3> threads_;
 
-  std::optional<DefaultSessionConnection> session_connection_;
+  std::shared_ptr<DefaultSessionConnection> session_connection_;
   std::optional<VulkanSurfaceProducer> surface_producer_;
   std::shared_ptr<FuchsiaExternalViewEmbedder> external_view_embedder_;
 #if defined(LEGACY_FUCHSIA_EMBEDDER)

shell/platform/fuchsia/flutter/platform_view.cc

@@ -74,7 +74,7 @@ PlatformView::PlatformView(
     OnCreateSurface on_create_surface_callback,
     std::shared_ptr<flutter::ExternalViewEmbedder> external_view_embedder,
     fml::TimeDelta vsync_offset,
-    zx_handle_t vsync_event_handle)
+    std::shared_ptr<SessionConnection> session_connection)
     : flutter::PlatformView(delegate, std::move(task_runners)),
       debug_label_(std::move(debug_label)),
       view_ref_(std::move(view_ref)),
@@ -90,7 +90,7 @@ PlatformView::PlatformView(
       external_view_embedder_(external_view_embedder),
       ime_client_(this),
       vsync_offset_(std::move(vsync_offset)),
-      vsync_event_handle_(vsync_event_handle),
+      session_connection_(session_connection),
       keyboard_listener_binding_(this, std::move(keyboard_listener_request)),
       weak_factory_(this) {
   // Register all error handlers.
@@ -692,7 +692,7 @@ void PlatformView::DeactivateIme() {
 // |flutter::PlatformView|
 std::unique_ptr<flutter::VsyncWaiter> PlatformView::CreateVSyncWaiter() {
   return std::make_unique<flutter_runner::VsyncWaiter>(
-      debug_label_, vsync_event_handle_, task_runners_, vsync_offset_);
+      session_connection_, task_runners_, vsync_offset_);
 }
 
 // |flutter::PlatformView|

shell/platform/fuchsia/flutter/platform_view.h

@@ -72,7 +72,7 @@ class PlatformView final : public flutter::PlatformView,
                OnCreateSurface on_create_surface_callback,
                std::shared_ptr<flutter::ExternalViewEmbedder> view_embedder,
                fml::TimeDelta vsync_offset,
-               zx_handle_t vsync_event_handle);
+               std::shared_ptr<SessionConnection> session_connection);
 
   ~PlatformView();
 
@@ -218,7 +218,7 @@ class PlatformView final : public flutter::PlatformView,
   std::set<std::string /* channel */> unregistered_channels_;
 
   fml::TimeDelta vsync_offset_;
-  zx_handle_t vsync_event_handle_ = 0;
+  std::shared_ptr<SessionConnection> session_connection_;
 
   // The registered binding for serving the keyboard listener server endpoint.
   fidl::Binding<fuchsia::ui::input3::KeyboardListener>

shell/platform/fuchsia/flutter/platform_view_unittest.cc

@@ -264,7 +264,7 @@ class PlatformViewBuilder {
                         std::move(on_update_view_callback_),
                         std::move(on_destroy_view_callback_),
                         std::move(on_create_surface_callback_), view_embedder_,
-                        std::move(vsync_offset_), vsync_event_handle_);
+                        std::move(vsync_offset_), nullptr);
   }
 
  private:
@@ -295,7 +295,6 @@ class PlatformViewBuilder {
   OnCreateSurface on_create_surface_callback_{nullptr};
   std::shared_ptr<flutter::ExternalViewEmbedder> view_embedder_{nullptr};
   fml::TimeDelta vsync_offset_{fml::TimeDelta::Zero()};
-  zx_handle_t vsync_event_handle_{ZX_HANDLE_INVALID};
 };
 
 }  // namespace