Vulkan: Ensure always using resolved Window Surface size

`WindowSurfaceVk::getWidth/Height()` methods return cached, previously
resolved Surface size. Using these methods while current Window Surface
size is unresolved may return stale values, causing undesired behavior.
Appropriate ASSERTs were added to these methods to prevent such usage.

Added ASSERTs revealed few places with incorrect usage:
- In `Context::makeCurrent()` to set initial viewport or for capture.
- In `IsPartialBlit()` and `ValidateReadPixelsBase()` validations.
- In `SerializeFramebufferAttachment()` during capture.

Rest of the code was thoroughly checked if it is possible to call
`WindowSurfaceVk::getWidth/Height()` when size is unresolved. All other
places always call these methods after framebuffer state
synchronization, which acquires swapchain images and resolves the
surface size.

Added `ensureSizeResolved()` method that is called during validation and
in the `SerializeFramebufferAttachment()` method. It is possible to use
existing `Framebuffer::syncState()` method as alternative, but this
solution was discarded since it may potentially interfere with
`State::syncDirtyObjects()` method.

The `Surface::getUserSize()` replaces old methods as optimization, to
prevent calling relatively expensive method twice from
`Context::makeCurrent()` to get width and height of the `drawSurface`.

Test: angle_trace_tests --gtest_filter=EGLSurfaceTest.ResizeBeforeMakeCurrent/*
Test: angle_trace_tests --gtest_filter=EGLSurfaceTest.ResizeBeforeMakeCurrentPostSizeQuery/*
Test: angle_trace_tests --gtest_filter=EGLSurfaceTest.ResizeAndReadPixelsRobustANGLE/*
Test: angle_trace_tests --gtest_filter=EGLSurfaceTest.ResizeAndBlitFramebufferANGLE/*
Bug: angleproject:397848903
Change-Id: I082e13d0b8db5fd7d08ff25b102df1f283e1256d
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6792928
Commit-Queue: Igor Nazarov <[email protected]>
Reviewed-by: Cody Northrop <[email protected]>
Reviewed-by: Shahbaz Youssefi <[email protected]>

Author: i-nazarov-ukraine

src/libANGLE/Context.cpp

@@ -1047,6 +1047,15 @@ egl::Error Context::makeCurrent(egl::Display *display,
 {
     mDisplay = display;
 
+    EGLint width  = 0;
+    EGLint height = 0;
+
+    angle::FrameCaptureShared *frameCaptureShared = getShareGroup()->getFrameCaptureShared();
+    if ((frameCaptureShared->enabled() || !mHasBeenCurrent) && drawSurface != nullptr)
+    {
+        ANGLE_TRY(drawSurface->getUserSize(display, &width, &height));
+    }
+
     if (!mHasBeenCurrent)
     {
         initializeDefaultResources();
@@ -1055,14 +1064,6 @@ egl::Error Context::makeCurrent(egl::Display *display,
         initVersionStrings();
         initExtensionStrings();
 
-        int width  = 0;
-        int height = 0;
-        if (drawSurface != nullptr)
-        {
-            width  = drawSurface->getWidth();
-            height = drawSurface->getHeight();
-        }
-
         ContextPrivateViewport(getMutablePrivateState(), getMutablePrivateStateCache(), 0, 0, width,
                                height);
         ContextPrivateScissor(getMutablePrivateState(), getMutablePrivateStateCache(), 0, 0, width,
@@ -1073,7 +1074,7 @@ egl::Error Context::makeCurrent(egl::Display *display,
 
     ANGLE_TRY(unsetDefaultFramebuffer());
 
-    getShareGroup()->getFrameCaptureShared()->onMakeCurrent(this, drawSurface);
+    frameCaptureShared->onMakeCurrent(this, drawSurface, width, height);
 
     // TODO(jmadill): Rework this when we support ContextImpl
     mState.setAllDirtyBits();

src/libANGLE/FramebufferAttachment.h

@@ -120,6 +120,8 @@ class FramebufferAttachment final
     bool isRenderToTexture() const;
     GLsizei getRenderToTextureSamples() const;
 
+    // Explicitly resolves attachment size to use before state synchronization (e.g. validation).
+    angle::Result ensureSizeResolved(const Context *context) const;
     // The size of the underlying resource the attachment points to. The 'depth' value will
     // correspond to a 3D texture depth or the layer count of a 2D array texture. For Surfaces and
     // Renderbuffers, it will always be 1.
@@ -224,6 +226,7 @@ class FramebufferAttachmentObject : public angle::Subject, public angle::Observe
     FramebufferAttachmentObject();
     ~FramebufferAttachmentObject() override;
 
+    virtual angle::Result ensureSizeResolved(const Context *context) const                 = 0;
     virtual bool isAttachmentSpecified(const ImageIndex &imageIndex) const                 = 0;
     virtual Extents getAttachmentSize(const ImageIndex &imageIndex) const                  = 0;
     virtual Format getAttachmentFormat(GLenum binding, const ImageIndex &imageIndex) const = 0;
@@ -268,6 +271,12 @@ inline const ImageIndex &FramebufferAttachment::getTextureImageIndex() const
     return mTarget.textureIndex();
 }
 
+inline angle::Result FramebufferAttachment::ensureSizeResolved(const Context *context) const
+{
+    ASSERT(mResource);
+    return mResource->ensureSizeResolved(context);
+}
+
 inline bool FramebufferAttachment::isSpecified() const
 {
     ASSERT(mResource);

src/libANGLE/Image.cpp

@@ -129,6 +129,11 @@ void ImageSibling::setSourceEGLImageInitState(gl::InitState initState) const
     mTargetOf->setInitState(initState);
 }
 
+angle::Result ImageSibling::ensureSizeResolved(const gl::Context *context) const
+{
+    return angle::Result::Continue;
+}
+
 bool ImageSibling::isAttachmentSpecified(const gl::ImageIndex &imageIndex) const
 {
     return !getAttachmentSize(imageIndex).empty();

src/libANGLE/Image.h

@@ -49,6 +49,7 @@ class ImageSibling : public gl::FramebufferAttachmentObject
     gl::InitState sourceEGLImageInitState() const;
     void setSourceEGLImageInitState(gl::InitState initState) const;
 
+    angle::Result ensureSizeResolved(const gl::Context *context) const override;
     bool isAttachmentSpecified(const gl::ImageIndex &imageIndex) const override;
     bool isRenderable(const gl::Context *context,
                       GLenum binding,

src/libANGLE/Surface.cpp

@@ -543,29 +543,24 @@ EGLint Surface::getHeight() const
     return mFixedSize ? static_cast<EGLint>(mFixedHeight) : mImplementation->getHeight();
 }
 
-egl::Error Surface::getUserWidth(const egl::Display *display, EGLint *value) const
+egl::Error Surface::getUserSize(const egl::Display *display, EGLint *width, EGLint *height) const
 {
+    ASSERT(width != nullptr || height != nullptr);
     if (mFixedSize)
     {
-        *value = static_cast<EGLint>(mFixedWidth);
-        return NoError();
-    }
-    else
-    {
-        return mImplementation->getUserWidth(display, value);
-    }
-}
-
-egl::Error Surface::getUserHeight(const egl::Display *display, EGLint *value) const
-{
-    if (mFixedSize)
-    {
-        *value = static_cast<EGLint>(mFixedHeight);
+        if (width != nullptr)
+        {
+            *width = static_cast<EGLint>(mFixedWidth);
+        }
+        if (height != nullptr)
+        {
+            *height = static_cast<EGLint>(mFixedHeight);
+        }
         return NoError();
     }
     else
     {
-        return mImplementation->getUserHeight(display, value);
+        return mImplementation->getUserSize(display, width, height);
     }
 }
 
@@ -617,6 +612,11 @@ Error Surface::releaseTexImageFromTexture(const gl::Context *context)
     return releaseRef(context->getDisplay());
 }
 
+angle::Result Surface::ensureSizeResolved(const gl::Context *context) const
+{
+    return mImplementation->ensureSizeResolved(context);
+}
+
 bool Surface::isAttachmentSpecified(const gl::ImageIndex & /*imageIndex*/) const
 {
     // Surface is always specified even if it has 0 sizes.

src/libANGLE/Surface.h

@@ -113,11 +113,11 @@ class Surface : public LabeledObject, public gl::FramebufferAttachmentObject
     const Config *getConfig() const;
 
     // width and height can change with client window resizing
+    // Size must be resolved before the call either during state synchronization or explicitly.
     EGLint getWidth() const;
     EGLint getHeight() const;
-    // Sizes that Surface will have after render target is first accessed (e.g. after draw).
-    egl::Error getUserWidth(const egl::Display *display, EGLint *value) const;
-    egl::Error getUserHeight(const egl::Display *display, EGLint *value) const;
+    // Unresolved Surface size until render target is first accessed (e.g. after draw).
+    egl::Error getUserSize(const egl::Display *display, EGLint *width, EGLint *height) const;
     EGLint getPixelAspectRatio() const;
     EGLenum getRenderBuffer() const;
     EGLenum getRequestedRenderBuffer() const;
@@ -161,6 +161,8 @@ class Surface : public LabeledObject, public gl::FramebufferAttachmentObject
     EGLint isFixedSize() const;
 
     // FramebufferAttachmentObject implementation
+    // Explicitly resolves surface size to use before state synchronization (e.g. validation).
+    angle::Result ensureSizeResolved(const gl::Context *context) const override;
     bool isAttachmentSpecified(const gl::ImageIndex &imageIndex) const override;
     gl::Extents getAttachmentSize(const gl::ImageIndex &imageIndex) const override;
     gl::Format getAttachmentFormat(GLenum binding, const gl::ImageIndex &imageIndex) const override;

src/libANGLE/capture/FrameCapture.cpp

@@ -8405,7 +8405,10 @@ void FrameCaptureShared::onDestroyContext(const gl::Context *context)
     }
 }
 
