author yulia <>
Thu, 18 Oct 2018 14:34:33 +0000
changeset 490315 a6b4461eadf0622f4d4f6ea1ee8389d1c655b336
parent 480569 176dcc5da6fe5f0596a32015e710054b03da88ce
permissions -rw-r--r--
Bug 1495387 - introduce async front instantiation; r=ochameau Depends on D8989 Differential Revision:

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* vim: set ts=8 sts=4 et sw=4 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at */


#include "GLContext.h"
#include "GLLibraryEGL.h"

namespace mozilla {
namespace widget {
class CompositorWidget;
} // namespace widget
namespace gl {

class GLContextEGL : public GLContext
    friend class TextureImageEGL;

    static already_AddRefed<GLContextEGL>
    CreateGLContext(CreateContextFlags flags,
                    const SurfaceCaps& caps,
                    bool isOffscreen,
                    EGLConfig config,
                    EGLSurface surface,
                    nsACString* const out_failureId);

    GLContextEGL(CreateContextFlags flags,
                 const SurfaceCaps& caps,
                 bool isOffscreen,
                 EGLConfig config,
                 EGLSurface surface,
                 EGLContext context);


    virtual GLContextType GetContextType() const override { return GLContextType::EGL; }

    static GLContextEGL* Cast(GLContext* gl) {
        MOZ_ASSERT(gl->GetContextType() == GLContextType::EGL);
        return static_cast<GLContextEGL*>(gl);

    bool Init() override;

    virtual bool IsDoubleBuffered() const override {
        return mIsDoubleBuffered;

    void SetIsDoubleBuffered(bool aIsDB) {
        mIsDoubleBuffered = aIsDB;

    virtual bool IsANGLE() const override {
        return GLLibraryEGL::Get()->IsANGLE();

    virtual bool IsWARP() const override {
        return GLLibraryEGL::Get()->IsWARP();

    virtual bool BindTexImage() override;

    virtual bool ReleaseTexImage() override;

    void SetEGLSurfaceOverride(EGLSurface surf);
    EGLSurface GetEGLSurfaceOverride() {
        return mSurfaceOverride;

    virtual bool MakeCurrentImpl() const override;

    virtual bool IsCurrentImpl() const override;

    virtual bool RenewSurface(widget::CompositorWidget* aWidget) override;

    virtual void ReleaseSurface() override;

    virtual bool SetupLookupFunction() override;

    virtual bool SwapBuffers() override;

    virtual void GetWSIInfo(nsCString* const out) const override;

    // hold a reference to the given surface
    // for the lifetime of this context.
    void HoldSurface(gfxASurface* aSurf);

    EGLSurface GetEGLSurface() const {
        return mSurface;

    EGLDisplay GetEGLDisplay() const {
        return GLLibraryEGL::Get()->Display();

    bool BindTex2DOffscreen(GLContext* aOffscreen);
    void UnbindTex2DOffscreen(GLContext* aOffscreen);
    void BindOffscreenFramebuffer();

    void Destroy();

    static already_AddRefed<GLContextEGL>
    CreateEGLPBufferOffscreenContext(CreateContextFlags flags,
                                     const gfx::IntSize& size,
                                     const SurfaceCaps& minCaps,
                                     nsACString* const out_FailureId);

    friend class GLContextProviderEGL;
    friend class GLContextEGLFactory;

    const EGLConfig mConfig;
    const RefPtr<GLLibraryEGL> mEgl;
    EGLSurface mSurface;
    const EGLSurface mFallbackSurface;
    const EGLContext mContext;
    EGLSurface mSurfaceOverride = EGL_NO_SURFACE;
    RefPtr<gfxASurface> mThebesSurface;
    bool mBound = false;

    bool mIsPBuffer = false;
    bool mIsDoubleBuffered = false;
    bool mCanBindToTexture = false;
    bool mShareWithEGLImage = false;
    bool mOwnsContext = true;

    static EGLSurface CreatePBufferSurfaceTryingPowerOfTwo(EGLConfig config,
                                                           EGLenum bindToTextureFormat,
                                                           gfx::IntSize& pbsize);
#if defined(MOZ_WAYLAND)
    static EGLSurface CreateWaylandBufferSurface(EGLConfig config,
                                                 gfx::IntSize& pbsize);
    EGLSurface CreateCompatibleSurface(void* aWindow);
#endif // defined(MOZ_WIDGET_ANDROID)

bool CreateConfig(EGLConfig* config, int32_t depth, bool enableDepthBuffer);

} // namespace gl
} // namespace mozilla