cc: Use correct message loop proxy in BlockingTaskRunner

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/base/simple_enclosed_region.h"
 #include "cc/layers/texture_layer_client.h"
 #include "cc/layers/texture_layer_impl.h"
 #include "cc/resources/single_release_callback.h"
+#include "cc/resources/single_release_callback_impl.h"
 #include "cc/trees/blocking_task_runner.h"
 #include "cc/trees/layer_tree_host.h"
 
 namespace cc {
 
 scoped_refptr<TextureLayer> TextureLayer::CreateForMailbox(
     TextureLayerClient* client) {
   return scoped_refptr<TextureLayer>(new TextureLayer(client));
 }
 
@@ skipping 212 matching lines @@
 
   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 (needs_set_mailbox_) {
     TextureMailbox texture_mailbox;
-    scoped_ptr<SingleReleaseCallback> release_callback;
+    scoped_ptr<SingleReleaseCallbackImpl> release_callback_impl;
     if (holder_ref_) {
       TextureMailboxHolder* holder = holder_ref_->holder();
       texture_mailbox = holder->mailbox();
-      release_callback = holder->GetCallbackForImplThread();
+      release_callback_impl = holder->GetCallbackForImplThread();
     }
-    texture_layer->SetTextureMailbox(texture_mailbox, release_callback.Pass());
+    texture_layer->SetTextureMailbox(texture_mailbox,
+                                     release_callback_impl.Pass());
     needs_set_mailbox_ = false;
   }
 }
 
 SimpleEnclosedRegion TextureLayer::VisibleContentOpaqueRegion() const {
   if (contents_opaque())
     return SimpleEnclosedRegion(visible_content_rect());
 
   if (blend_background_color_ && (SkColorGetA(background_color()) == 0xFF))
     return SimpleEnclosedRegion(visible_content_rect());
 
   return SimpleEnclosedRegion();
 }
 
 TextureLayer::TextureMailboxHolder::MainThreadReference::MainThreadReference(
     TextureMailboxHolder* holder)
     : holder_(holder) {
   holder_->InternalAddRef();
 }
 
 TextureLayer::TextureMailboxHolder::MainThreadReference::
     ~MainThreadReference() {
   holder_->InternalRelease();
 }
 
 TextureLayer::TextureMailboxHolder::TextureMailboxHolder(
     const TextureMailbox& mailbox,
     scoped_ptr<SingleReleaseCallback> release_callback)
-    : message_loop_(BlockingTaskRunner::current()),
-      internal_references_(0),
+    : internal_references_(0),
       mailbox_(mailbox),
       release_callback_(release_callback.Pass()),
       sync_point_(mailbox.sync_point()),
-      is_lost_(false) {}
+      is_lost_(false) {

[danakj, 2014/09/03 16:09:36]

can you CalledOnValidThread() here, so we show InternalRelease happens on the
same thread? The checker binds to the first thread CalledOnValidThread happens
on

[Sami, 2014/09/03 17:59:12]

Looks like the ThreadCheckerImpl constructor locks it to the current thread, no?

[danakj, 2014/09/03 19:47:41]

Ohh, ya it does!

+}
 
 TextureLayer::TextureMailboxHolder::~TextureMailboxHolder() {
   DCHECK_EQ(0u, internal_references_);
 }
 
 scoped_ptr<TextureLayer::TextureMailboxHolder::MainThreadReference>
 TextureLayer::TextureMailboxHolder::Create(
     const TextureMailbox& mailbox,
     scoped_ptr<SingleReleaseCallback> release_callback) {
   return scoped_ptr<MainThreadReference>(new MainThreadReference(
       new TextureMailboxHolder(mailbox, release_callback.Pass())));
 }
 
 void TextureLayer::TextureMailboxHolder::Return(uint32 sync_point,
                                                 bool is_lost) {
   base::AutoLock lock(arguments_lock_);
   sync_point_ = sync_point;
   is_lost_ = is_lost;
 }
 
-scoped_ptr<SingleReleaseCallback>
+scoped_ptr<SingleReleaseCallbackImpl>
 TextureLayer::TextureMailboxHolder::GetCallbackForImplThread() {
   // We can't call GetCallbackForImplThread if we released the main thread
   // reference.
   DCHECK_GT(internal_references_, 0u);
   InternalAddRef();
-  return SingleReleaseCallback::Create(
+  return SingleReleaseCallbackImpl::Create(
       base::Bind(&TextureMailboxHolder::ReturnAndReleaseOnImplThread, this));
 }
 
 void TextureLayer::TextureMailboxHolder::InternalAddRef() {
   ++internal_references_;
 }
 
 void TextureLayer::TextureMailboxHolder::InternalRelease() {
-  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK(main_thread_checker_.CalledOnValidThread());
   if (!--internal_references_) {
     release_callback_->Run(sync_point_, is_lost_);
     mailbox_ = TextureMailbox();
     release_callback_.reset();
   }
 }
 
 void TextureLayer::TextureMailboxHolder::ReturnAndReleaseOnImplThread(
     uint32 sync_point,
-    bool is_lost) {
+    bool is_lost,
+    BlockingTaskRunner* main_thread_task_runner) {
   Return(sync_point, is_lost);
-  message_loop_->PostTask(
+  main_thread_task_runner->PostTask(
       FROM_HERE, base::Bind(&TextureMailboxHolder::InternalRelease, this));
 }
 
 }  // namespace cc