chromium/ui/gl/gl_implementation.cc

// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "ui/gl/gl_implementation.h"

#include <stddef.h>

#include <cstdlib>
#include <sstream>
#include <string>
#include <string_view>
#include <vector>

#include "base/at_exit.h"
#include "base/command_line.h"
#include "base/compiler_specific.h"
#include "base/containers/contains.h"
#include "base/logging.h"
#include "base/strings/string_split.h"
#include "base/strings/string_util.h"
#include "build/build_config.h"
#include "build/chromeos_buildflags.h"
#include "ui/gl/buildflags.h"
#include "ui/gl/gl_bindings.h"
#include "ui/gl/gl_gl_api_implementation.h"
#include "ui/gl/gl_version_info.h"

namespace gl {

bool GLImplementationParts::IsValid() const { … }

bool GLImplementationParts::IsAllowed(
    const std::vector<GLImplementationParts>& allowed_impls) const { … }

std::string GLImplementationParts::ToString() const { … }

std::string GLImplementationParts::GLString() const { … }

std::string GLImplementationParts::ANGLEString() const { … }

namespace {

const struct { … } kGLImplementationNamePairs[] = …;

LibraryArray;

GLImplementationParts g_gl_implementation = …;
LibraryArray* g_libraries;
GLGetProcAddressProc g_get_proc_address;

void CleanupNativeLibraries(void* due_to_fallback) { … }

gfx::ExtensionSet GetGLExtensionsFromCurrentContext(GLApi* api,
                                                    GLenum extensions_enum) { … }

}  // namespace

EGLApi* g_current_egl_context;

GLImplementationParts GetNamedGLImplementation(const std::string& gl_name,
                                               const std::string& angle_name) { … }

GLImplementationParts GetSoftwareGLImplementation() { … }

bool IsSoftwareGLImplementation(GLImplementationParts implementation) { … }

void SetSoftwareGLCommandLineSwitches(base::CommandLine* command_line) { … }

void SetSoftwareWebGLCommandLineSwitches(base::CommandLine* command_line) { … }

std::optional<GLImplementationParts>
GetRequestedGLImplementationFromCommandLine(
    const base::CommandLine* command_line) { … }

const char* GetGLImplementationGLName(GLImplementationParts implementation) { … }

const char* GetGLImplementationANGLEName(GLImplementationParts implementation) { … }

void SetGLImplementationParts(const GLImplementationParts& implementation) { … }

const GLImplementationParts& GetGLImplementationParts() { … }

void SetGLImplementation(GLImplementation implementation) { … }

GLImplementation GetGLImplementation() { … }

void SetANGLEImplementation(ANGLEImplementation implementation) { … }

ANGLEImplementation GetANGLEImplementation() { … }

void AddGLNativeLibrary(base::NativeLibrary library) { … }

void UnloadGLNativeLibraries(bool due_to_fallback) { … }

void SetGLGetProcAddressProc(GLGetProcAddressProc proc) { … }

NO_SANITIZE("cfi-icall")
STDCALL GLFunctionPointerType GetGLProcAddress(const char* name) { … }

void SetNullDrawGLBindings(bool enabled) { … }

bool HasInitializedNullDrawGLBindings() { … }

std::string FilterGLExtensionList(
    const char* extensions,
    const std::vector<std::string>& disabled_extensions) { … }

DisableNullDrawGLBindings::DisableNullDrawGLBindings() { … }

DisableNullDrawGLBindings::~DisableNullDrawGLBindings() { … }

GLWindowSystemBindingInfo::GLWindowSystemBindingInfo() { … }
GLWindowSystemBindingInfo::~GLWindowSystemBindingInfo() { … }

std::string GetGLExtensionsFromCurrentContext() { … }

std::string GetGLExtensionsFromCurrentContext(GLApi* api) { … }

gfx::ExtensionSet GetRequestableGLExtensionsFromCurrentContext() { … }

gfx::ExtensionSet GetRequestableGLExtensionsFromCurrentContext(GLApi* api) { … }

base::NativeLibrary LoadLibraryAndPrintError(
    const base::FilePath::CharType* filename) { … }

base::NativeLibrary LoadLibraryAndPrintError(const base::FilePath& filename) { … }

#if BUILDFLAG(USE_OPENGL_APITRACE)
void TerminateFrame() {
  GetGLProcAddress("glFrameTerminatorGREMEDY")();
}
#endif

}  // namespace gl