kc3-lang/angle/src/libANGLE/Surface_unittest.cpp

• Show log

  Commit

• Hash : 5fd368aa
  Author :
  Date : 2025-07-30T14:45:55
  

  Replace Surface::getWidth/Height() with getSize()
  
  Most places in the code use both `getWidth/Height()` methods at the same
  time. On some back-ends it is more optimal to have single method.
  For example, `WindowSurfaceWGL` first uses `GetClientRect()` Win32 API
  inside each method to then calculate width and hight in each method,
  causing repeated `GetClientRect()` call.
  
  The only place where only one of the methods may be used is from
  `SurfaceImpl::getUserSize()` when one of the parameters is `nullptr`,
  which is only possible from `QuerySurfaceAttrib()` function. This
  method is rewritten to use new `getSize()` method and then use whatever
  dimensions is requested by the caller. This may cause
  `QuerySurfaceAttrib()` inefficiency on some back-ends that get width and
  height of the surface differently (`SurfaceEGL` for example). In such
  cases `getUserSize()` is overridden to avoid returning a dimension
  which is not required.
  
  After this change all places in the code that previously used both
  `getWidth/Height()` methods (like `Surface::getAttachmentSize()`) will
  be more efficient. The `QuerySurfaceAttrib()`, on the other hand, will
  have slightly more overhead on back-ends where base
  `SurfaceImpl::getUserSize()` method is used, which only happens on
  back-ends with trivial `getSize()` implementation.
  
  Bug: angleproject:397848903
  Change-Id: I4a22701a1e62ee4e7d07e77cac5b388050d98e4d
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6802440
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  Commit-Queue: Igor Nazarov <i.nazarov@samsung.com>
  

Download

• src/libANGLE/Surface_unittest.cpp

• //
  // Copyright 2014 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  
  #include "gmock/gmock.h"
  #include "gtest/gtest.h"
  
  #include "libANGLE/AttributeMap.h"
  #include "libANGLE/Config.h"
  #include "libANGLE/State.h"
  #include "libANGLE/Surface.h"
  #include "libANGLE/angletypes.h"
  #include "libANGLE/renderer/FramebufferImpl_mock.h"
  #include "libANGLE/renderer/SurfaceImpl.h"
  #include "tests/angle_unittests_utils.h"
  
  using namespace rx;
  using namespace testing;
  
  namespace
  {
  
  class MockSurfaceImpl : public rx::SurfaceImpl
  {
    public:
      MockSurfaceImpl() : SurfaceImpl(mockState), mockState({1}, nullptr, egl::AttributeMap()) {}
      virtual ~MockSurfaceImpl() { destructor(); }
  
      MOCK_METHOD1(destroy, void(const egl::Display *));
      MOCK_METHOD1(initialize, egl::Error(const egl::Display *));
      MOCK_METHOD2(swap, egl::Error(const gl::Context *, SurfaceSwapFeedback *));
      MOCK_METHOD4(swapWithDamage,
                   egl::Error(const gl::Context *, const EGLint *, EGLint, SurfaceSwapFeedback *));
      MOCK_METHOD5(postSubBuffer, egl::Error(const gl::Context *, EGLint, EGLint, EGLint, EGLint));
      MOCK_METHOD2(querySurfacePointerANGLE, egl::Error(EGLint, void **));
      MOCK_METHOD3(bindTexImage, egl::Error(const gl::Context *context, gl::Texture *, EGLint));
      MOCK_METHOD2(releaseTexImage, egl::Error(const gl::Context *context, EGLint));
      MOCK_METHOD3(getSyncValues, egl::Error(EGLuint64KHR *, EGLuint64KHR *, EGLuint64KHR *));
      MOCK_METHOD2(getMscRate, egl::Error(EGLint *, EGLint *));
      MOCK_METHOD2(setSwapInterval, void(const egl::Display *, EGLint));
      MOCK_CONST_METHOD0(getSize, gl::Extents());
      MOCK_CONST_METHOD0(isPostSubBufferSupported, EGLint(void));
      MOCK_CONST_METHOD0(getSwapBehavior, EGLint(void));
      MOCK_METHOD5(getAttachmentRenderTarget,
                   angle::Result(const gl::Context *,
                                 GLenum,
                                 const gl::ImageIndex &,
                                 GLsizei,
                                 rx::FramebufferAttachmentRenderTarget **));
      MOCK_METHOD2(attachToFramebuffer, egl::Error(const gl::Context *, gl::Framebuffer *));
      MOCK_METHOD2(detachFromFramebuffer, egl::Error(const gl::Context *, gl::Framebuffer *));
      MOCK_METHOD0(destructor, void());
  
      egl::SurfaceState mockState;
  };
  
  TEST(SurfaceTest, DestructionDeletesImpl)
  {
      NiceMock<MockEGLFactory> factory;
  
      MockSurfaceImpl *impl = new MockSurfaceImpl;
      EXPECT_CALL(factory, createWindowSurface(_, _, _)).WillOnce(Return(impl));
  
      egl::Config config;
      egl::Surface *surface = new egl::WindowSurface(
          &factory, {1}, &config, static_cast<EGLNativeWindowType>(0), egl::AttributeMap(), false);
  
      EXPECT_CALL(*impl, destroy(_)).Times(1).RetiresOnSaturation();
      EXPECT_CALL(*impl, destructor()).Times(1).RetiresOnSaturation();
  
      EXPECT_FALSE(surface->onDestroy(nullptr).isError());
  
      // Only needed because the mock is leaked if bugs are present,
      // which logs an error, but does not cause the test to fail.
      // Ordinarily mocks are verified when destroyed.
      Mock::VerifyAndClear(impl);
  }
  
  }  // namespace
  

Download