}
void SingleThreadProxy::FinishAllRendering() {
+ TRACE_EVENT0("cc", "SingleThreadProxy::FinishAllRendering");
DCHECK(Proxy::IsMainThread());
{
DebugScopedSetImplThread impl(this);
}
void SingleThreadProxy::SetLayerTreeHostClientReady() {
+ TRACE_EVENT0("cc", "SingleThreadProxy::SetLayerTreeHostClientReady");
// Scheduling is controlled by the embedder in the single thread case, so
// nothing to do.
}
void SingleThreadProxy::SetVisible(bool visible) {
+ TRACE_EVENT0("cc", "SingleThreadProxy::SetVisible");
DebugScopedSetImplThread impl(this);
layer_tree_host_impl_->SetVisible(visible);
DCHECK(output_surface);
initialized = layer_tree_host_impl_->InitializeRenderer(
output_surface.Pass());
- if (initialized) {
- renderer_capabilities_for_main_thread_ =
- layer_tree_host_impl_->GetRendererCapabilities()
- .MainThreadCapabilities();
- } else if (offscreen_context_provider.get()) {
+ if (!initialized && offscreen_context_provider.get()) {
offscreen_context_provider->VerifyContexts();
offscreen_context_provider = NULL;
}
}
void SingleThreadProxy::SetNeedsAnimate() {
+ TRACE_EVENT0("cc", "SingleThreadProxy::SetNeedsAnimate");
DCHECK(Proxy::IsMainThread());
client_->ScheduleAnimation();
}
void SingleThreadProxy::SetNeedsUpdateLayers() {
+ TRACE_EVENT0("cc", "SingleThreadProxy::SetNeedsUpdateLayers");
DCHECK(Proxy::IsMainThread());
client_->ScheduleComposite();
}
void SingleThreadProxy::DoCommit(scoped_ptr<ResourceUpdateQueue> queue) {
+ TRACE_EVENT0("cc", "SingleThreadProxy::DoCommit");
DCHECK(Proxy::IsMainThread());
// Commit immediately.
{
}
void SingleThreadProxy::SetNeedsRedraw(const gfx::Rect& damage_rect) {
+ TRACE_EVENT0("cc", "SingleThreadProxy::SetNeedsRedraw");
SetNeedsRedrawRectOnImplThread(damage_rect);
client_->ScheduleComposite();
}
}
void SingleThreadProxy::OnCanDrawStateChanged(bool can_draw) {
+ TRACE_EVENT1(
+ "cc", "SingleThreadProxy::OnCanDrawStateChanged", "can_draw", can_draw);
DCHECK(Proxy::IsImplThread());
UpdateBackgroundAnimateTicking();
}
void SingleThreadProxy::PostAnimationEventsToMainThreadOnImplThread(
scoped_ptr<AnimationEventsVector> events,
base::Time wall_clock_time) {
+ TRACE_EVENT0(
+ "cc", "SingleThreadProxy::PostAnimationEventsToMainThreadOnImplThread");
DCHECK(Proxy::IsImplThread());
DebugScopedSetMainThread main(this);
layer_tree_host_->SetAnimationEvents(events.Pass(), wall_clock_time);
bool SingleThreadProxy::IsInsideDraw() { return inside_draw_; }
+void SingleThreadProxy::UpdateRendererCapabilitiesOnImplThread() {
+ DCHECK(IsImplThread());
+ renderer_capabilities_for_main_thread_ =
+ layer_tree_host_impl_->GetRendererCapabilities().MainThreadCapabilities();
+}
+
void SingleThreadProxy::DidLoseOutputSurfaceOnImplThread() {
+ TRACE_EVENT0("cc", "SingleThreadProxy::DidLoseOutputSurfaceOnImplThread");
// Cause a commit so we can notice the lost context.
SetNeedsCommitOnImplThread();
client_->DidAbortSwapBuffers();
}
void SingleThreadProxy::OnSwapBuffersCompleteOnImplThread() {
+ TRACE_EVENT0("cc", "SingleThreadProxy::OnSwapBuffersCompleteOnImplThread");
client_->DidCompleteSwapBuffers();
}
// Called by the legacy scheduling path (e.g. where render_widget does the
// scheduling)
void SingleThreadProxy::CompositeImmediately(base::TimeTicks frame_begin_time) {
+ TRACE_EVENT0("cc", "SingleThreadProxy::CompositeImmediately");
gfx::Rect device_viewport_damage_rect;
LayerTreeHostImpl::FrameData frame;
const gfx::Rect& device_viewport_damage_rect,
bool for_readback,
LayerTreeHostImpl::FrameData* frame) {
+ TRACE_EVENT0("cc", "SingleThreadProxy::CommitAndComposite");
DCHECK(Proxy::IsMainThread());
if (!layer_tree_host_->InitializeOutputSurfaceIfNeeded())
const gfx::Rect& device_viewport_damage_rect,
bool for_readback,
LayerTreeHostImpl::FrameData* frame) {
+ TRACE_EVENT0("cc", "SingleThreadProxy::DoComposite");
DCHECK(!layer_tree_host_->output_surface_lost());
bool lost_output_surface = false;