| // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "gpu/command_buffer/client/gl_in_process_context.h" |
| |
| #include <stddef.h> |
| #include <stdint.h> |
| |
| #include <memory> |
| #include <set> |
| #include <utility> |
| #include <vector> |
| |
| #include <GLES2/gl2.h> |
| #ifndef GL_GLEXT_PROTOTYPES |
| #define GL_GLEXT_PROTOTYPES 1 |
| #endif |
| #include <GLES2/gl2ext.h> |
| #include <GLES2/gl2extchromium.h> |
| |
| #include "base/bind.h" |
| #include "base/bind_helpers.h" |
| #include "base/lazy_instance.h" |
| #include "base/logging.h" |
| #include "base/macros.h" |
| #include "base/memory/weak_ptr.h" |
| #include "base/message_loop/message_loop.h" |
| #include "gpu/command_buffer/client/gles2_cmd_helper.h" |
| #include "gpu/command_buffer/client/gles2_implementation.h" |
| #include "gpu/command_buffer/client/shared_memory_limits.h" |
| #include "gpu/command_buffer/client/transfer_buffer.h" |
| #include "gpu/command_buffer/common/command_buffer.h" |
| #include "gpu/command_buffer/common/constants.h" |
| #include "ui/gfx/geometry/size.h" |
| #include "ui/gl/gl_image.h" |
| |
| #if defined(OS_ANDROID) |
| #include "ui/gl/android/surface_texture.h" |
| #endif |
| |
| namespace gpu { |
| |
| namespace { |
| |
| class GLInProcessContextImpl |
| : public GLInProcessContext, |
| public base::SupportsWeakPtr<GLInProcessContextImpl> { |
| public: |
| GLInProcessContextImpl(); |
| ~GLInProcessContextImpl() override; |
| |
| bool Initialize(scoped_refptr<gl::GLSurface> surface, |
| bool is_offscreen, |
| GLInProcessContext* share_context, |
| gfx::AcceleratedWidget window, |
| const gpu::gles2::ContextCreationAttribHelper& attribs, |
| const scoped_refptr<InProcessCommandBuffer::Service>& service, |
| const SharedMemoryLimits& mem_limits, |
| GpuMemoryBufferManager* gpu_memory_buffer_manager, |
| ImageFactory* image_factory); |
| |
| // GLInProcessContext implementation: |
| gles2::GLES2Implementation* GetImplementation() override; |
| void SetLock(base::Lock* lock) override; |
| |
| private: |
| void Destroy(); |
| void OnSignalSyncPoint(const base::Closure& callback); |
| |
| std::unique_ptr<gles2::GLES2CmdHelper> gles2_helper_; |
| std::unique_ptr<TransferBuffer> transfer_buffer_; |
| std::unique_ptr<gles2::GLES2Implementation> gles2_implementation_; |
| std::unique_ptr<InProcessCommandBuffer> command_buffer_; |
| |
| DISALLOW_COPY_AND_ASSIGN(GLInProcessContextImpl); |
| }; |
| |
| GLInProcessContextImpl::GLInProcessContextImpl() = default; |
| |
| GLInProcessContextImpl::~GLInProcessContextImpl() { |
| Destroy(); |
| } |
| |
| gles2::GLES2Implementation* GLInProcessContextImpl::GetImplementation() { |
| return gles2_implementation_.get(); |
| } |
| |
| void GLInProcessContextImpl::SetLock(base::Lock* lock) { |
| NOTREACHED(); |
| } |
| |
| bool GLInProcessContextImpl::Initialize( |
| scoped_refptr<gl::GLSurface> surface, |
| bool is_offscreen, |
| GLInProcessContext* share_context, |
| gfx::AcceleratedWidget window, |
| const gles2::ContextCreationAttribHelper& attribs, |
| const scoped_refptr<InProcessCommandBuffer::Service>& service, |
| const SharedMemoryLimits& mem_limits, |
| GpuMemoryBufferManager* gpu_memory_buffer_manager, |
| ImageFactory* image_factory) { |
| DCHECK_GE(attribs.offscreen_framebuffer_size.width(), 0); |
| DCHECK_GE(attribs.offscreen_framebuffer_size.height(), 0); |
| |
| command_buffer_.reset(new InProcessCommandBuffer(service)); |
| |
| scoped_refptr<gles2::ShareGroup> share_group; |
| InProcessCommandBuffer* share_command_buffer = nullptr; |
| if (share_context) { |
| GLInProcessContextImpl* impl = |
| static_cast<GLInProcessContextImpl*>(share_context); |
| share_group = impl->gles2_implementation_->share_group(); |
| share_command_buffer = impl->command_buffer_.get(); |
| DCHECK(share_group); |
| DCHECK(share_command_buffer); |
| } |
| |
| if (!command_buffer_->Initialize(surface, |
| is_offscreen, |
| window, |
| attribs, |
| share_command_buffer, |
| gpu_memory_buffer_manager, |
| image_factory)) { |
| DLOG(ERROR) << "Failed to initialize InProcessCommmandBuffer"; |
| return false; |
| } |
| |
| // Create the GLES2 helper, which writes the command buffer protocol. |
| gles2_helper_.reset(new gles2::GLES2CmdHelper(command_buffer_.get())); |
| if (!gles2_helper_->Initialize(mem_limits.command_buffer_size)) { |
| LOG(ERROR) << "Failed to initialize GLES2CmdHelper"; |
| Destroy(); |
| return false; |
| } |
| |
| // Create a transfer buffer. |
| transfer_buffer_.reset(new TransferBuffer(gles2_helper_.get())); |
| |
| // Check for consistency. |
| DCHECK(!attribs.bind_generates_resource); |
| const bool bind_generates_resource = false; |
| const bool support_client_side_arrays = false; |
| |
| // Create the object exposing the OpenGL API. |
| gles2_implementation_.reset( |
| new gles2::GLES2Implementation(gles2_helper_.get(), |
| share_group.get(), |
| transfer_buffer_.get(), |
| bind_generates_resource, |
| attribs.lose_context_when_out_of_memory, |
| support_client_side_arrays, |
| command_buffer_.get())); |
| |
| if (!gles2_implementation_->Initialize( |
| mem_limits.start_transfer_buffer_size, |
| mem_limits.min_transfer_buffer_size, |
| mem_limits.max_transfer_buffer_size, |
| mem_limits.mapped_memory_reclaim_limit)) { |
| return false; |
| } |
| |
| return true; |
| } |
| |
| void GLInProcessContextImpl::Destroy() { |
| if (gles2_implementation_) { |
| // First flush the context to ensure that any pending frees of resources |
| // are completed. Otherwise, if this context is part of a share group, |
| // those resources might leak. Also, any remaining side effects of commands |
| // issued on this context might not be visible to other contexts in the |
| // share group. |
| gles2_implementation_->Flush(); |
| |
| gles2_implementation_.reset(); |
| } |
| |
| transfer_buffer_.reset(); |
| gles2_helper_.reset(); |
| command_buffer_.reset(); |
| } |
| |
| } // anonymous namespace |
| |
| // static |
| GLInProcessContext* GLInProcessContext::Create( |
| scoped_refptr<gpu::InProcessCommandBuffer::Service> service, |
| scoped_refptr<gl::GLSurface> surface, |
| bool is_offscreen, |
| gfx::AcceleratedWidget window, |
| GLInProcessContext* share_context, |
| const ::gpu::gles2::ContextCreationAttribHelper& attribs, |
| const SharedMemoryLimits& memory_limits, |
| GpuMemoryBufferManager* gpu_memory_buffer_manager, |
| ImageFactory* image_factory) { |
| if (surface.get()) { |
| DCHECK_EQ(surface->IsOffscreen(), is_offscreen); |
| DCHECK_EQ(gfx::kNullAcceleratedWidget, window); |
| } |
| |
| std::unique_ptr<GLInProcessContextImpl> context(new GLInProcessContextImpl); |
| if (!context->Initialize(surface, is_offscreen, share_context, window, |
| attribs, service, memory_limits, |
| gpu_memory_buffer_manager, image_factory)) |
| return NULL; |
| |
| return context.release(); |
| } |
| |
| } // namespace gpu |