Revert 212008 "cc: Remove TextureLayer::SetTextureId and Texture..."

Temporary revert of this as Android Build Sheriff until the
Android UI stops using SetTextureId. Needed since it is currently
impossible to roll the version of chromium used by Android past
this change.
> cc: Remove TextureLayer::SetTextureId and TextureLayer::WillModifyTexture
> 
> These are not used anymore except for clearing the client-provided texture, so
> this removes 1 of 4 TextureLayer paths, and implifies externally-exposed state.
> 
> BUG=None
> 
> Review URL: https://chromiumcodereview.appspot.com/19303003

BUG=261151
TBR=piman@chromium.org

Review URL: https://codereview.chromium.org/19463010

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@212321 0039d316-1c4b-4281-b951-d872f2087c98

3 files changed, 152 insertions, 254 deletions

diff --git a/cc/layers/texture_layer.cc b/cc/layers/texture_layer.cc
index 6f1772d..5e68802 100644
--- a/cc/layers/texture_layer.cc
+++ b/cc/layers/texture_layer.cc
@@ -33,7 +33,7 @@ TextureLayer::TextureLayer(TextureLayerClient* client, bool uses_mailbox)
       premultiplied_alpha_(true),
       blend_background_color_(false),
       rate_limit_context_(false),
-      impl_may_draw_client_data_(false),
+      content_committed_(false),
       texture_id_(0),
       needs_set_mailbox_(false) {
   vertex_opacity_[0] = 1.0f;
@@ -49,21 +49,10 @@ void TextureLayer::ClearClient() {
   if (rate_limit_context_ && client_ && layer_tree_host())
     layer_tree_host()->StopRateLimiter(client_->Context3d());
   client_ = NULL;
-  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_) {
+  if (uses_mailbox_)
     SetTextureMailbox(TextureMailbox());
-  } else {
-    texture_id_ = 0;
-    SetNeedsCommit();
-  }
+  else
+    SetTextureId(0);
 }
 
 scoped_ptr<LayerImpl> TextureLayer::CreateLayerImpl(LayerTreeImpl* tree_impl) {
@@ -127,6 +116,16 @@ void TextureLayer::SetRateLimitContext(bool rate_limit) {
   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_ ||
@@ -140,6 +139,13 @@ void TextureLayer::SetTextureMailbox(const TextureMailbox& mailbox) {
   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);
 
@@ -154,10 +160,8 @@ void TextureLayer::SetLayerTreeHost(LayerTreeHost* host) {
   }
 
   if (layer_tree_host()) {
-    if (impl_may_draw_client_data_) {
+    if (texture_id_)
       layer_tree_host()->AcquireLayerTextures();
-      impl_may_draw_client_data_ = false;
-    }
     if (rate_limit_context_ && client_)
       layer_tree_host()->StopRateLimiter(client_->Context3d());
   }
@@ -173,12 +177,6 @@ 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;
@@ -231,7 +229,7 @@ void TextureLayer::PushPropertiesTo(LayerImpl* layer) {
   } else {
     texture_layer->set_texture_id(texture_id_);
   }
-  impl_may_draw_client_data_ = DrawsClientData();
+  content_committed_ = DrawsContent();
 }
 
 bool TextureLayer::BlocksPendingCommit() const {
diff --git a/cc/layers/texture_layer.h b/cc/layers/texture_layer.h
index 5e4a34f..d87a9d3 100644
--- a/cc/layers/texture_layer.h
+++ b/cc/layers/texture_layer.h
@@ -34,16 +34,8 @@ class CC_EXPORT TextureLayer : public Layer {
   static scoped_refptr<TextureLayer> CreateForMailbox(
       TextureLayerClient* client);
 
-  // Resets the client, which also resets the texture. This may synchronize with
-  // the impl thread if it is currently drawing a texture or a mailbox from the
-  // client. After this call it is safe to destroy the texture / mailbox.
   void ClearClient();
 
-  // Resets the texture. This may synchronize with the impl thread if it is
-  // currently drawing a texture or a mailbox from the client. After this call
-  // it is safe to destroy the texture / mailbox.
-  void ClearTexture();
-
   virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl)
       OVERRIDE;
 
@@ -74,10 +66,15 @@ class CC_EXPORT TextureLayer : public Layer {
   // Requires a non-nil client.  Defaults to false.
   void SetRateLimitContext(bool rate_limit);
 
+  // Code path for plugins which supply their own texture ID.
+  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);
 
+  void WillModifyTexture();
+
   virtual void SetNeedsDisplayRect(const gfx::RectF& dirty_rect) OVERRIDE;
 
   virtual void SetLayerTreeHost(LayerTreeHost* layer_tree_host) OVERRIDE;
@@ -138,10 +135,6 @@ class CC_EXPORT TextureLayer : public Layer {
     DISALLOW_COPY_AND_ASSIGN(MailboxHolder);
   };
 
-  // Returns true if we draw content coming from the client, which implies we
-  // may need to synchronize with the impl thread when the client goes away.
-  bool DrawsClientData() const;
-
   TextureLayerClient* client_;
   bool uses_mailbox_;
 
@@ -153,7 +146,7 @@ class CC_EXPORT TextureLayer : public Layer {
   bool premultiplied_alpha_;
   bool blend_background_color_;
   bool rate_limit_context_;
-  bool impl_may_draw_client_data_;
+  bool content_committed_;
 
   unsigned texture_id_;
   scoped_ptr<MailboxHolder::MainThreadReference> holder_ref_;
diff --git a/cc/layers/texture_layer_unittest.cc b/cc/layers/texture_layer_unittest.cc
index 8d4b0d4..f4482ac 100644
--- a/cc/layers/texture_layer_unittest.cc
+++ b/cc/layers/texture_layer_unittest.cc
@@ -7,7 +7,6 @@
 #include <string>
 
 #include "base/callback.h"
-#include "base/run_loop.h"
 #include "cc/layers/texture_layer_client.h"
 #include "cc/layers/texture_layer_impl.h"
 #include "cc/test/fake_impl_proxy.h"
@@ -26,7 +25,6 @@ using ::testing::Mock;
 using ::testing::_;
 using ::testing::AtLeast;
 using ::testing::AnyNumber;
-using ::testing::InvokeWithoutArgs;
 
 namespace cc {
 namespace {
@@ -44,100 +42,6 @@ class MockLayerTreeHost : public LayerTreeHost {
   MOCK_METHOD1(StopRateLimiter, void(WebKit::WebGraphicsContext3D* context));
 };
 
-class FakeTextureLayerClient : public TextureLayerClient {
- public:
-  FakeTextureLayerClient()
-      : context_(TestWebGraphicsContext3D::Create()),
-        texture_(0),
-        mailbox_changed_(true) {}
-
-  virtual unsigned PrepareTexture() OVERRIDE {
-    return texture_;
-  }
-
-  virtual WebKit::WebGraphicsContext3D* Context3d() OVERRIDE {
-    return context_.get();
-  }
-
-  virtual bool PrepareTextureMailbox(TextureMailbox* mailbox,
-                                     bool use_shared_memory) OVERRIDE {
-    if (!mailbox_changed_)
-      return false;
-
-    *mailbox = mailbox_;
-    mailbox_changed_ = false;
-    return true;
-  }
-
-  void set_texture(unsigned texture) {
-    texture_ = texture;
-  }
-
-  void set_mailbox(const TextureMailbox& mailbox) {
-    mailbox_ = mailbox;
-    mailbox_changed_ = true;
-  }
-
- private:
-  scoped_ptr<TestWebGraphicsContext3D> context_;
-  unsigned texture_;
-  TextureMailbox mailbox_;
-  bool mailbox_changed_;
-  DISALLOW_COPY_AND_ASSIGN(FakeTextureLayerClient);
-};
-
-class MockMailboxCallback {
- public:
-  MOCK_METHOD3(Release, void(const std::string& mailbox,
-                             unsigned sync_point,
-                             bool lost_resource));
-  MOCK_METHOD3(Release2, void(base::SharedMemory* shared_memory,
-                              unsigned sync_point,
-                              bool lost_resource));
-};
-
-struct CommonMailboxObjects {
-  CommonMailboxObjects()
-      : mailbox_name1_(64, '1'),
-        mailbox_name2_(64, '2'),
-        sync_point1_(1),
-        sync_point2_(2),
-        shared_memory_(new base::SharedMemory) {
-    release_mailbox1_ = base::Bind(&MockMailboxCallback::Release,
-                                   base::Unretained(&mock_callback_),
-                                   mailbox_name1_);
-    release_mailbox2_ = base::Bind(&MockMailboxCallback::Release,
-                                   base::Unretained(&mock_callback_),
-                                   mailbox_name2_);
-    gpu::Mailbox m1;
-    m1.SetName(reinterpret_cast<const int8*>(mailbox_name1_.data()));
-    mailbox1_ = TextureMailbox(m1, release_mailbox1_, sync_point1_);
-    gpu::Mailbox m2;
-    m2.SetName(reinterpret_cast<const int8*>(mailbox_name2_.data()));
-    mailbox2_ = TextureMailbox(m2, release_mailbox2_, sync_point2_);
-
-    gfx::Size size(128, 128);
-    EXPECT_TRUE(shared_memory_->CreateAndMapAnonymous(4 * size.GetArea()));
-    release_mailbox3_ = base::Bind(&MockMailboxCallback::Release2,
-                                   base::Unretained(&mock_callback_),
-                                   shared_memory_.get());
-    mailbox3_ = TextureMailbox(shared_memory_.get(), size, release_mailbox3_);
-  }
-
-  std::string mailbox_name1_;
-  std::string mailbox_name2_;
-  MockMailboxCallback mock_callback_;
-  TextureMailbox::ReleaseCallback release_mailbox1_;
-  TextureMailbox::ReleaseCallback release_mailbox2_;
-  TextureMailbox::ReleaseCallback release_mailbox3_;
-  TextureMailbox mailbox1_;
-  TextureMailbox mailbox2_;
-  TextureMailbox mailbox3_;
-  unsigned sync_point1_;
-  unsigned sync_point2_;
-  scoped_ptr<base::SharedMemory> shared_memory_;
-};
-
 class TextureLayerTest : public testing::Test {
  public:
   TextureLayerTest()
@@ -148,10 +52,7 @@ class TextureLayerTest : public testing::Test {
  protected:
   virtual void SetUp() {
     layer_tree_host_.reset(new MockLayerTreeHost(&fake_client_));
-    EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AnyNumber());
-    layer_tree_host_->SetViewportSize(gfx::Size(10, 10));
-    Mock::VerifyAndClearExpectations(layer_tree_host_.get());
-}
+  }
 
   virtual void TearDown() {
     Mock::VerifyAndClearExpectations(layer_tree_host_.get());
@@ -168,148 +69,82 @@ class TextureLayerTest : public testing::Test {
   FakeLayerTreeHostImpl host_impl_;
 };
 
-TEST_F(TextureLayerTest, SyncImplWhenClearingTexture) {
-  FakeTextureLayerClient client;
-  scoped_refptr<TextureLayer> test_layer = TextureLayer::Create(&client);
+TEST_F(TextureLayerTest, SyncImplWhenChangingTextureId) {
+  scoped_refptr<TextureLayer> test_layer = TextureLayer::Create(NULL);
   ASSERT_TRUE(test_layer.get());
-  test_layer->SetIsDrawable(true);
-  test_layer->SetBounds(gfx::Size(10, 10));
 
-  EXPECT_CALL(*layer_tree_host_, AcquireLayerTextures()).Times(0);
+  EXPECT_CALL(*layer_tree_host_, AcquireLayerTextures()).Times(AnyNumber());
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AnyNumber());
   layer_tree_host_->SetRootLayer(test_layer);
   Mock::VerifyAndClearExpectations(layer_tree_host_.get());
   EXPECT_EQ(test_layer->layer_tree_host(), layer_tree_host_.get());
 
-  // Clearing the texture before we gave one should not sync.
-  EXPECT_CALL(*layer_tree_host_, AcquireLayerTextures()).Times(0);
-  EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AnyNumber());
-  test_layer->ClearTexture();
-  Mock::VerifyAndClearExpectations(layer_tree_host_.get());
-
-  // Give a texture to the layer through the client.
   EXPECT_CALL(*layer_tree_host_, AcquireLayerTextures()).Times(0);
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AtLeast(1));
-  client.set_texture(client.Context3d()->createTexture());
-  test_layer->SetNeedsDisplay();
-  // Force a commit.
-  layer_tree_host_->Composite(base::TimeTicks());
+  test_layer->SetTextureId(1);
   Mock::VerifyAndClearExpectations(layer_tree_host_.get());
 
-  // Clearing the texture should sync.
   EXPECT_CALL(*layer_tree_host_, AcquireLayerTextures()).Times(AtLeast(1));
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AtLeast(1));
-  test_layer->ClearTexture();
-  Mock::VerifyAndClearExpectations(layer_tree_host_.get());
-
-  // But only once.
-  EXPECT_CALL(*layer_tree_host_, AcquireLayerTextures()).Times(0);
-  EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AnyNumber());
-  test_layer->ClearTexture();
-  Mock::VerifyAndClearExpectations(layer_tree_host_.get());
-
-  // Force a commit to give another texture.
-  EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AtLeast(1));
-  test_layer->SetNeedsDisplay();
-  layer_tree_host_->Composite(base::TimeTicks());
+  test_layer->SetTextureId(2);
   Mock::VerifyAndClearExpectations(layer_tree_host_.get());
 
-  // Make undrawable and commit.
+  EXPECT_CALL(*layer_tree_host_, AcquireLayerTextures()).Times(AtLeast(1));
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AtLeast(1));
-  test_layer->SetIsDrawable(false);
-  layer_tree_host_->Composite(base::TimeTicks());
-  Mock::VerifyAndClearExpectations(layer_tree_host_.get());
-
-  // Clearing textures should not sync.
-  EXPECT_CALL(*layer_tree_host_, AcquireLayerTextures()).Times(0);
-  EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AnyNumber());
-  test_layer->ClearTexture();
+  test_layer->SetTextureId(0);
   Mock::VerifyAndClearExpectations(layer_tree_host_.get());
 }
 
