Fuchsia: Limit number of concurrent presents in ScenicWindow

src/tests/egl_tests/EGLSurfaceTest.cpp

@@ -528,6 +528,27 @@ TEST_P(EGLSurfaceTest, ResizeWindowWithDraw)
     EXPECT_PIXEL_COLOR_EQ(size, size, GLColor::transparentBlack);
 }
 
+// Test that the window can be reset repeatedly before surface creation.
+TEST_P(EGLSurfaceTest, ResetNativeWindow)
+{
+    mOSWindow->setVisible(true);
+
+    initializeDisplay();
+
+    for (int i = 0; i < 10; ++i)
+    {
+        mOSWindow->resetNativeWindow();
+    }
+
+    initializeSurfaceWithDefaultConfig();
+    initializeContext();
+
+    eglMakeCurrent(mDisplay, mWindowSurface, mWindowSurface, mContext);
+
+    eglSwapBuffers(mDisplay, mWindowSurface);
+    ASSERT_EGL_SUCCESS();
+}
+
 // Test that swap interval works.
 TEST_P(EGLSurfaceTest, SwapInterval)
 {

util/fuchsia/ScenicWindow.cpp

@@ -27,7 +27,7 @@ namespace
 
 async::Loop *GetDefaultLoop()
 {
-    static async::Loop *defaultLoop = new async::Loop(&kAsyncLoopConfigAttachToCurrentThread);
+    static async::Loop *defaultLoop = new async::Loop(&kAsyncLoopConfigNeverAttachToThread);
     return defaultLoop;
 }
 
@@ -50,10 +50,11 @@ zx_status_t ConnectToService(zx_handle_t serviceRoot, fidl::InterfaceRequest<Int
 }
 
 template <typename Interface>
-fidl::InterfacePtr<Interface> ConnectToService(zx_handle_t serviceRoot)
+fidl::InterfacePtr<Interface> ConnectToService(zx_handle_t serviceRoot,
+                                               async_dispatcher_t *dispatcher)
 {
     fidl::InterfacePtr<Interface> result;
-    ConnectToService(serviceRoot, result.NewRequest());
+    ConnectToService(serviceRoot, result.NewRequest(dispatcher));
     return result;
 }
 
@@ -62,12 +63,18 @@ fidl::InterfacePtr<Interface> ConnectToService(zx_handle_t serviceRoot)
 ScenicWindow::ScenicWindow()
     : mLoop(GetDefaultLoop()),
       mServiceRoot(ConnectToServiceRoot()),
-      mScenic(ConnectToService<fuchsia::ui::scenic::Scenic>(mServiceRoot.get())),
-      mPresenter(ConnectToService<fuchsia::ui::policy::Presenter>(mServiceRoot.get())),
-      mScenicSession(mScenic.get()),
+      mScenic(
+          ConnectToService<fuchsia::ui::scenic::Scenic>(mServiceRoot.get(), mLoop->dispatcher())),
+      mPresenter(ConnectToService<fuchsia::ui::policy::Presenter>(mServiceRoot.get(),
+                                                                  mLoop->dispatcher())),
+      mScenicSession(mScenic.get(), mLoop->dispatcher()),
       mShape(&mScenicSession),
       mMaterial(&mScenicSession)
-{}
+{
+    mScenicSession.set_error_handler(fit::bind_member(this, &ScenicWindow::onScenicError));
+    mScenicSession.set_on_frame_presented_handler(
+        fit::bind_member(this, &ScenicWindow::onFramePresented));
+}
 
 ScenicWindow::~ScenicWindow()
 {
@@ -87,8 +94,6 @@ bool ScenicWindow::initialize(const std::string &name, int width, int height)
     // Create view.
     mView = std::make_unique<scenic::View>(&mScenicSession, std::move(viewToken), name);
     mView->AddChild(mShape);
-    mScenicSession.Present2(0, 0,
-                            [](fuchsia::scenic::scheduling::FuturePresentationTimes info) {});
 
     // Present view.
     mPresenter->PresentView(std::move(viewHolderToken), nullptr);
@@ -103,6 +108,14 @@ bool ScenicWindow::initialize(const std::string &name, int width, int height)
 
 void ScenicWindow::destroy()
 {
+    while (mInFlightPresents != 0 && !mLostSession)
+    {
+        mLoop->ResetQuit();
+        mLoop->Run();
+    }
+
+    ASSERT(mInFlightPresents == 0 || mLostSession);
+
     mFuchsiaEGLWindow.reset();
 }
 
@@ -110,13 +123,13 @@ void ScenicWindow::resetNativeWindow()
 {
     fuchsia::images::ImagePipe2Ptr imagePipe;
     uint32_t imagePipeId = mScenicSession.AllocResourceId();
-    mScenicSession.Enqueue(scenic::NewCreateImagePipe2Cmd(imagePipeId, imagePipe.NewRequest()));
+    mScenicSession.Enqueue(
+        scenic::NewCreateImagePipe2Cmd(imagePipeId, imagePipe.NewRequest(mLoop->dispatcher())));
     zx_handle_t imagePipeHandle = imagePipe.Unbind().TakeChannel().release();
 
     mMaterial.SetTexture(imagePipeId);
     mScenicSession.ReleaseResource(imagePipeId);
-    mScenicSession.Present2(0, 0,
-                            [](fuchsia::scenic::scheduling::FuturePresentationTimes info) {});
+    present();
 
     mFuchsiaEGLWindow.reset(fuchsia_egl_window_create(imagePipeHandle, mWidth, mHeight));
 }
@@ -133,7 +146,8 @@ EGLNativeDisplayType ScenicWindow::getNativeDisplay() const
 
 void ScenicWindow::messageLoop()
 {
-    mLoop->Run(zx::deadline_after({}), true /* once */);
+    mLoop->ResetQuit();
+    mLoop->RunUntilIdle();
 }
 
 void ScenicWindow::setMousePosition(int x, int y)
@@ -161,14 +175,42 @@ void ScenicWindow::setVisible(bool isVisible) {}
 
 void ScenicWindow::signalTestEvent() {}
 
-void ScenicWindow::OnScenicEvents(std::vector<fuchsia::ui::scenic::Event> events)
+void ScenicWindow::present()
+{
+    while (mInFlightPresents >= kMaxInFlightPresents && !mLostSession)
+    {
+        mLoop->ResetQuit();
+        mLoop->Run();
+    }
+
+    if (mLostSession)
+    {
+        return;
+    }
+
+    ASSERT(mInFlightPresents < kMaxInFlightPresents);
+
+    ++mInFlightPresents;
+    mScenicSession.Present2(0, 0, [](fuchsia::scenic::scheduling::FuturePresentationTimes info) {});
+}
+
+void ScenicWindow::onFramePresented(fuchsia::scenic::scheduling::FramePresentedInfo info)
+{
+    mInFlightPresents -= info.presentation_infos.size();
+    ASSERT(mInFlightPresents >= 0);
+    mLoop->Quit();
+}
+
+void ScenicWindow::onScenicEvents(std::vector<fuchsia::ui::scenic::Event> events)
 {
     UNIMPLEMENTED();
 }
 
-void ScenicWindow::OnScenicError(zx_status_t status)
+void ScenicWindow::onScenicError(zx_status_t status)
 {
     WARN() << "OnScenicError: " << zx_status_get_string(status);
+    mLostSession = true;
+    mLoop->Quit();
 }
 
 // static

util/fuchsia/ScenicWindow.h

@@ -53,13 +53,20 @@ class ANGLE_UTIL_EXPORT ScenicWindow : public OSWindow
     void setVisible(bool isVisible) override;
     void signalTestEvent() override;
 
+    // Presents the window to Scenic.
+    //
+    // We need to do this once per EGL window surface after adding the
+    // surface's image pipe as a child of our window.
+    void present();
+
     // FIDL callbacks:
-    void OnScenicEvents(std::vector<fuchsia::ui::scenic::Event> events);
-    void OnScenicError(zx_status_t status);
+    void onScenicEvents(std::vector<fuchsia::ui::scenic::Event> events);
+    void onScenicError(zx_status_t status);
+    void onFramePresented(fuchsia::scenic::scheduling::FramePresentedInfo info);
 
   private:
-    // Default message loop.
-    async::Loop *mLoop;
+    // ScenicWindow async loop.
+    async::Loop *const mLoop;
 
     // System services.
     zx::channel mServiceRoot;
@@ -71,6 +78,13 @@ class ANGLE_UTIL_EXPORT ScenicWindow : public OSWindow
     scenic::ShapeNode mShape;
     scenic::Material mMaterial;
 
+    // Whether our scenic session has disconnected.
+    bool mLostSession = false;
+
+    // Present limiting.
+    static constexpr int kMaxInFlightPresents = 2;
+    int mInFlightPresents                     = 0;
+
     // Scenic view.
     std::unique_ptr<scenic::View> mView;