1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206
|
// 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.
#ifndef GPU_COMMAND_BUFFER_TESTS_GL_MANAGER_H_
#define GPU_COMMAND_BUFFER_TESTS_GL_MANAGER_H_
#include <stddef.h>
#include <stdint.h>
#include <memory>
#include "base/memory/raw_ptr.h"
#include "base/memory/ref_counted.h"
#include "gpu/command_buffer/client/gpu_control.h"
#include "gpu/command_buffer/client/shared_memory_limits.h"
#include "gpu/command_buffer/common/context_creation_attribs.h"
#include "gpu/command_buffer/service/feature_info.h"
#include "gpu/command_buffer/service/gpu_tracer.h"
#include "gpu/command_buffer/service/passthrough_discardable_manager.h"
#include "gpu/command_buffer/service/service_discardable_manager.h"
#include "gpu/command_buffer/service/shared_image/shared_image_manager.h"
#include "gpu/config/gpu_feature_info.h"
#include "gpu/config/gpu_preferences.h"
#include "ui/gfx/geometry/size.h"
#include "ui/gfx/gpu_memory_buffer.h"
namespace gl {
class GLContext;
class GLShareGroup;
class GLSurface;
}
namespace gpu {
class CommandBufferDirect;
class GpuMemoryBufferFactory;
class TransferBuffer;
namespace gles2 {
class GLES2CmdHelper;
class GLES2Implementation;
} // namespace gles2
class GLManager : private GpuControl {
public:
struct Options {
Options();
// The size of the backbuffer.
gfx::Size size = gfx::Size(4, 4);
// If not null will share resources with this context.
raw_ptr<GLManager> share_group_manager = nullptr;
// If not null will create a virtual manager based on this context.
raw_ptr<GLManager> virtual_manager = nullptr;
// Whether or not glBindXXX generates a resource.
bool bind_generates_resource = false;
// Whether or not the context is auto-lost when GL_OUT_OF_MEMORY occurs.
bool lose_context_when_out_of_memory = false;
// Whether or not it's ok to lose the context.
bool context_lost_allowed = false;
ContextType context_type = CONTEXT_TYPE_OPENGLES2;
// Force shader name hashing for all context types.
bool force_shader_name_hashing = false;
// Whether the buffer is multisampled.
bool multisampled = false;
// If we should use native gmb for backbuffer.
bool should_use_native_gmb_for_backbuffer = false;
// Shared memory limits
SharedMemoryLimits shared_memory_limits = {};
};
GLManager();
~GLManager() override;
// GPU feature info computed for the platform.
// Each test needs to apply them, plus the specific settings a test wants
// to test.
static GpuFeatureInfo g_gpu_feature_info;
std::unique_ptr<gfx::GpuMemoryBuffer> CreateGpuMemoryBuffer(
const gfx::Size& size,
gfx::BufferFormat format);
void Initialize(const Options& options);
void InitializeWithWorkarounds(const Options& options,
const GpuDriverBugWorkarounds& workarounds);
void Destroy();
bool IsInitialized() const { return gles2_implementation() != nullptr; }
void MakeCurrent();
void SetSurface(gl::GLSurface* surface);
void PerformIdleWork();
void BindOffscreenFramebuffer(GLenum target);
void set_use_iosurface_memory_buffers(bool use_iosurface_memory_buffers) {
use_iosurface_memory_buffers_ = use_iosurface_memory_buffers;
}
void set_use_native_pixmap_memory_buffers(
bool use_native_pixmap_memory_buffers) {
use_native_pixmap_memory_buffers_ = use_native_pixmap_memory_buffers;
}
gles2::GLES2Decoder* decoder() const {
return decoder_.get();
}
gl::GLShareGroup* share_group() const { return share_group_.get(); }
gles2::GLES2Implementation* gles2_implementation() const {
return gles2_implementation_.get();
}
gl::GLContext* context() { return context_.get(); }
ServiceDiscardableManager* discardable_manager() {
return discardable_manager_.get();
}
PassthroughDiscardableManager* passthrough_discardable_manager() {
return passthrough_discardable_manager_.get();
}
const GpuDriverBugWorkarounds& workarounds() const;
const gpu::GpuPreferences& gpu_preferences() const {
return gpu_preferences_;
}
// GpuControl implementation.
void SetGpuControlClient(GpuControlClient*) override;
const Capabilities& GetCapabilities() const override;
const GLCapabilities& GetGLCapabilities() const override;
void SignalQuery(uint32_t query, base::OnceClosure callback) override;
void CancelAllQueries() override;
void CreateGpuFence(uint32_t gpu_fence_id, ClientGpuFence source) override;
void GetGpuFence(uint32_t gpu_fence_id,
base::OnceCallback<void(std::unique_ptr<gfx::GpuFence>)>
callback) override;
void SetLock(base::Lock*) override;
void EnsureWorkVisible() override;
gpu::CommandBufferNamespace GetNamespaceID() const override;
CommandBufferId GetCommandBufferID() const override;
void FlushPendingWork() override;
uint64_t GenerateFenceSyncRelease() override;
bool IsFenceSyncReleased(uint64_t release) override;
void SignalSyncToken(const gpu::SyncToken& sync_token,
base::OnceClosure callback) override;
void WaitSyncToken(const gpu::SyncToken& sync_token) override;
bool CanWaitUnverifiedSyncToken(const gpu::SyncToken& sync_token) override;
size_t GetSharedMemoryBytesAllocated() const;
ContextType GetContextType() const;
void Reset();
private:
void SetupBaseContext();
void InitializeWithWorkaroundsImpl(
const Options& options,
const GpuDriverBugWorkarounds& workarounds);
gpu::GpuPreferences gpu_preferences_;
gles2::TraceOutputter outputter_;
std::unique_ptr<ServiceDiscardableManager> discardable_manager_;
std::unique_ptr<PassthroughDiscardableManager>
passthrough_discardable_manager_;
std::unique_ptr<gles2::ShaderTranslatorCache> translator_cache_;
gles2::FramebufferCompletenessCache completeness_cache_;
scoped_refptr<gl::GLShareGroup> share_group_;
std::unique_ptr<CommandBufferDirect> command_buffer_;
std::unique_ptr<gles2::GLES2Decoder> decoder_;
scoped_refptr<gl::GLContext> context_;
std::unique_ptr<gles2::GLES2CmdHelper> gles2_helper_;
std::unique_ptr<TransferBuffer> transfer_buffer_;
std::unique_ptr<gles2::GLES2Implementation> gles2_implementation_;
std::unique_ptr<gpu::GpuMemoryBufferFactory> gpu_memory_buffer_factory_;
SharedImageManager shared_image_manager_;
bool use_iosurface_memory_buffers_ = false;
bool use_native_pixmap_memory_buffers_ = false;
Capabilities capabilities_;
GLCapabilities gl_capabilities_;
GLuint fbo_ = 0;
// Used on Android to virtualize GL for all contexts with validating command
// decoder.
static int use_count_;
static scoped_refptr<gl::GLShareGroup>* base_share_group_;
static scoped_refptr<gl::GLSurface>* base_surface_;
static scoped_refptr<gl::GLContext>* base_context_;
ContextType context_type_ = CONTEXT_TYPE_OPENGLES2;
};
} // namespace gpu
#endif // GPU_COMMAND_BUFFER_TESTS_GL_MANAGER_H_
|