-TEST_F(TextureLayerTest, SyncImplWhenClearingMailbox) {
-  CommonMailboxObjects mailboxes;
-  FakeTextureLayerClient client;
-  scoped_refptr<TextureLayer> test_layer =
-      TextureLayer::CreateForMailbox(&client);
+TEST_F(TextureLayerTest, SyncImplWhenDrawing) {
+  gfx::RectF dirty_rect(0.f, 0.f, 1.f, 1.f);
+
+  scoped_refptr<TextureLayer> test_layer = TextureLayer::Create(NULL);
   ASSERT_TRUE(test_layer.get());
-  test_layer->SetIsDrawable(true);
-  test_layer->SetBounds(gfx::Size(10, 10));
-  EXPECT_CALL(*layer_tree_host_, AcquireLayerTextures()).Times(0);
+  scoped_ptr<TextureLayerImpl> impl_layer;
+  impl_layer = TextureLayerImpl::Create(host_impl_.active_tree(), 1, false);
+  ASSERT_TRUE(impl_layer);
+
+  EXPECT_CALL(*layer_tree_host_, AcquireLayerTextures()).Times(AnyNumber());
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AnyNumber());
   layer_tree_host_->SetRootLayer(test_layer);
+  test_layer->SetTextureId(1);
+  test_layer->SetIsDrawable(true);
   Mock::VerifyAndClearExpectations(layer_tree_host_.get());
   EXPECT_EQ(test_layer->layer_tree_host(), layer_tree_host_.get());
 
-  // Clearing the mailbox before we gave one should not sync.
-  EXPECT_CALL(*layer_tree_host_, AcquireLayerTextures()).Times(0);
-  EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AnyNumber());
-  test_layer->ClearTexture();
-  Mock::VerifyAndClearExpectations(layer_tree_host_.get());
-
-  // Give a mailbox to the layer through the client.
-  EXPECT_CALL(*layer_tree_host_, AcquireLayerTextures()).Times(0);
-  EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AtLeast(1));
-  client.set_mailbox(mailboxes.mailbox1_);
-  test_layer->SetNeedsDisplay();
-  // Force a commit.
-  layer_tree_host_->Composite(base::TimeTicks());
-  Mock::VerifyAndClearExpectations(layer_tree_host_.get());
-
-  // Clearing the mailbox should sync.
-  EXPECT_CALL(*layer_tree_host_, AcquireLayerTextures()).Times(AtLeast(1));
-  EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AtLeast(1));
-  test_layer->ClearTexture();
+  EXPECT_CALL(*layer_tree_host_, AcquireLayerTextures()).Times(1);
+  EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(0);
+  test_layer->WillModifyTexture();
   Mock::VerifyAndClearExpectations(layer_tree_host_.get());
 
