chromium/third_party/angle/util/capture/frame_capture_test_utils.h

//
// Copyright 2020 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.
//
// frame_capture_test_utils:
//   Helper functions for capture and replay of traces.
//

#ifndef UTIL_CAPTURE_FRAME_CAPTURE_TEST_UTILS_H_
#define UTIL_CAPTURE_FRAME_CAPTURE_TEST_UTILS_H_

#include <iostream>
#include <map>
#include <memory>
#include <sstream>
#include <type_traits>
#include <vector>

#include "common/angleutils.h"
#include "common/debug.h"
#include "common/frame_capture_utils.h"
#include "common/system_utils.h"
#include "trace_interface.h"

#define USE_SYSTEM_ZLIB
#include "compression_utils_portable.h"

#define ANGLE_MACRO_STRINGIZE_AUX(a) …
#define ANGLE_MACRO_STRINGIZE(a) …
#define ANGLE_MACRO_CONCAT_AUX(a, b) …
#define ANGLE_MACRO_CONCAT(a, b) …

namespace angle
{

ValidateSerializedStateCallback;

GetSerializedContextStateFunc;
SetValidateSerializedStateCallbackFunc;
SetupEntryPoints;

class TraceLibrary : angle::NonCopyable, angle::TraceCallbacks
{ … };

bool LoadTraceNamesFromJSON(const std::string jsonFilePath, std::vector<std::string> *namesOut);
bool LoadTraceInfoFromJSON(const std::string &traceName,
                           const std::string &traceJsonPath,
                           TraceInfo *traceInfoOut);

TraceFunction;
TraceFunctionMap;

void ReplayTraceFunctionCall(const CallCapture &call, const TraceFunctionMap &customFunctions);
void ReplayCustomFunctionCall(const CallCapture &call, const TraceFunctionMap &customFunctions);

template <typename T>
struct AssertFalse : std::false_type
{ … };

GLuint GetResourceIDMapValue(ResourceIDType resourceIDType, GLuint key);

template <typename T>
T GetParamValue(ParamType type, const ParamValue &value);

template <>
inline GLuint GetParamValue<GLuint>(ParamType type, const ParamValue &value)
{ … }

template <>
inline GLint GetParamValue<GLint>(ParamType type, const ParamValue &value)
{ … }

template <>
inline const void *GetParamValue<const void *>(ParamType type, const ParamValue &value)
{ … }

template <>
inline GLuint64 GetParamValue<GLuint64>(ParamType type, const ParamValue &value)
{ … }

template <>
inline GLint64 GetParamValue<GLint64>(ParamType type, const ParamValue &value)
{ … }

template <>
inline const char *GetParamValue<const char *>(ParamType type, const ParamValue &value)
{ … }

template <>
inline void *GetParamValue<void *>(ParamType type, const ParamValue &value)
{ … }

#if defined(ANGLE_IS_64_BIT_CPU)
template <>
inline const EGLAttrib *GetParamValue<const EGLAttrib *>(ParamType type, const ParamValue &value)
{ … }
#endif  // defined(ANGLE_IS_64_BIT_CPU)

template <>
inline const EGLint *GetParamValue<const EGLint *>(ParamType type, const ParamValue &value)
{ … }

template <>
inline const GLchar *const *GetParamValue<const GLchar *const *>(ParamType type,
                                                                 const ParamValue &value)
{ … }

// On Apple platforms, std::is_same<uint64_t, long> is false despite being both 8 bits.
#if defined(ANGLE_PLATFORM_APPLE) || !defined(ANGLE_IS_64_BIT_CPU)
template <>
inline long GetParamValue<long>(ParamType type, const ParamValue &value)
{
    return static_cast<long>(value.GLint64Val);
}

template <>
inline unsigned long GetParamValue<unsigned long>(ParamType type, const ParamValue &value)
{
    return static_cast<unsigned long>(value.GLuint64Val);
}
#endif  // defined(ANGLE_PLATFORM_APPLE)

template <typename T>
T GetParamValue(ParamType type, const ParamValue &value)
{ … }

template <typename T>
struct Traits;

Traits<void (Args...)>;

FnArg;

EnableIfNArgs;

template <typename Fn, size_t Idx>
FnArg<Fn, Idx> Arg(const Captures &cap)
{ … }
}  // namespace angle

#endif  // UTIL_CAPTURE_FRAME_CAPTURE_TEST_UTILS_H_