-void FrameCaptureShared::onMakeCurrent(const gl::Context *context, const egl::Surface *drawSurface)
+void FrameCaptureShared::onMakeCurrent(const gl::Context *context,
+                                       const egl::Surface *drawSurface,
+                                       EGLint surfaceWidth,
+                                       EGLint surfaceHeight)
 {
     if (!drawSurface)
     {
@@ -8414,7 +8417,7 @@ void FrameCaptureShared::onMakeCurrent(const gl::Context *context, const egl::Su
 
     // Track the width, height and color space of the draw surface as provided to makeCurrent
     SurfaceParams &params = mDrawSurfaceParams[context->id()];
-    params.extents        = gl::Extents(drawSurface->getWidth(), drawSurface->getHeight(), 1);
+    params.extents        = gl::Extents(surfaceWidth, surfaceHeight, 1);
     params.colorSpace     = egl::FromEGLenum<egl::ColorSpace>(drawSurface->getGLColorspace());
 }
 

src/libANGLE/capture/FrameCapture.h

@@ -749,7 +749,10 @@ class FrameCaptureShared final : angle::NonCopyable
     void onEndFrame(gl::Context *context);
     void onDestroyContext(const gl::Context *context);
     bool onEndCLCapture();
-    void onMakeCurrent(const gl::Context *context, const egl::Surface *drawSurface);
+    void onMakeCurrent(const gl::Context *context,
+                       const egl::Surface *drawSurface,
+                       EGLint surfaceWidth,
+                       EGLint surfaceHeight);
     bool enabled() const { return mEnabled; }
 
     bool isCapturing() const;

src/libANGLE/capture/FrameCapture_mock.cpp

@@ -43,7 +43,10 @@ FrameCapture::~FrameCapture() {}
 FrameCaptureShared::FrameCaptureShared() : mEnabled(false) {}
 FrameCaptureShared::~FrameCaptureShared() {}
 void FrameCaptureShared::onEndFrame(gl::Context *context) {}
-void FrameCaptureShared::onMakeCurrent(const gl::Context *context, const egl::Surface *drawSurface)
+void FrameCaptureShared::onMakeCurrent(const gl::Context *context,
+                                       const egl::Surface *drawSurface,
+                                       EGLint surfaceWidth,
+                                       EGLint surfaceHeight)
 {}
 void FrameCaptureShared::onDestroyContext(const gl::Context *context) {}
 void *FrameCaptureShared::maybeGetShadowMemoryPointer(gl::Buffer *buffer,

src/libANGLE/capture/serialize.cpp

@@ -291,6 +291,9 @@ Result SerializeFramebufferAttachment(const gl::Context *context,
     json->addScalar("ViewIndex", framebufferAttachment.getBaseViewIndex());
     json->addScalar("Samples", framebufferAttachment.getRenderToTextureSamples());
 
+    // Need to resolve the size before getting it below.
+    ANGLE_TRY(framebufferAttachment.ensureSizeResolved(context));
+
     {
         GroupScope extentsGroup(json, "Extents");
         SerializeExtents(json, framebufferAttachment.getSize());