-  // But only once.
   EXPECT_CALL(*layer_tree_host_, AcquireLayerTextures()).Times(0);
-  EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AnyNumber());
-  test_layer->ClearTexture();
+  EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(1);
+  test_layer->SetNeedsDisplayRect(dirty_rect);
   Mock::VerifyAndClearExpectations(layer_tree_host_.get());
 
-  // Force a commit to give another mailbox.
   EXPECT_CALL(*layer_tree_host_, AcquireLayerTextures()).Times(0);
-  EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AtLeast(1));
-  client.set_mailbox(mailboxes.mailbox2_);
-  test_layer->SetNeedsDisplay();
-  // Commit will return mailbox1.
-  layer_tree_host_->Composite(base::TimeTicks());
-  Mock::VerifyAndClearExpectations(layer_tree_host_.get());
-
-  // Wait for mailbox callback.
-  {
-    base::RunLoop run_loop;
-    EXPECT_CALL(mailboxes.mock_callback_,
-                Release(mailboxes.mailbox_name1_, _, false))
-        .WillOnce(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
-    run_loop.Run();
-  }
-
-  // Make undrawable and commit.
-  EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AtLeast(1));
+  EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(1);
+  test_layer->PushPropertiesTo(impl_layer.get());  // fake commit
   test_layer->SetIsDrawable(false);
