blob: 0f2a757b0560e678485b2e23e66c063c9ebbe0c9 [file] [log] [blame]
// Copyright 2018 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 "base/callback.h"
#include "gpu/command_buffer/service/texture_base.h"
#include "gpu/gpu_gles2_export.h"
// Forwardly declare a few GL types to avoid including GL header files.
typedef unsigned GLenum;
typedef int GLsizei;
typedef int GLint;
typedef unsigned int GLuint;
namespace gl {
class GLImage;
} // namespace gl
namespace gpu {
namespace gles2 {
class GLStreamTextureImage;
// An AbstractTexture enables access to GL textures from the GPU process, for
// things that set up textures using some client's decoder. Creating an
// AbstractTexture is similar to "glGenTexture", and deleting it is similar to
// calling "glDeleteTextures".
// There are some subtle differences. Deleting an AbstractTexture doesn't
// guarantee that the underlying platform texture has been deleted if it's
// referenced elsewhere. For example, if it has been sent via mailbox to some
// other context, then it might still be around after the AbstractTexture has
// been destroyed.
// Also, an AbstractTexture is tied to the decoder that created it, in the sense
// that destroying the decoder drops the reference to the texture just as if the
// AbstractTexture were destroyed. While it's okay for the AbstractTexture to
// exist beyond decoder destruction, it won't actually refer to a texture after
// that. This makes it easier for the holder to ignore stub destruction; the
// texture will be cleaned up properly, as needed.
class GPU_GLES2_EXPORT AbstractTexture {
using CleanupCallback = base::OnceCallback<void(AbstractTexture*)>;
// The texture is guaranteed to be around while |this| exists, as long as
// the decoder isn't destroyed / context isn't lost.
virtual ~AbstractTexture() = default;
// Return our TextureBase, useful mostly for creating a mailbox. This may
// return null if the texture has been destroyed.
virtual TextureBase* GetTextureBase() const = 0;
// Set a texture parameter. The GL context must be current.
virtual void SetParameteri(GLenum pname, GLint param) = 0;
// Set |image| to be our stream texture image, using |service_id| in place
// of our real service id when the client tries to bind us. This must also
// guarantee that CopyTexImage() is called before drawing, so that |image|
// may update the stream texture. This will do nothing if the texture has
// been destroyed.
// It is not required to SetCleared() if one binds an image.
// The context must be current.
virtual void BindStreamTextureImage(GLStreamTextureImage* image,
GLuint service_id) = 0;
// Attaches |image| to the AbstractTexture. If |client_managed| is true, then
// the decoder does not call GLImage::Copy/Bind. Further, the decoder
// guarantees that ScheduleOverlayPlane will be called if the texture is ever
// promoted to an overlay.
// It is not required to SetCleared() if one binds an image.
// The context must be current.
virtual void BindImage(gl::GLImage* image, bool client_managed) = 0;
// Return the image, if any.
virtual gl::GLImage* GetImage() const = 0;
// Marks the texture as cleared, to help prevent sending an uninitialized
// texture to the (untrusted) renderer. One should call this only when one
// has actually initialized the texture.
virtual void SetCleared() = 0;
// Set a callback that will be called when the AbstractTexture is going to
// drop its reference to the underlying TextureBase. We can't guarantee that
// the TextureBase will be destroyed, but it is the last time that we can
// guarantee that it won't be. Typically, this callback will happen when the
// AbstractTexture is destroyed, or when our stub is destroyed. Do not change
// the current context during this callback. Also, do not assume that one
// has a current context.
virtual void SetCleanupCallback(CleanupCallback cleanup_callback) = 0;
unsigned int service_id() const { return GetTextureBase()->service_id(); }
} // namespace gles2
} // namespace gpu