kc3-lang/angle/src/libANGLE/renderer/gl/egl/SyncEGL.cpp

• Show log

  Commit

• Hash : 42bd78b2
  Author :
  Date : 2023-05-23T14:21:14
  

  Remove assertion in SyncEGL::onDestroy that the sync is valid
  
  When a egl::Sync objecct is created in egl::Display, it's wrapped in
  the RAII object angle::UniqueObjectPointer which calls onDestroy and
  the destructor on the sync when leaving scope due to an error. If the
  SyncEGL fails to initialize, it will still have onDestroy called. This
  patch makes sure that we don't assert in that case.
  
  Bug: chromium:1434602
  Change-Id: I501a0173328e4d9d01474d1084c64ef178896f17
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4556167
  Commit-Queue: Geoff Lang <geofflang@chromium.org>
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  

Download

• src/libANGLE/renderer/gl/egl/SyncEGL.cpp

• //
  // Copyright 2019 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.
  //
  
  // SyncEGL.cpp: Implements the rx::SyncEGL class.
  
  #include "libANGLE/renderer/gl/egl/SyncEGL.h"
  
  #include "libANGLE/AttributeMap.h"
  #include "libANGLE/Display.h"
  #include "libANGLE/renderer/gl/egl/FunctionsEGL.h"
  
  namespace rx
  {
  
  SyncEGL::SyncEGL(const egl::AttributeMap &attribs, const FunctionsEGL *egl)
      : mEGL(egl),
        mNativeFenceFD(
            attribs.getAsInt(EGL_SYNC_NATIVE_FENCE_FD_ANDROID, EGL_NO_NATIVE_FENCE_FD_ANDROID)),
        mSync(EGL_NO_SYNC_KHR)
  {}
  
  SyncEGL::~SyncEGL()
  {
      ASSERT(mSync == EGL_NO_SYNC_KHR);
  }
  
  void SyncEGL::onDestroy(const egl::Display *display)
  {
      if (mSync != EGL_NO_SYNC_KHR)
      {
          mEGL->destroySyncKHR(mSync);
          mSync = EGL_NO_SYNC_KHR;
      }
  }
  
  egl::Error SyncEGL::initialize(const egl::Display *display,
                                 const gl::Context *context,
                                 EGLenum type)
  {
      ASSERT(type == EGL_SYNC_FENCE_KHR || type == EGL_SYNC_NATIVE_FENCE_ANDROID);
  
      constexpr size_t kAttribVectorSize = 3;
      angle::FixedVector<EGLint, kAttribVectorSize> attribs;
      if (type == EGL_SYNC_NATIVE_FENCE_ANDROID)
      {
          attribs.push_back(EGL_SYNC_NATIVE_FENCE_FD_ANDROID);
          attribs.push_back(mNativeFenceFD);
      }
      attribs.push_back(EGL_NONE);
  
      mSync = mEGL->createSyncKHR(type, attribs.data());
      if (mSync == EGL_NO_SYNC_KHR)
      {
          return egl::Error(mEGL->getError(), "eglCreateSync failed to create sync object");
      }
  
      return egl::NoError();
  }
  
  egl::Error SyncEGL::clientWait(const egl::Display *display,
                                 const gl::Context *context,
                                 EGLint flags,
                                 EGLTime timeout,
                                 EGLint *outResult)
  {
      ASSERT(mSync != EGL_NO_SYNC_KHR);
      EGLint result = mEGL->clientWaitSyncKHR(mSync, flags, timeout);
  
      if (result == EGL_FALSE)
      {
          return egl::Error(mEGL->getError(), "eglClientWaitSync failed");
      }
  
      *outResult = result;
      return egl::NoError();
  }
  
  egl::Error SyncEGL::serverWait(const egl::Display *display,
                                 const gl::Context *context,
                                 EGLint flags)
  {
      ASSERT(mSync != EGL_NO_SYNC_KHR);
      EGLint result = mEGL->waitSyncKHR(mSync, flags);
  
      if (result == EGL_FALSE)
      {
          return egl::Error(mEGL->getError(), "eglWaitSync failed");
      }
  
      return egl::NoError();
  }
  
  egl::Error SyncEGL::getStatus(const egl::Display *display, EGLint *outStatus)
  {
      ASSERT(mSync != EGL_NO_SYNC_KHR);
      EGLBoolean result = mEGL->getSyncAttribKHR(mSync, EGL_SYNC_STATUS_KHR, outStatus);
  
      if (result == EGL_FALSE)
      {
          return egl::Error(mEGL->getError(), "eglGetSyncAttribKHR with EGL_SYNC_STATUS_KHR failed");
      }
  
      return egl::NoError();
  }
  
  egl::Error SyncEGL::dupNativeFenceFD(const egl::Display *display, EGLint *result) const
  {
      ASSERT(mSync != EGL_NO_SYNC_KHR);
      *result = mEGL->dupNativeFenceFDANDROID(mSync);
      if (*result == EGL_NO_NATIVE_FENCE_FD_ANDROID)
      {
          return egl::Error(mEGL->getError(), "eglDupNativeFenceFDANDROID failed");
      }
  
      return egl::NoError();
  }
  
  }  // namespace rx
  

Download