-  layer_tree_host_->Composite(base::TimeTicks());
   Mock::VerifyAndClearExpectations(layer_tree_host_.get());
 
-  // Clearing textures should not sync.
-  EXPECT_CALL(*layer_tree_host_, AcquireLayerTextures()).Times(0);
-  EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AnyNumber());
-  test_layer->ClearTexture();
+  // Verify that non-drawable layers don't signal the compositor,
+  // except for the first draw after last commit, which must acquire
+  // the texture.
+  EXPECT_CALL(*layer_tree_host_, AcquireLayerTextures()).Times(1);
+  EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(0);
+  test_layer->WillModifyTexture();
+  test_layer->SetNeedsDisplayRect(dirty_rect);
+  test_layer->PushPropertiesTo(impl_layer.get());  // fake commit
   Mock::VerifyAndClearExpectations(layer_tree_host_.get());
 
-  // Commit will return the mailbox.
-  layer_tree_host_->Composite(base::TimeTicks());
+  // Second draw with layer in non-drawable state: no texture
+  // acquisition.
+  EXPECT_CALL(*layer_tree_host_, AcquireLayerTextures()).Times(0);
+  EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(0);
+  test_layer->WillModifyTexture();
+  test_layer->SetNeedsDisplayRect(dirty_rect);
   Mock::VerifyAndClearExpectations(layer_tree_host_.get());
