[fuchsia] Restructure Flatland vsync loop (cherry picked from commit 77ea7c2d91cfbd371522e379b6c0022d2baf0955)
diff --git a/shell/platform/fuchsia/flutter/engine.cc b/shell/platform/fuchsia/flutter/engine.cc index b0612ac..3543c84 100644 --- a/shell/platform/fuchsia/flutter/engine.cc +++ b/shell/platform/fuchsia/flutter/engine.cc
@@ -354,8 +354,6 @@ view_protocols = std::move(view_protocols), request = parent_viewport_watcher.NewRequest(), view_ref_pair = std::move(view_ref_pair), - max_frames_in_flight = product_config.get_max_frames_in_flight(), - vsync_offset = product_config.get_vsync_offset(), software_rendering = product_config.software_rendering()]() mutable { if (software_rendering) { surface_producer_ = std::make_shared<SoftwareSurfaceProducer>(); @@ -365,8 +363,7 @@ flatland_connection_ = std::make_shared<FlatlandConnection>( thread_label_, std::move(flatland), - std::move(session_error_callback), [](auto) {}, - max_frames_in_flight, vsync_offset); + std::move(session_error_callback), [](auto) {}); fuchsia::ui::views::ViewIdentityOnCreation view_identity = { .view_ref = std::move(view_ref_pair.second),
diff --git a/shell/platform/fuchsia/flutter/flatland_connection.cc b/shell/platform/fuchsia/flutter/flatland_connection.cc index 5b3a029..cfc7ea0 100644 --- a/shell/platform/fuchsia/flutter/flatland_connection.cc +++ b/shell/platform/fuchsia/flutter/flatland_connection.cc
@@ -13,11 +13,10 @@ namespace { -fml::TimePoint GetNextPresentationTime(fml::TimePoint now, - fml::TimePoint next_presentation_time) { - return now > next_presentation_time - ? now + flutter_runner::kDefaultFlatlandPresentationInterval - : next_presentation_time; +// Helper function for traces. +double DeltaFromNowInNanoseconds(const fml::TimePoint& now, + const fml::TimePoint& time) { + return (time - now).ToNanoseconds(); } } // namespace @@ -26,9 +25,7 @@ std::string debug_label, fuchsia::ui::composition::FlatlandHandle flatland, fml::closure error_callback, - on_frame_presented_event on_frame_presented_callback, - uint64_t max_frames_in_flight, - fml::TimeDelta vsync_offset) + on_frame_presented_event on_frame_presented_callback) : flatland_(flatland.Bind()), error_callback_(error_callback), on_frame_presented_callback_(std::move(on_frame_presented_callback)) { @@ -49,11 +46,9 @@ // This method is called from the raster thread. void FlatlandConnection::Present() { - if (!threadsafe_state_.first_present_called_) { - std::scoped_lock<std::mutex> lock(threadsafe_state_.mutex_); - threadsafe_state_.first_present_called_ = true; - } - if (present_credits_ > 0) { + TRACE_DURATION("flutter", "FlatlandConnection::Present"); + std::scoped_lock<std::mutex> lock(threadsafe_state_.mutex_); + if (threadsafe_state_.present_credits_ > 0) { DoPresent(); } else { present_waiting_for_credit_ = true; @@ -66,14 +61,15 @@ TRACE_FLOW_BEGIN("gfx", "Flatland::Present", next_present_trace_id_); ++next_present_trace_id_; - FML_CHECK(present_credits_ > 0); - --present_credits_; + FML_CHECK(threadsafe_state_.present_credits_ > 0); + --threadsafe_state_.present_credits_; fuchsia::ui::composition::PresentArgs present_args; present_args.set_requested_presentation_time(0); present_args.set_acquire_fences(std::move(acquire_fences_)); present_args.set_release_fences(std::move(previous_present_release_fences_)); - present_args.set_unsquashable(false); + // Frame rate over latency. + present_args.set_unsquashable(true); flatland_->Present(std::move(present_args)); // In Flatland, release fences apply to the content of the previous present. @@ -86,38 +82,44 @@ // This method is called from the UI thread. void FlatlandConnection::AwaitVsync(FireCallbackCallback callback) { - std::scoped_lock<std::mutex> lock(threadsafe_state_.mutex_); - const fml::TimePoint now = fml::TimePoint::Now(); + TRACE_DURATION("flutter", "FlatlandConnection::AwaitVsync"); - // Immediately fire callbacks until the first Present. We might receive - // multiple requests for AwaitVsync() until the first Present, which relies on - // receiving size on PlatformView::OnGetLayout() at an uncertain time. - if (!threadsafe_state_.first_present_called_) { - callback(now, now + kDefaultFlatlandPresentationInterval); + std::scoped_lock<std::mutex> lock(threadsafe_state_.mutex_); + threadsafe_state_.pending_fire_callback_ = nullptr; + const auto now = fml::TimePoint::Now(); + + // Initial case. + if (MaybeRunInitialVsyncCallback(now, callback)) + return; + + // Throttle case. + if (threadsafe_state_.present_credits_ == 0) { + threadsafe_state_.pending_fire_callback_ = callback; return; } - threadsafe_state_.fire_callback_ = callback; - - // Immediately fire callback if OnNextFrameBegin() is already called. - if (threadsafe_state_.on_next_frame_pending_) { - threadsafe_state_.fire_callback_( - now, GetNextPresentationTime( - now, threadsafe_state_.next_presentation_time_)); - threadsafe_state_.fire_callback_ = nullptr; - threadsafe_state_.on_next_frame_pending_ = false; - } + // Regular case. + RunVsyncCallback(now, callback); } // This method is called from the UI thread. void FlatlandConnection::AwaitVsyncForSecondaryCallback( FireCallbackCallback callback) { - const fml::TimePoint now = fml::TimePoint::Now(); + TRACE_DURATION("flutter", + "FlatlandConnection::AwaitVsyncForSecondaryCallback"); + std::scoped_lock<std::mutex> lock(threadsafe_state_.mutex_); - callback(now, GetNextPresentationTime( - now, threadsafe_state_.next_presentation_time_)); + const auto now = fml::TimePoint::Now(); + + // Initial case. + if (MaybeRunInitialVsyncCallback(now, callback)) + return; + + // Regular case. + RunVsyncCallback(now, callback); } +// This method is called from the raster thread. void FlatlandConnection::OnError( fuchsia::ui::composition::FlatlandError error) { FML_LOG(ERROR) << "Flatland error: " << static_cast<int>(error); @@ -127,30 +129,62 @@ // This method is called from the raster thread. void FlatlandConnection::OnNextFrameBegin( fuchsia::ui::composition::OnNextFrameBeginValues values) { - present_credits_ += values.additional_present_credits(); + // Collect now before locking because this is an important timing information + // from Scenic. + const auto now = fml::TimePoint::Now(); - if (present_waiting_for_credit_ && present_credits_ > 0) { + std::scoped_lock<std::mutex> lock(threadsafe_state_.mutex_); + threadsafe_state_.first_feedback_received_ = true; + threadsafe_state_.present_credits_ += values.additional_present_credits(); + TRACE_DURATION("flutter", "FlatlandConnection::OnNextFrameBegin", + "present_credits", threadsafe_state_.present_credits_); + + if (present_waiting_for_credit_ && threadsafe_state_.present_credits_ > 0) { DoPresent(); present_waiting_for_credit_ = false; } - if (present_credits_ > 0) { - FML_CHECK(values.has_future_presentation_infos() && - !values.future_presentation_infos().empty()); - const auto next_presentation_time = - fml::TimePoint::FromEpochDelta(fml::TimeDelta::FromNanoseconds( - values.future_presentation_infos().front().presentation_time())); + // Update vsync_interval_ by calculating the difference between the first two + // presentation times. Flatland always returns >1 presentation_infos, so this + // check is to guard against any changes to this assumption. + if (values.has_future_presentation_infos() && + values.future_presentation_infos().size() > 1) { + threadsafe_state_.vsync_interval_ = fml::TimeDelta::FromNanoseconds( + values.future_presentation_infos().at(1).presentation_time() - + values.future_presentation_infos().at(0).presentation_time()); + } else { + FML_LOG(WARNING) + << "Flatland didn't send enough future_presentation_infos to update " + "vsync interval."; + } - std::scoped_lock<std::mutex> lock(threadsafe_state_.mutex_); - if (threadsafe_state_.fire_callback_) { - threadsafe_state_.fire_callback_( - /*frame_start=*/fml::TimePoint::Now(), - /*frame_target=*/next_presentation_time); - threadsafe_state_.fire_callback_ = nullptr; - } else { - threadsafe_state_.on_next_frame_pending_ = true; - } - threadsafe_state_.next_presentation_time_ = next_presentation_time; + // Update next_presentation_times_. + std::queue<fml::TimePoint> new_times; + for (const auto& info : values.future_presentation_infos()) { + new_times.emplace(fml::TimePoint::FromEpochDelta( + fml::TimeDelta::FromNanoseconds(info.presentation_time()))); + } + threadsafe_state_.next_presentation_times_.swap(new_times); + + // Update vsync_offset_. + // We use modulo here because Flatland may point to the following vsync if + // OnNextFrameBegin() is called after the current frame's latch point. + auto vsync_offset = + (fml::TimePoint::FromEpochDelta(fml::TimeDelta::FromNanoseconds( + values.future_presentation_infos().front().presentation_time())) - + now) % + threadsafe_state_.vsync_interval_; + // Thread contention may result in OnNextFrameBegin() being called after the + // presentation time. Ignore these outliers. + if (vsync_offset > fml::TimeDelta::Zero()) { + threadsafe_state_.vsync_offset_ = vsync_offset; + } + + // Throttle case. + if (threadsafe_state_.pending_fire_callback_ && + threadsafe_state_.present_credits_ > 0) { + RunVsyncCallback(now, threadsafe_state_.pending_fire_callback_); + threadsafe_state_.pending_fire_callback_ = nullptr; } } @@ -160,6 +194,68 @@ on_frame_presented_callback_(std::move(info)); } +// Parses and updates next_presentation_times_. +fml::TimePoint FlatlandConnection::GetNextPresentationTime( + const fml::TimePoint& now) { + const fml::TimePoint& cutoff = + now > threadsafe_state_.last_presentation_time_ + ? now + : threadsafe_state_.last_presentation_time_; + + // Remove presentation times that may have been passed. This may happen after + // a long draw call. + while (!threadsafe_state_.next_presentation_times_.empty() && + threadsafe_state_.next_presentation_times_.front() <= cutoff) { + threadsafe_state_.next_presentation_times_.pop(); + } + + // Calculate a presentation time based on + // |threadsafe_state_.last_presentation_time_| that is later than cutoff using + // |vsync_interval| increments if we don't have any future presentation times + // left. + if (threadsafe_state_.next_presentation_times_.empty()) { + auto result = threadsafe_state_.last_presentation_time_; + while (result <= cutoff) { + result = result + threadsafe_state_.vsync_interval_; + } + return result; + } + + // Return the next presentation time in the queue for the regular case. + const auto result = threadsafe_state_.next_presentation_times_.front(); + threadsafe_state_.next_presentation_times_.pop(); + return result; +} + +// This method is called from the UI thread. +bool FlatlandConnection::MaybeRunInitialVsyncCallback( + const fml::TimePoint& now, + FireCallbackCallback& callback) { + if (!threadsafe_state_.first_feedback_received_) { + TRACE_DURATION("flutter", + "FlatlandConnection::MaybeRunInitialVsyncCallback"); + const auto frame_end = now + kInitialFlatlandVsyncOffset; + threadsafe_state_.last_presentation_time_ = frame_end; + callback(now, frame_end); + return true; + } + return false; +} + +// This method may be called from the raster or UI thread, but it is safe +// because VsyncWaiter posts the vsync callback on UI thread. +void FlatlandConnection::RunVsyncCallback(const fml::TimePoint& now, + FireCallbackCallback& callback) { + const auto& frame_end = GetNextPresentationTime(now); + const auto& frame_start = frame_end - threadsafe_state_.vsync_offset_; + threadsafe_state_.last_presentation_time_ = frame_end; + TRACE_DURATION("flutter", "FlatlandConnection::RunVsyncCallback", + "frame_start_delta", + DeltaFromNowInNanoseconds(now, frame_start), "frame_end_delta", + DeltaFromNowInNanoseconds(now, frame_end)); + callback(frame_start, frame_end); +} + // This method is called from the raster thread. void FlatlandConnection::EnqueueAcquireFence(zx::event fence) { acquire_fences_.push_back(std::move(fence));
diff --git a/shell/platform/fuchsia/flutter/flatland_connection.h b/shell/platform/fuchsia/flutter/flatland_connection.h index 2d894de..6b03f06 100644 --- a/shell/platform/fuchsia/flutter/flatland_connection.h +++ b/shell/platform/fuchsia/flutter/flatland_connection.h
@@ -16,6 +16,7 @@ #include <cstdint> #include <mutex> +#include <queue> #include <string> namespace flutter_runner { @@ -23,10 +24,10 @@ using on_frame_presented_event = std::function<void(fuchsia::scenic::scheduling::FramePresentedInfo)>; -// 2ms interval to target vsync is only used until Scenic sends presentation -// feedback, or when we run out of present credits. -static constexpr fml::TimeDelta kDefaultFlatlandPresentationInterval = - fml::TimeDelta::FromMilliseconds(2); +// 10ms interval to target vsync is only used until Scenic sends presentation +// feedback. +static constexpr fml::TimeDelta kInitialFlatlandVsyncOffset = + fml::TimeDelta::FromMilliseconds(10); // The component residing on the raster thread that is responsible for // maintaining the Flatland instance connection and presenting updates. @@ -35,9 +36,7 @@ FlatlandConnection(std::string debug_label, fuchsia::ui::composition::FlatlandHandle flatland, fml::closure error_callback, - on_frame_presented_event on_frame_presented_callback, - uint64_t max_frames_in_flight, - fml::TimeDelta vsync_offset); + on_frame_presented_event on_frame_presented_callback); ~FlatlandConnection(); @@ -70,6 +69,12 @@ void OnFramePresented(fuchsia::scenic::scheduling::FramePresentedInfo info); void DoPresent(); + fml::TimePoint GetNextPresentationTime(const fml::TimePoint& now); + bool MaybeRunInitialVsyncCallback(const fml::TimePoint& now, + FireCallbackCallback& callback); + void RunVsyncCallback(const fml::TimePoint& now, + FireCallbackCallback& callback); + fuchsia::ui::composition::FlatlandPtr flatland_; fml::closure error_callback_; @@ -78,7 +83,6 @@ uint64_t next_content_id_ = 0; on_frame_presented_event on_frame_presented_callback_; - uint32_t present_credits_ = 1; bool present_waiting_for_credit_ = false; // A flow event trace id for following |Flatland::Present| calls into Scenic. @@ -89,10 +93,13 @@ // You should always lock mutex_ before touching anything in this struct struct { std::mutex mutex_; - FireCallbackCallback fire_callback_; - bool first_present_called_ = false; - bool on_next_frame_pending_ = false; - fml::TimePoint next_presentation_time_; + std::queue<fml::TimePoint> next_presentation_times_; + fml::TimeDelta vsync_interval_ = kInitialFlatlandVsyncOffset; + fml::TimeDelta vsync_offset_ = kInitialFlatlandVsyncOffset; + fml::TimePoint last_presentation_time_; + FireCallbackCallback pending_fire_callback_; + uint32_t present_credits_ = 1; + bool first_feedback_received_ = false; } threadsafe_state_; std::vector<zx::event> acquire_fences_;
diff --git a/shell/platform/fuchsia/flutter/flutter_runner_product_configuration.cc b/shell/platform/fuchsia/flutter/flutter_runner_product_configuration.cc index f0137c3..6a536d5 100644 --- a/shell/platform/fuchsia/flutter/flutter_runner_product_configuration.cc +++ b/shell/platform/fuchsia/flutter/flutter_runner_product_configuration.cc
@@ -23,18 +23,6 @@ } // Parse out all values we're expecting. - if (document.HasMember("vsync_offset_in_us")) { - auto& val = document["vsync_offset_in_us"]; - if (val.IsInt()) { - vsync_offset_ = fml::TimeDelta::FromMicroseconds(val.GetInt()); - } - } - if (document.HasMember("max_frames_in_flight")) { - auto& val = document["max_frames_in_flight"]; - if (val.IsInt()) { - max_frames_in_flight_ = val.GetInt(); - } - } if (document.HasMember("intercept_all_input")) { auto& val = document["intercept_all_input"]; if (val.IsBool()) {
diff --git a/shell/platform/fuchsia/flutter/flutter_runner_product_configuration.h b/shell/platform/fuchsia/flutter/flutter_runner_product_configuration.h index 3b6fceb..7fe73bc 100644 --- a/shell/platform/fuchsia/flutter/flutter_runner_product_configuration.h +++ b/shell/platform/fuchsia/flutter/flutter_runner_product_configuration.h
@@ -7,8 +7,6 @@ #include <string> -#include "flutter/fml/time/time_delta.h" - namespace flutter_runner { class FlutterRunnerProductConfiguration { @@ -16,8 +14,6 @@ FlutterRunnerProductConfiguration() {} explicit FlutterRunnerProductConfiguration(std::string json_string); - fml::TimeDelta get_vsync_offset() { return vsync_offset_; } - uint64_t get_max_frames_in_flight() { return max_frames_in_flight_; } bool get_intercept_all_input() { return intercept_all_input_; } bool software_rendering() { return software_rendering_; } bool enable_shader_warmup() { return enable_shader_warmup_; } @@ -26,8 +22,6 @@ } private: - fml::TimeDelta vsync_offset_ = fml::TimeDelta::Zero(); - uint64_t max_frames_in_flight_ = 3; bool intercept_all_input_ = false; bool software_rendering_ = false; bool enable_shader_warmup_ = false;
diff --git a/shell/platform/fuchsia/flutter/tests/external_view_embedder_unittests.cc b/shell/platform/fuchsia/flutter/tests/external_view_embedder_unittests.cc index 69f0106..97581fa 100644 --- a/shell/platform/fuchsia/flutter/tests/external_view_embedder_unittests.cc +++ b/shell/platform/fuchsia/flutter/tests/external_view_embedder_unittests.cc
@@ -414,12 +414,9 @@ const auto test_name = ::testing::UnitTest::GetInstance()->current_test_info()->name(); - const auto max_frames_in_flight = 1; - const auto vsync_offset = fml::TimeDelta::Zero(); return std::make_shared<FlatlandConnection>( std::move(test_name), std::move(flatland), - /*error_callback=*/[] { FAIL(); }, /*ofpe_callback=*/[](auto...) {}, - max_frames_in_flight, vsync_offset); + /*error_callback=*/[] { FAIL(); }, /*ofpe_callback=*/[](auto...) {}); } // Primary loop and subloop for the FakeFlatland instance to process its
diff --git a/shell/platform/fuchsia/flutter/tests/flatland_connection_unittests.cc b/shell/platform/fuchsia/flutter/tests/flatland_connection_unittests.cc index 7aab547..f70afc9 100644 --- a/shell/platform/fuchsia/flutter/tests/flatland_connection_unittests.cc +++ b/shell/platform/fuchsia/flutter/tests/flatland_connection_unittests.cc
@@ -52,11 +52,17 @@ } std::vector<fuchsia::scenic::scheduling::PresentationInfo> -CreateFuturePresentationInfos(int presentation_time) { +CreateFuturePresentationInfos(const fml::TimePoint& presentation_time_1, + const fml::TimePoint& presentation_time_2) { fuchsia::scenic::scheduling::PresentationInfo info_1; - info_1.set_presentation_time(presentation_time); + info_1.set_presentation_time( + presentation_time_1.ToEpochDelta().ToNanoseconds()); std::vector<fuchsia::scenic::scheduling::PresentationInfo> infos; infos.push_back(std::move(info_1)); + fuchsia::scenic::scheduling::PresentationInfo info_2; + info_2.set_presentation_time( + presentation_time_2.ToEpochDelta().ToNanoseconds()); + infos.push_back(std::move(info_2)); return infos; } @@ -81,15 +87,25 @@ } // Syntactic sugar for OnNextFrameBegin - void OnNextFrameBegin(int num_present_credits, int presentation_time = 345) { + void OnNextFrameBegin(int num_present_credits, + const fml::TimePoint& presentation_time_1, + const fml::TimePoint& presentation_time_2) { fuchsia::ui::composition::OnNextFrameBeginValues on_next_frame_begin_values; on_next_frame_begin_values.set_additional_present_credits( num_present_credits); on_next_frame_begin_values.set_future_presentation_infos( - CreateFuturePresentationInfos(presentation_time)); + CreateFuturePresentationInfos(presentation_time_1, + presentation_time_2)); fake_flatland().FireOnNextFrameBeginEvent( std::move(on_next_frame_begin_values)); } + void OnNextFrameBegin(int num_present_credits) { + const auto now = fml::TimePoint::Now(); + const auto kPresentationTime1 = now + fml::TimeDelta::FromSeconds(100); + const auto kPresentationTime2 = now + fml::TimeDelta::FromSeconds(200); + OnNextFrameBegin(num_present_credits, kPresentationTime1, + kPresentationTime2); + } private: async::TestLoop loop_; @@ -106,13 +122,13 @@ const std::string debug_name = GetCurrentTestName(); flutter_runner::FlatlandConnection flatland_connection( debug_name, TakeFlatlandHandle(), []() { FAIL(); }, - [](auto...) { FAIL(); }, 1, fml::TimeDelta::Zero()); + [](auto...) { FAIL(); }); EXPECT_EQ(fake_flatland().debug_name(), ""); - // Simulate an AwaitVsync that comes immediately. + // Simulate an AwaitVsync that returns immediately. bool await_vsync_fired = false; AwaitVsyncChecked(flatland_connection, await_vsync_fired, - kDefaultFlatlandPresentationInterval); + kInitialFlatlandVsyncOffset); EXPECT_TRUE(await_vsync_fired); // Ensure the debug name is set. @@ -129,7 +145,7 @@ // completed yet. flutter_runner::FlatlandConnection flatland_connection( GetCurrentTestName(), TakeFlatlandHandle(), std::move(on_session_error), - [](auto...) { FAIL(); }, 1, fml::TimeDelta::Zero()); + [](auto...) { FAIL(); }); EXPECT_FALSE(error_fired); // Simulate a flatland disconnection, then Pump the loop. The error callback @@ -163,7 +179,7 @@ // completed yet. flutter_runner::FlatlandConnection flatland_connection( GetCurrentTestName(), TakeFlatlandHandle(), []() { FAIL(); }, - std::move(on_frame_presented), 1, fml::TimeDelta::Zero()); + std::move(on_frame_presented)); EXPECT_EQ(presents_called, 0u); EXPECT_EQ(vsyncs_handled, 0u); @@ -175,7 +191,7 @@ // Simulate an AwaitVsync that comes after the first call. bool await_vsync_fired = false; AwaitVsyncChecked(flatland_connection, await_vsync_fired, - kDefaultFlatlandPresentationInterval); + kInitialFlatlandVsyncOffset); EXPECT_TRUE(await_vsync_fired); // Call Present and Pump the loop; `Present` and its callback is called. No @@ -193,17 +209,17 @@ EXPECT_FALSE(await_vsync_fired); // Fire the `OnNextFrameBegin` event. AwaitVsync should be fired. - const int kPresentationTime = 123; - AwaitVsyncChecked(flatland_connection, await_vsync_fired, - fml::TimePoint::FromEpochDelta( - fml::TimeDelta::FromNanoseconds(kPresentationTime))); + const auto now = fml::TimePoint::Now(); + const auto kPresentationTime1 = now + fml::TimeDelta::FromSeconds(100); + const auto kPresentationTime2 = now + fml::TimeDelta::FromSeconds(200); fuchsia::ui::composition::OnNextFrameBeginValues on_next_frame_begin_values; on_next_frame_begin_values.set_additional_present_credits(3); on_next_frame_begin_values.set_future_presentation_infos( - CreateFuturePresentationInfos(kPresentationTime)); + CreateFuturePresentationInfos(kPresentationTime1, kPresentationTime2)); fake_flatland().FireOnNextFrameBeginEvent( std::move(on_next_frame_begin_values)); loop().RunUntilIdle(); + AwaitVsyncChecked(flatland_connection, await_vsync_fired, kPresentationTime1); EXPECT_TRUE(await_vsync_fired); // Fire the `OnFramePresented` event associated with the first `Present`, @@ -219,9 +235,14 @@ loop().RunUntilIdle(); EXPECT_EQ(presents_called, 2u); EXPECT_EQ(release_fence_handle, first_release_fence_handle); + + // AwaitVsync should be fired with the second present. + await_vsync_fired = false; + AwaitVsyncChecked(flatland_connection, await_vsync_fired, kPresentationTime2); + EXPECT_TRUE(await_vsync_fired); } -TEST_F(FlatlandConnectionTest, AwaitVsyncBeforePresent) { +TEST_F(FlatlandConnectionTest, AwaitVsyncsBeforeOnNextFrameBegin) { // Set up callbacks which allow sensing of how many presents were handled. size_t presents_called = 0u; fake_flatland().SetPresentHandler( @@ -231,7 +252,7 @@ // completed yet. flutter_runner::FlatlandConnection flatland_connection( GetCurrentTestName(), TakeFlatlandHandle(), []() { FAIL(); }, - [](auto...) {}, 1, fml::TimeDelta::Zero()); + [](auto...) {}); EXPECT_EQ(presents_called, 0u); // Pump the loop. Nothing is called. @@ -241,28 +262,20 @@ // Simulate an AwaitVsync that comes before the first Present. bool await_vsync_callback_fired = false; AwaitVsyncChecked(flatland_connection, await_vsync_callback_fired, - kDefaultFlatlandPresentationInterval); + kInitialFlatlandVsyncOffset); EXPECT_TRUE(await_vsync_callback_fired); - // Another AwaitVsync that comes before the first Present. - await_vsync_callback_fired = false; - AwaitVsyncChecked(flatland_connection, await_vsync_callback_fired, - kDefaultFlatlandPresentationInterval); - EXPECT_TRUE(await_vsync_callback_fired); - - // Queue Present. - flatland_connection.Present(); - loop().RunUntilIdle(); - EXPECT_EQ(presents_called, 1u); - - // Set the callback with AwaitVsync, callback should not be fired - await_vsync_callback_fired = false; - AwaitVsyncChecked(flatland_connection, await_vsync_callback_fired, - kDefaultFlatlandPresentationInterval); - EXPECT_FALSE(await_vsync_callback_fired); + // AwaitVsync that comes before the first Present. + bool await_vsync_secondary_callback_fired = false; + flatland_connection.AwaitVsyncForSecondaryCallback( + [&await_vsync_secondary_callback_fired](fml::TimePoint frame_start, + fml::TimePoint frame_end) { + await_vsync_secondary_callback_fired = true; + }); + EXPECT_TRUE(await_vsync_secondary_callback_fired); } -TEST_F(FlatlandConnectionTest, OutOfOrderAwait) { +TEST_F(FlatlandConnectionTest, RunsOutOfFuturePresentationInfos) { // Set up callbacks which allow sensing of how many presents were handled. size_t presents_called = 0u; fake_flatland().SetPresentHandler( @@ -279,7 +292,7 @@ // completed yet. flutter_runner::FlatlandConnection flatland_connection( GetCurrentTestName(), TakeFlatlandHandle(), []() { FAIL(); }, - std::move(on_frame_presented), 1, fml::TimeDelta::Zero()); + std::move(on_frame_presented)); EXPECT_EQ(presents_called, 0u); EXPECT_EQ(vsyncs_handled, 0u); @@ -291,7 +304,7 @@ // Simulate an AwaitVsync that comes before the first Present. bool await_vsync_callback_fired = false; AwaitVsyncChecked(flatland_connection, await_vsync_callback_fired, - kDefaultFlatlandPresentationInterval); + kInitialFlatlandVsyncOffset); EXPECT_TRUE(await_vsync_callback_fired); // Queue Present. @@ -299,49 +312,30 @@ loop().RunUntilIdle(); EXPECT_EQ(presents_called, 1u); - // Set the callback with AwaitVsync, callback should not be fired - await_vsync_callback_fired = false; - const int kPresentationTime1 = 567; - AwaitVsyncChecked(flatland_connection, await_vsync_callback_fired, - fml::TimePoint::FromEpochDelta( - fml::TimeDelta::FromNanoseconds(kPresentationTime1))); - EXPECT_FALSE(await_vsync_callback_fired); - // Fire the `OnNextFrameBegin` event. AwaitVsync callback should be fired with - // the given presentation time. + // the first presentation time. await_vsync_callback_fired = false; - OnNextFrameBegin(1, kPresentationTime1); + const auto kPresentationTime1 = + fml::TimePoint::Now() + fml::TimeDelta::FromSeconds(123); + const auto kVsyncInterval = fml::TimeDelta::FromSeconds(234); + const auto kPresentationTime2 = kPresentationTime1 + kVsyncInterval; + OnNextFrameBegin(1, kPresentationTime1, kPresentationTime2); loop().RunUntilIdle(); + AwaitVsyncChecked(flatland_connection, await_vsync_callback_fired, + kPresentationTime1); EXPECT_TRUE(await_vsync_callback_fired); - // Second consecutive ONFB should not call the fire callback and should - // instead set it to be pending to fire on next AwaitVsync - await_vsync_callback_fired = false; - const int kPresentationTime2 = 678; - OnNextFrameBegin(1, kPresentationTime2); - loop().RunUntilIdle(); - EXPECT_FALSE(await_vsync_callback_fired); - - // Now an AwaitVsync should immediately fire the pending callback with the - // default presentation interval. + // Second consecutive AwaitVsync callback should be fired with + // the second presentation time. await_vsync_callback_fired = false; AwaitVsyncChecked(flatland_connection, await_vsync_callback_fired, - kDefaultFlatlandPresentationInterval); + kPresentationTime2); EXPECT_TRUE(await_vsync_callback_fired); - // With the pending callback fired, The new callback should be set for the - // next OnNextFrameBegin to call + // Another AwaitVsync callback should be fired with vsync_interval. await_vsync_callback_fired = false; - const int kPresentationTime3 = 789; AwaitVsyncChecked(flatland_connection, await_vsync_callback_fired, - fml::TimePoint::FromEpochDelta( - fml::TimeDelta::FromNanoseconds(kPresentationTime3))); - EXPECT_FALSE(await_vsync_callback_fired); - - // Now OnNextFrameBegin should fire the callback - await_vsync_callback_fired = false; - OnNextFrameBegin(1, kPresentationTime3); - loop().RunUntilIdle(); + kPresentationTime2 + kVsyncInterval); EXPECT_TRUE(await_vsync_callback_fired); } @@ -371,7 +365,7 @@ on_frame_presented_event on_frame_presented = [](auto...) {}; flutter_runner::FlatlandConnection flatland_connection( GetCurrentTestName(), TakeFlatlandHandle(), []() { FAIL(); }, - std::move(on_frame_presented), 1, fml::TimeDelta::Zero()); + std::move(on_frame_presented)); EXPECT_EQ(num_presents_called, 0u); // Pump the loop. Nothing is called.
diff --git a/shell/platform/fuchsia/flutter/tests/flutter_runner_product_configuration_unittests.cc b/shell/platform/fuchsia/flutter/tests/flutter_runner_product_configuration_unittests.cc index 2e287db..51fa2a1 100644 --- a/shell/platform/fuchsia/flutter/tests/flutter_runner_product_configuration_unittests.cc +++ b/shell/platform/fuchsia/flutter/tests/flutter_runner_product_configuration_unittests.cc
@@ -4,7 +4,6 @@ #include <gtest/gtest.h> -#include "flutter/fml/time/time_delta.h" #include "flutter/shell/platform/fuchsia/flutter/flutter_runner_product_configuration.h" using namespace flutter_runner; @@ -13,79 +12,24 @@ class FlutterRunnerProductConfigurationTest : public testing::Test {}; -TEST_F(FlutterRunnerProductConfigurationTest, ValidVsyncOffset) { - const std::string json_string = "{ \"vsync_offset_in_us\" : 9000 } "; - const fml::TimeDelta expected_offset = fml::TimeDelta::FromMicroseconds(9000); - - FlutterRunnerProductConfiguration product_config = - FlutterRunnerProductConfiguration(json_string); - EXPECT_EQ(product_config.get_vsync_offset(), expected_offset); -} - TEST_F(FlutterRunnerProductConfigurationTest, InvalidJsonString) { const std::string json_string = "{ \"invalid json string\" }}} "; - const fml::TimeDelta expected_offset = fml::TimeDelta::FromMicroseconds(0); + const uint64_t expected_intercept_all_input = false; FlutterRunnerProductConfiguration product_config = FlutterRunnerProductConfiguration(json_string); - EXPECT_EQ(product_config.get_vsync_offset(), expected_offset); + EXPECT_EQ(expected_intercept_all_input, + product_config.get_intercept_all_input()); } TEST_F(FlutterRunnerProductConfigurationTest, EmptyJsonString) { const std::string json_string = ""; - const fml::TimeDelta expected_offset = fml::TimeDelta::FromMicroseconds(0); + const uint64_t expected_intercept_all_input = false; FlutterRunnerProductConfiguration product_config = FlutterRunnerProductConfiguration(json_string); - EXPECT_EQ(product_config.get_vsync_offset(), expected_offset); -} - -TEST_F(FlutterRunnerProductConfigurationTest, EmptyVsyncOffset) { - const std::string json_string = "{ \"vsync_offset_in_us\" : } "; - const fml::TimeDelta expected_offset = fml::TimeDelta::FromMicroseconds(0); - - FlutterRunnerProductConfiguration product_config = - FlutterRunnerProductConfiguration(json_string); - EXPECT_EQ(product_config.get_vsync_offset(), expected_offset); -} - -TEST_F(FlutterRunnerProductConfigurationTest, NegativeVsyncOffset) { - const std::string json_string = "{ \"vsync_offset_in_us\" : -15410 } "; - const fml::TimeDelta expected_offset = - fml::TimeDelta::FromMicroseconds(-15410); - - FlutterRunnerProductConfiguration product_config = - FlutterRunnerProductConfiguration(json_string); - EXPECT_EQ(product_config.get_vsync_offset(), expected_offset); -} - -TEST_F(FlutterRunnerProductConfigurationTest, NonIntegerVsyncOffset) { - const std::string json_string = "{ \"vsync_offset_in_us\" : 3.14159 } "; - const fml::TimeDelta expected_offset = fml::TimeDelta::FromMicroseconds(0); - - FlutterRunnerProductConfiguration product_config = - FlutterRunnerProductConfiguration(json_string); - EXPECT_EQ(product_config.get_vsync_offset(), expected_offset); -} - -TEST_F(FlutterRunnerProductConfigurationTest, ValidMaxFramesInFlight) { - const std::string json_string = "{ \"max_frames_in_flight\" : 5 } "; - const uint64_t expected_max_frames_in_flight = 5; - - FlutterRunnerProductConfiguration product_config = - FlutterRunnerProductConfiguration(json_string); - EXPECT_EQ(product_config.get_max_frames_in_flight(), - expected_max_frames_in_flight); -} - -TEST_F(FlutterRunnerProductConfigurationTest, MissingMaxFramesInFlight) { - const std::string json_string = "{ \"max_frames_in_flight\" : } "; - const uint64_t minimum_reasonable_max_frames_in_flight = 1; - - FlutterRunnerProductConfiguration product_config = - FlutterRunnerProductConfiguration(json_string); - EXPECT_GE(product_config.get_max_frames_in_flight(), - minimum_reasonable_max_frames_in_flight); + EXPECT_EQ(expected_intercept_all_input, + product_config.get_intercept_all_input()); } TEST_F(FlutterRunnerProductConfigurationTest, ValidInterceptAllInput) {