cc/texture_layer.cc

   1 // Copyright 2010 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "cc/texture_layer.h"
   6
   7 #include "cc/layer_tree_host.h"
   8 #include "cc/texture_layer_client.h"
   9 #include "cc/texture_layer_impl.h"
  10 #include "cc/thread.h"
  11 #include "third_party/WebKit/Source/Platform/chromium/public/WebGraphicsContext3D.h"
  12
  13 namespace cc {
  14
  15 static void runCallbackOnMainThread(const TextureMailbox::ReleaseCallback& callback, unsigned syncPoint)
  16 {
  17     callback.Run(syncPoint);
  18 }
  19
  20 static void postCallbackToMainThread(Thread *mainThread, const TextureMailbox::ReleaseCallback& callback, unsigned syncPoint)
  21 {
  22     mainThread->postTask(base::Bind(&runCallbackOnMainThread, callback, syncPoint));
  23 }
  24
  25 scoped_refptr<TextureLayer> TextureLayer::create(TextureLayerClient* client)
  26 {
  27     return scoped_refptr<TextureLayer>(new TextureLayer(client, false));
  28 }
  29
  30 scoped_refptr<TextureLayer> TextureLayer::createForMailbox()
  31 {
  32     return scoped_refptr<TextureLayer>(new TextureLayer(0, true));
  33 }
  34
  35 TextureLayer::TextureLayer(TextureLayerClient* client, bool usesMailbox)
  36     : Layer()
  37     , m_client(client)
  38     , m_usesMailbox(usesMailbox)
  39     , m_flipped(true)
  40     , m_uvTopLeft(0.f, 0.f)
  41     , m_uvBottomRight(1.f, 1.f)
  42     , m_premultipliedAlpha(true)
  43     , m_rateLimitContext(false)
  44     , m_contextLost(false)
  45     , m_textureId(0)
  46     , m_contentCommitted(false)
  47 {
  48   m_vertexOpacity[0] = 1.0f;
  49   m_vertexOpacity[1] = 1.0f;
  50   m_vertexOpacity[2] = 1.0f;
  51   m_vertexOpacity[3] = 1.0f;
  52 }
  53
  54 TextureLayer::~TextureLayer()
  55 {
  56     if (layerTreeHost()) {
  57         if (m_textureId)
  58             layerTreeHost()->acquireLayerTextures();
  59         if (m_rateLimitContext && m_client)
  60             layerTreeHost()->stopRateLimiter(m_client->context());
  61     }
  62     if (!m_contentCommitted)
  63         m_textureMailbox.RunReleaseCallback(m_textureMailbox.sync_point());
  64 }
  65
  66 scoped_ptr<LayerImpl> TextureLayer::createLayerImpl(LayerTreeImpl* treeImpl)
  67 {
  68     return TextureLayerImpl::create(treeImpl, m_layerId, m_usesMailbox).PassAs<LayerImpl>();
  69 }
  70
  71 void TextureLayer::setFlipped(bool flipped)
  72 {
  73     m_flipped = flipped;
  74     setNeedsCommit();
  75 }
  76
  77 void TextureLayer::setUV(gfx::PointF topLeft, gfx::PointF bottomRight)
  78 {
  79     m_uvTopLeft = topLeft;
  80     m_uvBottomRight = bottomRight;
  81     setNeedsCommit();
  82 }
  83
  84 void TextureLayer::setVertexOpacity(float bottomLeft,
  85                                     float topLeft,
  86                                     float topRight,
  87                                     float bottomRight) {
  88   // Indexing according to the quad vertex generation:
  89   // 1--2
  90   // |  |
  91   // 0--3
  92   m_vertexOpacity[0] = bottomLeft;
  93   m_vertexOpacity[1] = topLeft;
  94   m_vertexOpacity[2] = topRight;
  95   m_vertexOpacity[3] = bottomRight;
  96   setNeedsCommit();
  97 }
  98
  99 void TextureLayer::setPremultipliedAlpha(bool premultipliedAlpha)
 100 {
 101     m_premultipliedAlpha = premultipliedAlpha;
 102     setNeedsCommit();
 103 }
 104
 105 void TextureLayer::setRateLimitContext(bool rateLimit)
 106 {
 107     if (!rateLimit && m_rateLimitContext && m_client && layerTreeHost())
 108         layerTreeHost()->stopRateLimiter(m_client->context());
 109
 110     m_rateLimitContext = rateLimit;
 111 }
 112
 113 void TextureLayer::setTextureId(unsigned id)
 114 {
 115     DCHECK(!m_usesMailbox);
 116     if (m_textureId == id)
 117         return;
 118     if (m_textureId && layerTreeHost())
 119         layerTreeHost()->acquireLayerTextures();
 120     m_textureId = id;
 121     setNeedsCommit();
 122 }
 123
 124 void TextureLayer::setTextureMailbox(const TextureMailbox& mailbox)
 125 {
 126     DCHECK(m_usesMailbox);
 127     if (m_textureMailbox.Equals(mailbox))
 128         return;
 129     // If we never commited the mailbox, we need to release it here
 130     if (!m_contentCommitted)
 131         m_textureMailbox.RunReleaseCallback(m_textureMailbox.sync_point());
 132     m_textureMailbox = mailbox;
 133
 134     setNeedsCommit();
 135 }
 136
 137 void TextureLayer::willModifyTexture()
 138 {
 139     if (layerTreeHost() && (drawsContent() || m_contentCommitted)) {
 140         layerTreeHost()->acquireLayerTextures();
 141         m_contentCommitted = false;
 142     }
 143 }
 144
 145 void TextureLayer::setNeedsDisplayRect(const gfx::RectF& dirtyRect)
 146 {
 147     Layer::setNeedsDisplayRect(dirtyRect);
 148
 149     if (m_rateLimitContext && m_client && layerTreeHost() && drawsContent())
 150         layerTreeHost()->startRateLimiter(m_client->context());
 151 }
 152
 153 void TextureLayer::setLayerTreeHost(LayerTreeHost* host)
 154 {
 155     if (m_textureId && layerTreeHost() && host != layerTreeHost())
 156         layerTreeHost()->acquireLayerTextures();
 157     Layer::setLayerTreeHost(host);
 158 }
 159
 160 bool TextureLayer::drawsContent() const
 161 {
 162     return (m_client || m_textureId || !m_textureMailbox.IsEmpty()) && !m_contextLost && Layer::drawsContent();
 163 }
 164
 165 void TextureLayer::update(ResourceUpdateQueue& queue, const OcclusionTracker*, RenderingStats*)
 166 {
 167     if (m_client) {
 168         m_textureId = m_client->prepareTexture(queue);
 169         m_contextLost = m_client->context()->getGraphicsResetStatusARB() != GL_NO_ERROR;
 170     }
 171
 172     m_needsDisplay = false;
 173 }
 174
 175 void TextureLayer::pushPropertiesTo(LayerImpl* layer)
 176 {
 177     Layer::pushPropertiesTo(layer);
 178
 179     TextureLayerImpl* textureLayer = static_cast<TextureLayerImpl*>(layer);
 180     textureLayer->setFlipped(m_flipped);
 181     textureLayer->setUVTopLeft(m_uvTopLeft);
 182     textureLayer->setUVBottomRight(m_uvBottomRight);
 183     textureLayer->setVertexOpacity(m_vertexOpacity);
 184     textureLayer->setPremultipliedAlpha(m_premultipliedAlpha);
 185     if (m_usesMailbox) {
 186         Thread* mainThread = layerTreeHost()->proxy()->mainThread();
 187         TextureMailbox::ReleaseCallback callback;
 188         if (!m_textureMailbox.IsEmpty())
 189           callback = base::Bind(&postCallbackToMainThread, mainThread, m_textureMailbox.callback());
 190         textureLayer->setTextureMailbox(TextureMailbox(m_textureMailbox.name(), callback, m_textureMailbox.sync_point()));
 191     } else {
 192         textureLayer->setTextureId(m_textureId);
 193     }
 194     m_contentCommitted = drawsContent();
 195 }
 196
 197 bool TextureLayer::blocksPendingCommit() const
 198 {
 199     // Double-buffered texture layers need to be blocked until they can be made
 200     // triple-buffered.  Single-buffered layers already prevent draws, so
 201     // can block too for simplicity.
 202     return drawsContent();
 203 }
 204
 205 bool TextureLayer::canClipSelf() const
 206 {
 207     return true;
 208 }
 209
 210 }  // namespace cc