-
-  // Wait for mailbox callback.
-  {
-    base::RunLoop run_loop;
-    EXPECT_CALL(mailboxes.mock_callback_,
-                Release(mailboxes.mailbox_name2_, _, false))
-        .WillOnce(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
-    run_loop.Run();
-  }
 }
 
 TEST_F(TextureLayerTest, SyncImplWhenRemovingFromTree) {
@@ -318,11 +153,9 @@ TEST_F(TextureLayerTest, SyncImplWhenRemovingFromTree) {
   scoped_refptr<Layer> child_layer = Layer::Create();
   ASSERT_TRUE(child_layer.get());
   root_layer->AddChild(child_layer);
-  FakeTextureLayerClient client;
-  scoped_refptr<TextureLayer> test_layer = TextureLayer::Create(&client);
-  test_layer->SetIsDrawable(true);
-  test_layer->SetBounds(gfx::Size(10, 10));
+  scoped_refptr<TextureLayer> test_layer = TextureLayer::Create(NULL);
   ASSERT_TRUE(test_layer.get());
+  test_layer->SetTextureId(0);
   child_layer->AddChild(test_layer);
 
   EXPECT_CALL(*layer_tree_host_, AcquireLayerTextures()).Times(AnyNumber());
@@ -340,13 +173,9 @@ TEST_F(TextureLayerTest, SyncImplWhenRemovingFromTree) {
   child_layer->AddChild(test_layer);
   Mock::VerifyAndClearExpectations(layer_tree_host_.get());
 
-  // Give a texture to the layer through the client.
   EXPECT_CALL(*layer_tree_host_, AcquireLayerTextures()).Times(0);
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AtLeast(1));
-  client.set_texture(client.Context3d()->createTexture());
-  test_layer->SetNeedsDisplay();
-  // Force a commit.
-  layer_tree_host_->Composite(base::TimeTicks());
+  test_layer->SetTextureId(1);
   Mock::VerifyAndClearExpectations(layer_tree_host_.get());
 
   EXPECT_CALL(*layer_tree_host_, AcquireLayerTextures()).Times(AtLeast(1));
@@ -357,7 +186,7 @@ TEST_F(TextureLayerTest, SyncImplWhenRemovingFromTree) {
 
 TEST_F(TextureLayerTest, CheckPropertyChangeCausesCorrectBehavior) {
   scoped_refptr<TextureLayer> test_layer = TextureLayer::Create(NULL);
-  EXPECT_SET_NEEDS_COMMIT(1, layer_tree_host_->SetRootLayer(test_layer));
+  layer_tree_host_->SetRootLayer(test_layer);
 
   // Test properties that should call SetNeedsCommit.  All properties need to
   // be set to new values in order for SetNeedsCommit to be called.
@@ -368,9 +197,35 @@ TEST_F(TextureLayerTest, CheckPropertyChangeCausesCorrectBehavior) {
       0.5f, 0.5f, 0.5f, 0.5f));
   EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetPremultipliedAlpha(false));
   EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetBlendBackgroundColor(true));
-  EXPECT_SET_NEEDS_COMMIT(1, test_layer->ClearTexture());
+  EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetTextureId(1));
+
+  // Calling SetTextureId can call AcquireLayerTextures.
+  EXPECT_CALL(*layer_tree_host_, AcquireLayerTextures()).Times(AnyNumber());
 }
 
