Remove old texture path in TextureLayer

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/callback_helpers.h"
 #include "base/location.h"
 #include "base/synchronization/lock.h"
 #include "cc/layers/texture_layer_client.h"
 #include "cc/layers/texture_layer_impl.h"
 #include "cc/resources/single_release_callback.h"
 #include "cc/trees/blocking_task_runner.h"
 #include "cc/trees/layer_tree_host.h"
 
 namespace cc {
 
-scoped_refptr<TextureLayer> TextureLayer::Create(TextureLayerClient* client) {
-  return scoped_refptr<TextureLayer>(new TextureLayer(client, false));
+scoped_refptr<TextureLayer> TextureLayer::CreateForMailbox(
+    TextureLayerClient* client) {
+  return scoped_refptr<TextureLayer>(new TextureLayer(client));
 }
 
-scoped_refptr<TextureLayer> TextureLayer::CreateForMailbox(
-    TextureLayerClient* client) {
-  return scoped_refptr<TextureLayer>(new TextureLayer(client, true));
-}
-
-TextureLayer::TextureLayer(TextureLayerClient* client, bool uses_mailbox)
+TextureLayer::TextureLayer(TextureLayerClient* client)
     : 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),
-      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() {
 }
 
 void TextureLayer::ClearClient() {
   if (rate_limit_context_ && client_ && layer_tree_host())
     layer_tree_host()->StopRateLimiter();
   client_ = NULL;
   ClearTexture();
 }
 
 void TextureLayer::ClearTexture() {
-  if (uses_mailbox_) {
-    SetTextureMailbox(TextureMailbox(), scoped_ptr<SingleReleaseCallback>());
-  } else if (texture_id_) {
-    if (impl_may_draw_client_data_) {
-      DCHECK(layer_tree_host());
-      layer_tree_host()->AcquireLayerTextures();
-      impl_may_draw_client_data_ = false;
-    }
-    texture_id_ = 0;
-    SetNeedsCommit();
-    // The texture id needs to be removed from the active tree before the
-    // commit is called complete.
-    SetNextCommitWaitsForActivation();
-  }
+  SetTextureMailbox(TextureMailbox(), scoped_ptr<SingleReleaseCallback>());
 }
 
 scoped_ptr<LayerImpl> TextureLayer::CreateLayerImpl(LayerTreeImpl* tree_impl) {
-  return TextureLayerImpl::Create(tree_impl, id(), uses_mailbox_).
-      PassAs<LayerImpl>();
+  return TextureLayerImpl::Create(tree_impl, id()).PassAs<LayerImpl>();
 }
 
 void TextureLayer::SetFlipped(bool flipped) {
   if (flipped_ == flipped)
     return;
   flipped_ = flipped;
   SetNeedsCommit();
 }
 
 void TextureLayer::SetUV(const gfx::PointF& top_left,
@@ skipping 44 matching lines @@
     layer_tree_host()->StopRateLimiter();
 
   rate_limit_context_ = rate_limit;
 }
 
 void TextureLayer::SetTextureMailboxInternal(
     const TextureMailbox& mailbox,
     scoped_ptr<SingleReleaseCallback> release_callback,
     bool requires_commit,
     bool allow_mailbox_reuse) {
-  DCHECK(uses_mailbox_);
   DCHECK(!mailbox.IsValid() || !holder_ref_ ||
          !mailbox.Equals(holder_ref_->holder()->mailbox()) ||
          allow_mailbox_reuse);
   DCHECK_EQ(mailbox.IsValid(), !!release_callback);
 
   // If we never commited the mailbox, we need to release it here.
   if (mailbox.IsValid()) {
     holder_ref_ =
         TextureMailboxHolder::Create(mailbox, release_callback.Pass());
   } else {
@@ skipping 46 matching lines @@
     layer_tree_host()->StartRateLimiter();
 }
 
 void TextureLayer::SetLayerTreeHost(LayerTreeHost* host) {
   if (layer_tree_host() == host) {
     Layer::SetLayerTreeHost(host);
     return;
   }
 
   if (layer_tree_host()) {
-    if (impl_may_draw_client_data_) {
-      layer_tree_host()->AcquireLayerTextures();
-      // The texture id needs to be removed from the active tree before the
-      // commit is called complete.
-      SetNextCommitWaitsForActivation();
-      impl_may_draw_client_data_ = false;
-    }
     if (rate_limit_context_ && client_)
       layer_tree_host()->StopRateLimiter();
   }
   // 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_) {
+  if (!host && holder_ref_) {
     needs_set_mailbox_ = true;
     // The active frame needs to be replaced and the mailbox returned before the
     // commit is called complete.
     SetNextCommitWaitsForActivation();
   }
   Layer::SetLayerTreeHost(host);
 }
 
 bool TextureLayer::DrawsContent() const {
-  return (client_ || texture_id_ || holder_ref_) && Layer::DrawsContent();
+  return (client_ || holder_ref_) && Layer::DrawsContent();
 }
 
 bool TextureLayer::Update(ResourceUpdateQueue* queue,
                           const OcclusionTracker<Layer>* occlusion) {
   bool updated = Layer::Update(queue, occlusion);
   if (client_) {
-    if (uses_mailbox_) {
-      TextureMailbox mailbox;
-      scoped_ptr<SingleReleaseCallback> release_callback;
-      if (client_->PrepareTextureMailbox(
-              &mailbox,
-              &release_callback,
-              layer_tree_host()->UsingSharedMemoryResources())) {
-        // Already within a commit, no need to do another one immediately.
-        bool requires_commit = false;
-        bool allow_mailbox_reuse = false;
-        SetTextureMailboxInternal(mailbox,
-                                  release_callback.Pass(),
-                                  requires_commit,
-                                  allow_mailbox_reuse);
-        updated = true;
-      }
-    } else {
-      texture_id_ = client_->PrepareTexture();
+    TextureMailbox mailbox;
+    scoped_ptr<SingleReleaseCallback> release_callback;
+    if (client_->PrepareTextureMailbox(
+            &mailbox,
+            &release_callback,
+            layer_tree_host()->UsingSharedMemoryResources())) {
+      // Already within a commit, no need to do another one immediately.
+      bool requires_commit = false;
+      bool allow_mailbox_reuse = false;
+      SetTextureMailboxInternal(mailbox,
+                                release_callback.Pass(),
+                                requires_commit,
+                                allow_mailbox_reuse);
       updated = true;
-      SetNeedsPushProperties();
-      // The texture id needs to be removed from the active tree before the
-      // commit is called complete.
-      SetNextCommitWaitsForActivation();
     }
   }
 
   // SetTextureMailbox could be called externally and the same mailbox used for
   // different textures.  Such callers notify this layer that the texture has
   // changed by calling SetNeedsDisplay, so check for that here.
   return updated || !update_rect_.IsEmpty();
 }
 
 void TextureLayer::PushPropertiesTo(LayerImpl* layer) {
   Layer::PushPropertiesTo(layer);
 
   TextureLayerImpl* texture_layer = static_cast<TextureLayerImpl*>(layer);
   texture_layer->SetFlipped(flipped_);
   texture_layer->SetUVTopLeft(uv_top_left_);
   texture_layer->SetUVBottomRight(uv_bottom_right_);
   texture_layer->SetVertexOpacity(vertex_opacity_);
   texture_layer->SetPremultipliedAlpha(premultiplied_alpha_);
   texture_layer->SetBlendBackgroundColor(blend_background_color_);
-  if (uses_mailbox_ && needs_set_mailbox_) {
+  if (needs_set_mailbox_) {
     TextureMailbox texture_mailbox;
     scoped_ptr<SingleReleaseCallback> release_callback;
     if (holder_ref_) {
       TextureMailboxHolder* holder = holder_ref_->holder();
       texture_mailbox = holder->mailbox();
       release_callback = holder->GetCallbackForImplThread();
     }
     texture_layer->SetTextureMailbox(texture_mailbox, release_callback.Pass());
     needs_set_mailbox_ = false;
-  } else {
-    texture_layer->SetTextureId(texture_id_);
-    impl_may_draw_client_data_ = texture_id_ && Layer::DrawsContent();
   }
 }
 
 Region TextureLayer::VisibleContentOpaqueRegion() const {
   if (contents_opaque())
     return visible_content_rect();
 
   if (blend_background_color_ && (SkColorGetA(background_color()) == 0xFF))
     return visible_content_rect();
 
@@ skipping 65 matching lines @@
 
 void TextureLayer::TextureMailboxHolder::ReturnAndReleaseOnImplThread(
     uint32 sync_point,
     bool is_lost) {
   Return(sync_point, is_lost);
   message_loop_->PostTask(
       FROM_HERE, base::Bind(&TextureMailboxHolder::InternalRelease, this));
 }
 
 }  // namespace cc