#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"
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;
}
}
-Region TextureLayer::VisibleContentOpaqueRegion() const {
+SimpleEnclosedRegion TextureLayer::VisibleContentOpaqueRegion() const {
if (contents_opaque())
- return visible_content_rect();
+ return SimpleEnclosedRegion(visible_content_rect());
if (blend_background_color_ && (SkColorGetA(background_color()) == 0xFF))
- return visible_content_rect();
+ return SimpleEnclosedRegion(visible_content_rect());
- return Region();
+ return SimpleEnclosedRegion();
}
TextureLayer::TextureMailboxHolder::MainThreadReference::MainThreadReference(
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) {
+}
TextureLayer::TextureMailboxHolder::~TextureMailboxHolder() {
DCHECK_EQ(0u, internal_references_);
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::InternalRelease() {
- DCHECK(message_loop_->BelongsToCurrentThread());
+ DCHECK(main_thread_checker_.CalledOnValidThread());
if (!--internal_references_) {
release_callback_->Run(sync_point_, is_lost_);
mailbox_ = TextureMailbox();
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));
}