+class FakeTextureLayerClient : public TextureLayerClient {
+ public:
+  FakeTextureLayerClient() : context_(TestWebGraphicsContext3D::Create()) {}
+
+  virtual unsigned PrepareTexture() OVERRIDE {
+    return 0;
+  }
+
+  virtual WebKit::WebGraphicsContext3D* Context3d() OVERRIDE {
+    return context_.get();
+  }
+
+  virtual bool PrepareTextureMailbox(TextureMailbox* mailbox,
+                                     bool use_shared_memory) OVERRIDE {
+    *mailbox = TextureMailbox();
+    return true;
+  }
+
+ private:
+  scoped_ptr<TestWebGraphicsContext3D> context_;
+  DISALLOW_COPY_AND_ASSIGN(FakeTextureLayerClient);
+};
+
 TEST_F(TextureLayerTest, RateLimiter) {
   FakeTextureLayerClient client;
   scoped_refptr<TextureLayer> test_layer = TextureLayer::CreateForMailbox(
@@ -420,6 +275,58 @@ TEST_F(TextureLayerTest, RateLimiter) {
   Mock::VerifyAndClearExpectations(layer_tree_host_.get());
 }
 
+class MockMailboxCallback {
+ public:
+  MOCK_METHOD3(Release, void(const std::string& mailbox,
+                             unsigned sync_point,
+                             bool lost_resource));
+  MOCK_METHOD3(Release2, void(base::SharedMemory* shared_memory,
+                              unsigned sync_point,
+                              bool lost_resource));
+};
+
+struct CommonMailboxObjects {
+  CommonMailboxObjects()
+      : mailbox_name1_(64, '1'),
+        mailbox_name2_(64, '2'),
+        sync_point1_(1),
+        sync_point2_(2),
+        shared_memory_(new base::SharedMemory) {
+    release_mailbox1_ = base::Bind(&MockMailboxCallback::Release,
+                                   base::Unretained(&mock_callback_),
+                                   mailbox_name1_);
+    release_mailbox2_ = base::Bind(&MockMailboxCallback::Release,
+                                   base::Unretained(&mock_callback_),
+                                   mailbox_name2_);
+    gpu::Mailbox m1;
+    m1.SetName(reinterpret_cast<const int8*>(mailbox_name1_.data()));
+    mailbox1_ = TextureMailbox(m1, release_mailbox1_, sync_point1_);
+    gpu::Mailbox m2;
+    m2.SetName(reinterpret_cast<const int8*>(mailbox_name2_.data()));
+    mailbox2_ = TextureMailbox(m2, release_mailbox2_, sync_point2_);
+
+    gfx::Size size(128, 128);
+    EXPECT_TRUE(shared_memory_->CreateAndMapAnonymous(4 * size.GetArea()));
+    release_mailbox3_ = base::Bind(&MockMailboxCallback::Release2,
+                                   base::Unretained(&mock_callback_),
+                                   shared_memory_.get());
+    mailbox3_ = TextureMailbox(shared_memory_.get(), size, release_mailbox3_);
+  }
+
+  std::string mailbox_name1_;
+  std::string mailbox_name2_;
+  MockMailboxCallback mock_callback_;
+  TextureMailbox::ReleaseCallback release_mailbox1_;
+  TextureMailbox::ReleaseCallback release_mailbox2_;
+  TextureMailbox::ReleaseCallback release_mailbox3_;
+  TextureMailbox mailbox1_;
+  TextureMailbox mailbox2_;
+  TextureMailbox mailbox3_;
+  unsigned sync_point1_;
+  unsigned sync_point2_;
+  scoped_ptr<base::SharedMemory> shared_memory_;
+};
+
 class TextureLayerWithMailboxTest : public TextureLayerTest {
  protected:
   virtual void TearDown() {