blob: 05f7367ff872fab46a4bd3575e8a60396e1ff9cc [file] [log] [blame]
// Copyright 2010 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 <string>
#include "base/callback.h"
#include "base/macros.h"
#include "base/synchronization/lock.h"
#include "base/threading/thread_checker.h"
#include "cc/cc_export.h"
#include "cc/layers/layer.h"
#include "cc/resources/texture_mailbox.h"
namespace gpu {
struct SyncToken;
namespace cc {
class BlockingTaskRunner;
class SingleReleaseCallback;
class SingleReleaseCallbackImpl;
class TextureLayerClient;
// A Layer containing a the rendered output of a plugin instance.
class CC_EXPORT TextureLayer : public Layer {
class CC_EXPORT TextureMailboxHolder
: public base::RefCountedThreadSafe<TextureMailboxHolder> {
class CC_EXPORT MainThreadReference {
explicit MainThreadReference(TextureMailboxHolder* holder);
TextureMailboxHolder* holder() { return holder_.get(); }
scoped_refptr<TextureMailboxHolder> holder_;
const TextureMailbox& mailbox() const { return mailbox_; }
void Return(const gpu::SyncToken& sync_token, bool is_lost);
// Gets a ReleaseCallback that can be called from another thread. Note: the
// caller must ensure the callback is called.
std::unique_ptr<SingleReleaseCallbackImpl> GetCallbackForImplThread();
friend class TextureLayer;
// Protected visiblity so only TextureLayer and unit tests can create these.
static std::unique_ptr<MainThreadReference> Create(
const TextureMailbox& mailbox,
std::unique_ptr<SingleReleaseCallback> release_callback);
virtual ~TextureMailboxHolder();
friend class base::RefCountedThreadSafe<TextureMailboxHolder>;
friend class MainThreadReference;
explicit TextureMailboxHolder(
const TextureMailbox& mailbox,
std::unique_ptr<SingleReleaseCallback> release_callback);
void InternalAddRef();
void InternalRelease();
void ReturnAndReleaseOnImplThread(
const gpu::SyncToken& sync_token,
bool is_lost,
BlockingTaskRunner* main_thread_task_runner);
// These members are only accessed on the main thread, or on the impl thread
// during commit where the main thread is blocked.
unsigned internal_references_;
TextureMailbox mailbox_;
std::unique_ptr<SingleReleaseCallback> release_callback_;
// This lock guards the sync_token_ and is_lost_ fields because they can be
// accessed on both the impl and main thread. We do this to ensure that the
// values of these fields are well-ordered such that the last call to
// ReturnAndReleaseOnImplThread() defines their values.
base::Lock arguments_lock_;
gpu::SyncToken sync_token_;
bool is_lost_;
base::ThreadChecker main_thread_checker_;
// Used when mailbox names are specified instead of texture IDs.
static scoped_refptr<TextureLayer> CreateForMailbox(
TextureLayerClient* client);
// Resets the client, which also resets the texture.
void ClearClient();
// Resets the texture.
void ClearTexture();
std::unique_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl) override;
// Sets whether this texture should be Y-flipped at draw time. Defaults to
// true.
void SetFlipped(bool flipped);
bool flipped() const { return flipped_; }
// Sets whether this texture should use nearest neighbor interpolation as
// opposed to bilinear. Defaults to false.
void SetNearestNeighbor(bool nearest_neighbor);
// Sets a UV transform to be used at draw time. Defaults to (0, 0) and (1, 1).
void SetUV(const gfx::PointF& top_left, const gfx::PointF& bottom_right);
// Sets an opacity value per vertex. It will be multiplied by the layer
// opacity value.
void SetVertexOpacity(float bottom_left,
float top_left,
float top_right,
float bottom_right);
// Sets whether the alpha channel is premultiplied or unpremultiplied.
// Defaults to true.
void SetPremultipliedAlpha(bool premultiplied_alpha);
// Sets whether the texture should be blended with the background color
// at draw time. Defaults to false.
void SetBlendBackgroundColor(bool blend);
// Code path for plugins which supply their own mailbox.
void SetTextureMailbox(
const TextureMailbox& mailbox,
std::unique_ptr<SingleReleaseCallback> release_callback);
void SetNeedsDisplayRect(const gfx::Rect& dirty_rect) override;
void SetLayerTreeHost(LayerTreeHost* layer_tree_host) override;
bool Update() override;
bool IsSnapped() override;
void PushPropertiesTo(LayerImpl* layer) override;
explicit TextureLayer(TextureLayerClient* client);
~TextureLayer() override;
bool HasDrawableContent() const override;
void SetTextureMailboxInternal(
const TextureMailbox& mailbox,
std::unique_ptr<SingleReleaseCallback> release_callback,
bool requires_commit,
bool allow_mailbox_reuse);
TextureLayerClient* client_;
bool flipped_;
bool nearest_neighbor_;
gfx::PointF uv_top_left_;
gfx::PointF uv_bottom_right_;
// [bottom left, top left, top right, bottom right]
float vertex_opacity_[4];
bool premultiplied_alpha_;
bool blend_background_color_;
std::unique_ptr<TextureMailboxHolder::MainThreadReference> holder_ref_;
bool needs_set_mailbox_;
} // namespace cc