cc: Remove TextureLayer::SetTextureId and TextureLayer::WillModifyTexture

cc/layers/texture_layer.cc

 // 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 "cc/layers/texture_layer.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "cc/layers/texture_layer_client.h"
@@ skipping 15 matching lines @@
 TextureLayer::TextureLayer(TextureLayerClient* client, bool uses_mailbox)
     : Layer(),
       client_(client),
       uses_mailbox_(uses_mailbox),
       flipped_(true),
       uv_top_left_(0.f, 0.f),
       uv_bottom_right_(1.f, 1.f),
       premultiplied_alpha_(true),
       blend_background_color_(false),
       rate_limit_context_(false),
-      content_committed_(false),
+      impl_may_draw_client_data_(false),
       texture_id_(0),
       needs_set_mailbox_(false) {
   vertex_opacity_[0] = 1.0f;
   vertex_opacity_[1] = 1.0f;
   vertex_opacity_[2] = 1.0f;
   vertex_opacity_[3] = 1.0f;
 }
 
 TextureLayer::~TextureLayer() {
 }

[danakj, 2013/07/15 23:25:05]

Should we ClearClient() in here? Or DCHECK that it was already done?

[piman, 2013/07/16 00:03:12]

We don't need to, we know we've been removed from the tree, which means we'll
have called SetLayerTreeHost(NULL) (asserted in layer.cc) which will have sync'd
with the impl thread.

[danakj, 2013/07/16 00:03:53]

Ah, okay cool thanks.

 
 void TextureLayer::ClearClient() {
   if (rate_limit_context_ && client_ && layer_tree_host())
     layer_tree_host()->StopRateLimiter(client_->Context3d());
   client_ = NULL;
-  if (uses_mailbox_)
+  ClearTexture();
+}
+
+void TextureLayer::ClearTexture() {
+  if (impl_may_draw_client_data_) {
+    DCHECK(layer_tree_host());
+    layer_tree_host()->AcquireLayerTextures();
+    impl_may_draw_client_data_ = false;
+  }
+  if (uses_mailbox_) {
     SetTextureMailbox(TextureMailbox());
-  else
-    SetTextureId(0);
+  } else {
+    texture_id_ = 0;
+    SetNeedsCommit();
+  }
 }
 
 scoped_ptr<LayerImpl> TextureLayer::CreateLayerImpl(LayerTreeImpl* tree_impl) {
   return TextureLayerImpl::Create(tree_impl, id(), uses_mailbox_).
       PassAs<LayerImpl>();
 }
 
 void TextureLayer::SetFlipped(bool flipped) {
   if (flipped_ == flipped)
     return;
@@ skipping 43 matching lines @@
   SetNeedsCommit();
 }
 
 void TextureLayer::SetRateLimitContext(bool rate_limit) {
   if (!rate_limit && rate_limit_context_ && client_ && layer_tree_host())
     layer_tree_host()->StopRateLimiter(client_->Context3d());
 
   rate_limit_context_ = rate_limit;
 }
 
-void TextureLayer::SetTextureId(unsigned id) {
-  DCHECK(!uses_mailbox_);
-  if (texture_id_ == id)
-    return;
-  if (texture_id_ && layer_tree_host())
-    layer_tree_host()->AcquireLayerTextures();
-  texture_id_ = id;
-  SetNeedsCommit();
-}
-
 void TextureLayer::SetTextureMailbox(const TextureMailbox& mailbox) {
   DCHECK(uses_mailbox_);
   DCHECK(!mailbox.IsValid() || !holder_ref_ ||
          !mailbox.Equals(holder_ref_->holder()->mailbox()));
   // If we never commited the mailbox, we need to release it here.
   if (mailbox.IsValid())
     holder_ref_ = MailboxHolder::Create(mailbox);
   else
     holder_ref_.reset();
   needs_set_mailbox_ = true;
   SetNeedsCommit();
 }
 
-void TextureLayer::WillModifyTexture() {
-  if (layer_tree_host() && (DrawsContent() || content_committed_)) {
-    layer_tree_host()->AcquireLayerTextures();
-    content_committed_ = false;
-  }
-}
-
 void TextureLayer::SetNeedsDisplayRect(const gfx::RectF& dirty_rect) {
   Layer::SetNeedsDisplayRect(dirty_rect);
 
   if (rate_limit_context_ && client_ && layer_tree_host() && DrawsContent())
     layer_tree_host()->StartRateLimiter(client_->Context3d());
 }
 
 void TextureLayer::SetLayerTreeHost(LayerTreeHost* host) {
   if (layer_tree_host() == host) {
     Layer::SetLayerTreeHost(host);
     return;
   }
 
   if (layer_tree_host()) {
-    if (texture_id_)
+    if (impl_may_draw_client_data_) {
       layer_tree_host()->AcquireLayerTextures();
+      impl_may_draw_client_data_ = false;
+    }
     if (rate_limit_context_ && client_)
       layer_tree_host()->StopRateLimiter(client_->Context3d());
   }
   // If we're removed from the tree, the TextureLayerImpl will be destroyed, and
   // we will need to set the mailbox again on a new TextureLayerImpl the next
   // time we push.
   if (!host && uses_mailbox_ && holder_ref_)
     needs_set_mailbox_ = true;
   Layer::SetLayerTreeHost(host);
 }
 
 bool TextureLayer::DrawsContent() const {
   return (client_ || texture_id_ || holder_ref_) && Layer::DrawsContent();
 }
 
+bool TextureLayer::DrawsClientData() const {
+  if (!Layer::DrawsContent() || !client_)
+    return false;
+  return texture_id_ || holder_ref_;
+}
+
 bool TextureLayer::Update(ResourceUpdateQueue* queue,
                           const OcclusionTracker* occlusion) {
   bool updated = false;
   if (client_) {
     if (uses_mailbox_) {
       TextureMailbox mailbox;
       if (client_->PrepareTextureMailbox(
               &mailbox, layer_tree_host()->UsingSharedMemoryResources())) {
         SetTextureMailbox(mailbox);
         updated = true;
@@ skipping 32 matching lines @@
       MailboxHolder* holder = holder_ref_->holder();
       TextureMailbox::ReleaseCallback callback =
           holder->GetCallbackForImplThread();
       texture_mailbox = holder->mailbox().CopyWithNewCallback(callback);
     }
     texture_layer->SetTextureMailbox(texture_mailbox);
     needs_set_mailbox_ = false;
   } else {
     texture_layer->set_texture_id(texture_id_);
   }
-  content_committed_ = DrawsContent();
+  impl_may_draw_client_data_ = DrawsClientData();
 }
 
 bool TextureLayer::BlocksPendingCommit() const {
   // Double-buffered texture layers need to be blocked until they can be made
   // triple-buffered.  Single-buffered layers already prevent draws, so
   // can block too for simplicity.
   return DrawsContent();
 }
 
 bool TextureLayer::CanClipSelf() const {
@@ skipping 62 matching lines @@
 }
 
 void TextureLayer::MailboxHolder::ReturnAndReleaseOnImplThread(
     unsigned sync_point, bool is_lost) {
   message_loop_->PostTask(FROM_HERE, base::Bind(
       &MailboxHolder::ReturnAndReleaseOnMainThread,
       this, sync_point, is_lost));
 }
 
 }  // namespace cc