chromium/third_party/angle/src/libANGLE/Debug.cpp

//
// Copyright 2015 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.
//

// Debug.cpp: Defines debug state used for GL_KHR_debug

#include "libANGLE/Debug.h"

#include "common/debug.h"

#include <algorithm>
#include <tuple>

namespace
{
const char *GLSeverityToString(GLenum severity)
{ … }

const char *EGLMessageTypeToString(egl::MessageType messageType)
{ … }

const char *GLMessageTypeToString(GLenum type)
{ … }
}  // namespace

namespace gl
{

Debug::Control::Control() { … }

Debug::Control::~Control() { … }

Debug::Control::Control(const Control &other) = default;

Debug::Group::Group() { … }

Debug::Group::~Group() { … }

Debug::Group::Group(const Group &other) = default;

Debug::Debug(bool initialDebugState)
    : … { … }

Debug::~Debug() { … }

void Debug::setMaxLoggedMessages(GLuint maxLoggedMessages)
{ … }

void Debug::setOutputEnabled(bool enabled)
{ … }

bool Debug::isOutputEnabled() const
{ … }

void Debug::setOutputSynchronous(bool synchronous)
{ … }

bool Debug::isOutputSynchronous() const
{ … }

void Debug::setCallback(GLDEBUGPROCKHR callback, const void *userParam)
{ … }

GLDEBUGPROCKHR Debug::getCallback() const
{ … }

const void *Debug::getUserParam() const
{ … }

void Debug::insertMessage(GLenum source,
                          GLenum type,
                          GLuint id,
                          GLenum severity,
                          const std::string &message,
                          gl::LogSeverity logSeverity,
                          angle::EntryPoint entryPoint) const
{ … }

void Debug::insertMessage(GLenum source,
                          GLenum type,
                          GLuint id,
                          GLenum severity,
                          std::string &&message,
                          gl::LogSeverity logSeverity,
                          angle::EntryPoint entryPoint) const
{ … }

size_t Debug::getMessages(GLuint count,
                          GLsizei bufSize,
                          GLenum *sources,
                          GLenum *types,
                          GLuint *ids,
                          GLenum *severities,
                          GLsizei *lengths,
                          GLchar *messageLog)
{ … }

size_t Debug::getNextMessageLength() const
{ … }

size_t Debug::getMessageCount() const
{ … }

void Debug::setMessageControl(GLenum source,
                              GLenum type,
                              GLenum severity,
                              std::vector<GLuint> &&ids,
                              bool enabled)
{ … }

void Debug::pushGroup(GLenum source, GLuint id, std::string &&message)
{ … }

void Debug::popGroup()
{ … }

size_t Debug::getGroupStackDepth() const
{ … }

void Debug::insertPerfWarning(GLenum severity, bool isLastRepeat, const char *message) const
{ … }

bool Debug::isMessageEnabled(GLenum source, GLenum type, GLuint id, GLenum severity) const
{ … }

void Debug::pushDefaultGroup()
{ … }
}  // namespace gl

namespace egl
{

namespace
{
angle::PackedEnumBitSet<MessageType> GetDefaultMessageTypeBits()
{ … }
}  // anonymous namespace

Debug::Debug() : … { … }

void Debug::setCallback(EGLDEBUGPROCKHR callback, const AttributeMap &attribs)
{ … }

EGLDEBUGPROCKHR Debug::getCallback() const
{ … }

bool Debug::isMessageTypeEnabled(MessageType type) const
{ … }

void Debug::insertMessage(EGLenum error,
                          const char *command,
                          MessageType messageType,
                          EGLLabelKHR threadLabel,
                          EGLLabelKHR objectLabel,
                          const std::string &message) const
{ … }

}  // namespace egl