cc/layers/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/layers/texture_layer.h"
   6
   7 #include "base/bind.h"
   8 #include "base/callback_helpers.h"
   9 #include "base/location.h"
  10 #include "base/synchronization/lock.h"
  11 #include "cc/base/simple_enclosed_region.h"
  12 #include "cc/layers/texture_layer_client.h"
  13 #include "cc/layers/texture_layer_impl.h"
  14 #include "cc/resources/single_release_callback.h"
  15 #include "cc/resources/single_release_callback_impl.h"
  16 #include "cc/trees/blocking_task_runner.h"
  17 #include "cc/trees/layer_tree_host.h"
  18
  19 namespace cc {
  20
  21 scoped_refptr<TextureLayer> TextureLayer::CreateForMailbox(
  22     TextureLayerClient* client) {
  23   return scoped_refptr<TextureLayer>(new TextureLayer(client));
  24 }
  25
  26 TextureLayer::TextureLayer(TextureLayerClient* client)
  27     : Layer(),
  28       client_(client),
  29       flipped_(true),
  30       uv_top_left_(0.f, 0.f),
  31       uv_bottom_right_(1.f, 1.f),
  32       premultiplied_alpha_(true),
  33       blend_background_color_(false),
  34       rate_limit_context_(false),
  35       needs_set_mailbox_(false) {
  36   vertex_opacity_[0] = 1.0f;
  37   vertex_opacity_[1] = 1.0f;
  38   vertex_opacity_[2] = 1.0f;
  39   vertex_opacity_[3] = 1.0f;
  40 }
  41
  42 TextureLayer::~TextureLayer() {
  43 }
  44
  45 void TextureLayer::ClearClient() {
  46   if (rate_limit_context_ && client_ && layer_tree_host())
  47     layer_tree_host()->StopRateLimiter();
  48   client_ = nullptr;
  49   ClearTexture();
  50   UpdateDrawsContent(HasDrawableContent());
  51 }
  52
  53 void TextureLayer::ClearTexture() {
  54   SetTextureMailbox(TextureMailbox(), nullptr);
  55 }
  56
  57 scoped_ptr<LayerImpl> TextureLayer::CreateLayerImpl(LayerTreeImpl* tree_impl) {
  58   return TextureLayerImpl::Create(tree_impl, id());
  59 }
  60
  61 void TextureLayer::SetFlipped(bool flipped) {
  62   if (flipped_ == flipped)
  63     return;
  64   flipped_ = flipped;
  65   SetNeedsCommit();
  66 }
  67
  68 void TextureLayer::SetUV(const gfx::PointF& top_left,
  69                          const gfx::PointF& bottom_right) {
  70   if (uv_top_left_ == top_left && uv_bottom_right_ == bottom_right)
  71     return;
  72   uv_top_left_ = top_left;
  73   uv_bottom_right_ = bottom_right;
  74   SetNeedsCommit();
  75 }
  76
  77 void TextureLayer::SetVertexOpacity(float bottom_left,
  78                                     float top_left,
  79                                     float top_right,
  80                                     float bottom_right) {
  81   // Indexing according to the quad vertex generation:
  82   // 1--2
  83   // |  |
  84   // 0--3
  85   if (vertex_opacity_[0] == bottom_left &&
  86       vertex_opacity_[1] == top_left &&
  87       vertex_opacity_[2] == top_right &&
  88       vertex_opacity_[3] == bottom_right)
  89     return;
  90   vertex_opacity_[0] = bottom_left;
  91   vertex_opacity_[1] = top_left;
  92   vertex_opacity_[2] = top_right;
  93   vertex_opacity_[3] = bottom_right;
  94   SetNeedsCommit();
  95 }
  96
  97 void TextureLayer::SetPremultipliedAlpha(bool premultiplied_alpha) {
  98   if (premultiplied_alpha_ == premultiplied_alpha)
  99     return;
 100   premultiplied_alpha_ = premultiplied_alpha;
 101   SetNeedsCommit();
 102 }
 103
 104 void TextureLayer::SetBlendBackgroundColor(bool blend) {
 105   if (blend_background_color_ == blend)
 106     return;
 107   blend_background_color_ = blend;
 108   SetNeedsCommit();
 109 }
 110
 111 void TextureLayer::SetRateLimitContext(bool rate_limit) {
 112   if (!rate_limit && rate_limit_context_ && client_ && layer_tree_host())
 113     layer_tree_host()->StopRateLimiter();
 114
 115   rate_limit_context_ = rate_limit;
 116 }
 117
 118 void TextureLayer::SetTextureMailboxInternal(
 119     const TextureMailbox& mailbox,
 120     scoped_ptr<SingleReleaseCallback> release_callback,
 121     bool requires_commit,
 122     bool allow_mailbox_reuse) {
 123   DCHECK(!mailbox.IsValid() || !holder_ref_ ||
 124          !mailbox.Equals(holder_ref_->holder()->mailbox()) ||
 125          allow_mailbox_reuse);
 126   DCHECK_EQ(mailbox.IsValid(), !!release_callback);
 127
 128   // If we never commited the mailbox, we need to release it here.
 129   if (mailbox.IsValid()) {
 130     holder_ref_ =
 131         TextureMailboxHolder::Create(mailbox, release_callback.Pass());
 132   } else {
 133     holder_ref_ = nullptr;
 134   }
 135   needs_set_mailbox_ = true;
 136   // If we are within a commit, no need to do it again immediately after.
 137   if (requires_commit)
 138     SetNeedsCommit();
 139   else
 140     SetNeedsPushProperties();
 141
 142   UpdateDrawsContent(HasDrawableContent());
 143   // The active frame needs to be replaced and the mailbox returned before the
 144   // commit is called complete.
 145   SetNextCommitWaitsForActivation();
 146 }
 147
 148 void TextureLayer::SetTextureMailbox(
 149     const TextureMailbox& mailbox,
 150     scoped_ptr<SingleReleaseCallback> release_callback) {
 151   bool requires_commit = true;
 152   bool allow_mailbox_reuse = false;
 153   SetTextureMailboxInternal(
 154       mailbox, release_callback.Pass(), requires_commit, allow_mailbox_reuse);
 155 }
 156
 157 static void IgnoreReleaseCallback(uint32 sync_point, bool lost) {}
 158
 159 void TextureLayer::SetTextureMailboxWithoutReleaseCallback(
 160     const TextureMailbox& mailbox) {
 161   // We allow reuse of the mailbox if there is a new sync point signalling new
 162   // content, and the release callback goes nowhere since we'll be calling it
 163   // multiple times for the same mailbox.
 164   DCHECK(!mailbox.IsValid() || !holder_ref_ ||
 165          !mailbox.Equals(holder_ref_->holder()->mailbox()) ||
 166          mailbox.sync_point() != holder_ref_->holder()->mailbox().sync_point());
 167   scoped_ptr<SingleReleaseCallback> release;
 168   bool requires_commit = true;
 169   bool allow_mailbox_reuse = true;
 170   if (mailbox.IsValid())
 171     release = SingleReleaseCallback::Create(base::Bind(&IgnoreReleaseCallback));
 172   SetTextureMailboxInternal(
 173       mailbox, release.Pass(), requires_commit, allow_mailbox_reuse);
 174 }
 175
 176 void TextureLayer::SetNeedsDisplayRect(const gfx::Rect& dirty_rect) {
 177   Layer::SetNeedsDisplayRect(dirty_rect);
 178
 179   if (rate_limit_context_ && client_ && layer_tree_host() && DrawsContent())
 180     layer_tree_host()->StartRateLimiter();
 181 }
 182
 183 void TextureLayer::SetLayerTreeHost(LayerTreeHost* host) {
 184   if (layer_tree_host() == host) {
 185     Layer::SetLayerTreeHost(host);
 186     return;
 187   }
 188
 189   if (layer_tree_host()) {
 190     if (rate_limit_context_ && client_)
 191       layer_tree_host()->StopRateLimiter();
 192   }
 193   // If we're removed from the tree, the TextureLayerImpl will be destroyed, and
 194   // we will need to set the mailbox again on a new TextureLayerImpl the next
 195   // time we push.
 196   if (!host && holder_ref_) {
 197     needs_set_mailbox_ = true;
 198     // The active frame needs to be replaced and the mailbox returned before the
 199     // commit is called complete.
 200     SetNextCommitWaitsForActivation();
 201   }
 202   Layer::SetLayerTreeHost(host);
 203 }
 204
 205 bool TextureLayer::HasDrawableContent() const {
 206   return (client_ || holder_ref_) && Layer::HasDrawableContent();
 207 }
 208
 209 bool TextureLayer::Update(ResourceUpdateQueue* queue,
 210                           const OcclusionTracker<Layer>* occlusion) {
 211   bool updated = Layer::Update(queue, occlusion);
 212   if (client_) {
 213     TextureMailbox mailbox;
 214     scoped_ptr<SingleReleaseCallback> release_callback;
 215     if (client_->PrepareTextureMailbox(
 216             &mailbox,
 217             &release_callback,
 218             layer_tree_host()->UsingSharedMemoryResources())) {
 219       // Already within a commit, no need to do another one immediately.
 220       bool requires_commit = false;
 221       bool allow_mailbox_reuse = false;
 222       SetTextureMailboxInternal(mailbox,
 223                                 release_callback.Pass(),
 224                                 requires_commit,
 225                                 allow_mailbox_reuse);
 226       updated = true;
 227     }
 228   }
 229
 230   // SetTextureMailbox could be called externally and the same mailbox used for
 231   // different textures.  Such callers notify this layer that the texture has
 232   // changed by calling SetNeedsDisplay, so check for that here.
 233   return updated || !update_rect_.IsEmpty();
 234 }
 235
 236 void TextureLayer::PushPropertiesTo(LayerImpl* layer) {
 237   Layer::PushPropertiesTo(layer);
 238
 239   TextureLayerImpl* texture_layer = static_cast<TextureLayerImpl*>(layer);
 240   texture_layer->SetFlipped(flipped_);
 241   texture_layer->SetUVTopLeft(uv_top_left_);
 242   texture_layer->SetUVBottomRight(uv_bottom_right_);
 243   texture_layer->SetVertexOpacity(vertex_opacity_);
 244   texture_layer->SetPremultipliedAlpha(premultiplied_alpha_);
 245   texture_layer->SetBlendBackgroundColor(blend_background_color_);
 246   if (needs_set_mailbox_) {
 247     TextureMailbox texture_mailbox;
 248     scoped_ptr<SingleReleaseCallbackImpl> release_callback_impl;
 249     if (holder_ref_) {
 250       TextureMailboxHolder* holder = holder_ref_->holder();
 251       texture_mailbox = holder->mailbox();
 252       release_callback_impl = holder->GetCallbackForImplThread();
 253     }
 254     texture_layer->SetTextureMailbox(texture_mailbox,
 255                                      release_callback_impl.Pass());
 256     needs_set_mailbox_ = false;
 257   }
 258 }
 259
 260 SimpleEnclosedRegion TextureLayer::VisibleContentOpaqueRegion() const {
 261   if (contents_opaque())
 262     return SimpleEnclosedRegion(visible_content_rect());
 263
 264   if (blend_background_color_ && (SkColorGetA(background_color()) == 0xFF))
 265     return SimpleEnclosedRegion(visible_content_rect());
 266
 267   return SimpleEnclosedRegion();
 268 }
 269
 270 TextureLayer::TextureMailboxHolder::MainThreadReference::MainThreadReference(
 271     TextureMailboxHolder* holder)
 272     : holder_(holder) {
 273   holder_->InternalAddRef();
 274 }
 275
 276 TextureLayer::TextureMailboxHolder::MainThreadReference::
 277     ~MainThreadReference() {
 278   holder_->InternalRelease();
 279 }
 280
 281 TextureLayer::TextureMailboxHolder::TextureMailboxHolder(
 282     const TextureMailbox& mailbox,
 283     scoped_ptr<SingleReleaseCallback> release_callback)
 284     : internal_references_(0),
 285       mailbox_(mailbox),
 286       release_callback_(release_callback.Pass()),
 287       sync_point_(mailbox.sync_point()),
 288       is_lost_(false) {
 289 }
 290
 291 TextureLayer::TextureMailboxHolder::~TextureMailboxHolder() {
 292   DCHECK_EQ(0u, internal_references_);
 293 }
 294
 295 scoped_ptr<TextureLayer::TextureMailboxHolder::MainThreadReference>
 296 TextureLayer::TextureMailboxHolder::Create(
 297     const TextureMailbox& mailbox,
 298     scoped_ptr<SingleReleaseCallback> release_callback) {
 299   return make_scoped_ptr(new MainThreadReference(
 300       new TextureMailboxHolder(mailbox, release_callback.Pass())));
 301 }
 302
 303 void TextureLayer::TextureMailboxHolder::Return(uint32 sync_point,
 304                                                 bool is_lost) {
 305   base::AutoLock lock(arguments_lock_);
 306   sync_point_ = sync_point;
 307   is_lost_ = is_lost;
 308 }
 309
 310 scoped_ptr<SingleReleaseCallbackImpl>
 311 TextureLayer::TextureMailboxHolder::GetCallbackForImplThread() {
 312   // We can't call GetCallbackForImplThread if we released the main thread
 313   // reference.
 314   DCHECK_GT(internal_references_, 0u);
 315   InternalAddRef();
 316   return SingleReleaseCallbackImpl::Create(
 317       base::Bind(&TextureMailboxHolder::ReturnAndReleaseOnImplThread, this));
 318 }
 319
 320 void TextureLayer::TextureMailboxHolder::InternalAddRef() {
 321   ++internal_references_;
 322 }
 323
 324 void TextureLayer::TextureMailboxHolder::InternalRelease() {
 325   DCHECK(main_thread_checker_.CalledOnValidThread());
 326   if (!--internal_references_) {
 327     release_callback_->Run(sync_point_, is_lost_);
 328     mailbox_ = TextureMailbox();
 329     release_callback_ = nullptr;
 330   }
 331 }
 332
 333 void TextureLayer::TextureMailboxHolder::ReturnAndReleaseOnImplThread(
 334     uint32 sync_point,
 335     bool is_lost,
 336     BlockingTaskRunner* main_thread_task_runner) {
 337   Return(sync_point, is_lost);
 338   main_thread_task_runner->PostTask(
 339       FROM_HERE, base::Bind(&TextureMailboxHolder::InternalRelease, this));
 340 }
 341
 342 }  // namespace cc