chromium/third_party/angle/src/libANGLE/renderer/null/DisplayNULL.cpp

//
// Copyright 2016 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.
//
// DisplayNULL.cpp:
//    Implements the class methods for DisplayNULL.
//

#include "libANGLE/renderer/null/DisplayNULL.h"

#include "common/debug.h"

#include "libANGLE/Display.h"
#include "libANGLE/renderer/null/ContextNULL.h"
#include "libANGLE/renderer/null/DeviceNULL.h"
#include "libANGLE/renderer/null/ImageNULL.h"
#include "libANGLE/renderer/null/SurfaceNULL.h"

namespace rx
{

DisplayNULL::DisplayNULL(const egl::DisplayState &state) : … { … }

DisplayNULL::~DisplayNULL() { … }

egl::Error DisplayNULL::initialize(egl::Display *display)
{ … }

void DisplayNULL::terminate()
{ … }

egl::Error DisplayNULL::makeCurrent(egl::Display *display,
                                    egl::Surface *drawSurface,
                                    egl::Surface *readSurface,
                                    gl::Context *context)
{ … }

egl::ConfigSet DisplayNULL::generateConfigs()
{ … }

bool DisplayNULL::testDeviceLost()
{ … }

egl::Error DisplayNULL::restoreLostDevice(const egl::Display *display)
{ … }

bool DisplayNULL::isValidNativeWindow(EGLNativeWindowType window) const
{ … }

std::string DisplayNULL::getRendererDescription()
{ … }

std::string DisplayNULL::getVendorString()
{ … }

std::string DisplayNULL::getVersionString(bool includeFullVersion)
{ … }

DeviceImpl *DisplayNULL::createDevice()
{ … }

egl::Error DisplayNULL::waitClient(const gl::Context *context)
{ … }

egl::Error DisplayNULL::waitNative(const gl::Context *context, EGLint engine)
{ … }

gl::Version DisplayNULL::getMaxSupportedESVersion() const
{ … }

Optional<gl::Version> DisplayNULL::getMaxSupportedDesktopVersion() const
{ … }

gl::Version DisplayNULL::getMaxConformantESVersion() const
{ … }

SurfaceImpl *DisplayNULL::createWindowSurface(const egl::SurfaceState &state,
                                              EGLNativeWindowType window,
                                              const egl::AttributeMap &attribs)
{ … }

SurfaceImpl *DisplayNULL::createPbufferSurface(const egl::SurfaceState &state,
                                               const egl::AttributeMap &attribs)
{ … }

SurfaceImpl *DisplayNULL::createPbufferFromClientBuffer(const egl::SurfaceState &state,
                                                        EGLenum buftype,
                                                        EGLClientBuffer buffer,
                                                        const egl::AttributeMap &attribs)
{ … }

SurfaceImpl *DisplayNULL::createPixmapSurface(const egl::SurfaceState &state,
                                              NativePixmapType nativePixmap,
                                              const egl::AttributeMap &attribs)
{ … }

ImageImpl *DisplayNULL::createImage(const egl::ImageState &state,
                                    const gl::Context *context,
                                    EGLenum target,
                                    const egl::AttributeMap &attribs)
{ … }

rx::ContextImpl *DisplayNULL::createContext(const gl::State &state,
                                            gl::ErrorSet *errorSet,
                                            const egl::Config *configuration,
                                            const gl::Context *shareContext,
                                            const egl::AttributeMap &attribs)
{ … }

StreamProducerImpl *DisplayNULL::createStreamProducerD3DTexture(
    egl::Stream::ConsumerType consumerType,
    const egl::AttributeMap &attribs)
{ … }

ShareGroupImpl *DisplayNULL::createShareGroup(const egl::ShareGroupState &state)
{ … }

void DisplayNULL::generateExtensions(egl::DisplayExtensions *outExtensions) const
{ … }

void DisplayNULL::generateCaps(egl::Caps *outCaps) const
{ … }

}  // namespace rx