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
|
// 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.
#ifndef CC_LAYERS_TEXTURE_LAYER_H_
#define CC_LAYERS_TEXTURE_LAYER_H_
#include <string>
#include "base/callback.h"
#include "base/synchronization/lock.h"
#include "cc/base/cc_export.h"
#include "cc/layers/layer.h"
#include "cc/resources/texture_mailbox.h"
namespace cc {
class BlockingTaskRunner;
class SingleReleaseCallback;
class TextureLayerClient;
// A Layer containing a the rendered output of a plugin instance.
class CC_EXPORT TextureLayer : public Layer {
public:
class CC_EXPORT MailboxHolder
: public base::RefCountedThreadSafe<MailboxHolder> {
public:
class CC_EXPORT MainThreadReference {
public:
explicit MainThreadReference(MailboxHolder* holder);
~MainThreadReference();
MailboxHolder* holder() { return holder_.get(); }
private:
scoped_refptr<MailboxHolder> holder_;
DISALLOW_COPY_AND_ASSIGN(MainThreadReference);
};
const TextureMailbox& mailbox() const { return mailbox_; }
void Return(unsigned sync_point, bool is_lost);
// Gets a ReleaseCallback that can be called from another thread. Note: the
// caller must ensure the callback is called.
scoped_ptr<SingleReleaseCallback> GetCallbackForImplThread();
protected:
friend class TextureLayer;
// Protected visiblity so only TextureLayer and unit tests can create these.
static scoped_ptr<MainThreadReference> Create(
const TextureMailbox& mailbox,
scoped_ptr<SingleReleaseCallback> release_callback);
virtual ~MailboxHolder();
private:
friend class base::RefCountedThreadSafe<MailboxHolder>;
friend class MainThreadReference;
explicit MailboxHolder(const TextureMailbox& mailbox,
scoped_ptr<SingleReleaseCallback> release_callback);
void InternalAddRef();
void InternalRelease();
void ReturnAndReleaseOnImplThread(unsigned sync_point, bool is_lost);
// This member is thread safe, and is accessed on main and impl threads.
const scoped_refptr<BlockingTaskRunner> message_loop_;
// 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_;
scoped_ptr<SingleReleaseCallback> release_callback_;
// This lock guards the sync_point_ 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_;
unsigned sync_point_;
bool is_lost_;
DISALLOW_COPY_AND_ASSIGN(MailboxHolder);
};
// If this texture layer requires special preparation logic for each frame
// driven by the compositor, pass in a non-nil client. Pass in a nil client
// pointer if texture updates are driven by an external process.
static scoped_refptr<TextureLayer> Create(TextureLayerClient* client);
// Used when mailbox names are specified instead of texture IDs.
static scoped_refptr<TextureLayer> CreateForMailbox(
TextureLayerClient* client);
void ClearClient();
virtual scoped_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);
// Sets a UV transform to be used at draw time. Defaults to (0, 0) and (1, 1).
void SetUV(gfx::PointF top_left, 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);
// Sets whether this context should rate limit on damage to prevent too many
// frames from being queued up before the compositor gets a chance to run.
// Requires a non-nil client. Defaults to false.
void SetRateLimitContext(bool rate_limit);
// Code path for plugins which supply their own texture ID.
// DEPRECATED. DO NOT USE.
void SetTextureId(unsigned texture_id);
// Code path for plugins which supply their own mailbox.
bool uses_mailbox() const { return uses_mailbox_; }
void SetTextureMailbox(const TextureMailbox& mailbox,
scoped_ptr<SingleReleaseCallback> release_callback);
void WillModifyTexture();
virtual void SetNeedsDisplayRect(const gfx::RectF& dirty_rect) OVERRIDE;
virtual void SetLayerTreeHost(LayerTreeHost* layer_tree_host) OVERRIDE;
virtual bool DrawsContent() const OVERRIDE;
virtual bool Update(ResourceUpdateQueue* queue,
const OcclusionTracker* occlusion) OVERRIDE;
virtual void PushPropertiesTo(LayerImpl* layer) OVERRIDE;
virtual Region VisibleContentOpaqueRegion() const OVERRIDE;
protected:
TextureLayer(TextureLayerClient* client, bool uses_mailbox);
virtual ~TextureLayer();
private:
void SetTextureMailboxInternal(
const TextureMailbox& mailbox,
scoped_ptr<SingleReleaseCallback> release_callback,
bool requires_commit);
TextureLayerClient* client_;
bool uses_mailbox_;
bool flipped_;
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_;
bool rate_limit_context_;
bool content_committed_;
unsigned texture_id_;
scoped_ptr<MailboxHolder::MainThreadReference> holder_ref_;
bool needs_set_mailbox_;
DISALLOW_COPY_AND_ASSIGN(TextureLayer);
};
} // namespace cc
#endif // CC_LAYERS_TEXTURE_LAYER_H_
|
