Index: cc/trees/single_thread_proxy.cc |
diff --git a/cc/trees/single_thread_proxy.cc b/cc/trees/single_thread_proxy.cc |
index 7a38252a2ea6a3547853e61bee2a54424fe3191c..35e0f67180bb94d5ce2e28f4df9f7e6b60fe5ca2 100644 |
--- a/cc/trees/single_thread_proxy.cc |
+++ b/cc/trees/single_thread_proxy.cc |
@@ -11,8 +11,8 @@ |
#include "cc/animation/animation_events.h" |
#include "cc/debug/benchmark_instrumentation.h" |
#include "cc/debug/devtools_instrumentation.h" |
+#include "cc/output/compositor_frame_sink.h" |
#include "cc/output/context_provider.h" |
-#include "cc/output/output_surface.h" |
#include "cc/quads/draw_quad.h" |
#include "cc/resources/ui_resource_manager.h" |
#include "cc/scheduler/commit_earlyout_reason.h" |
@@ -50,8 +50,8 @@ SingleThreadProxy::SingleThreadProxy(LayerTreeHost* layer_tree_host, |
animate_requested_(false), |
commit_requested_(false), |
inside_synchronous_composite_(false), |
- output_surface_creation_requested_(false), |
- output_surface_lost_(true), |
+ compositor_frame_sink_creation_requested_(false), |
+ compositor_frame_sink_lost_(true), |
weak_factory_(this) { |
TRACE_EVENT0("cc", "SingleThreadProxy::SingleThreadProxy"); |
DCHECK(task_runner_provider_); |
@@ -77,7 +77,7 @@ void SingleThreadProxy::Start( |
// TODO(enne): remove these settings. |
DCHECK(!settings.use_external_begin_frame_source); |
- DCHECK(settings.use_output_surface_begin_frame_source); |
+ DCHECK(settings.use_compositor_frame_sink_begin_frame_source); |
scheduler_on_impl_thread_ = |
Scheduler::Create(this, scheduler_settings, layer_tree_host_->GetId(), |
task_runner_provider_->MainThreadTaskRunner(), |
@@ -116,45 +116,47 @@ void SingleThreadProxy::SetVisible(bool visible) { |
scheduler_on_impl_thread_->SetVisible(layer_tree_host_impl_->visible()); |
} |
-void SingleThreadProxy::RequestNewOutputSurface() { |
+void SingleThreadProxy::RequestNewCompositorFrameSink() { |
DCHECK(task_runner_provider_->IsMainThread()); |
- output_surface_creation_callback_.Cancel(); |
- if (output_surface_creation_requested_) |
+ compositor_frame_sink_creation_callback_.Cancel(); |
+ if (compositor_frame_sink_creation_requested_) |
return; |
- output_surface_creation_requested_ = true; |
- layer_tree_host_->RequestNewOutputSurface(); |
+ compositor_frame_sink_creation_requested_ = true; |
+ layer_tree_host_->RequestNewCompositorFrameSink(); |
} |
-void SingleThreadProxy::ReleaseOutputSurface() { |
- output_surface_lost_ = true; |
+void SingleThreadProxy::ReleaseCompositorFrameSink() { |
+ compositor_frame_sink_lost_ = true; |
if (scheduler_on_impl_thread_) |
- scheduler_on_impl_thread_->DidLoseOutputSurface(); |
- return layer_tree_host_impl_->ReleaseOutputSurface(); |
+ scheduler_on_impl_thread_->DidLoseCompositorFrameSink(); |
+ return layer_tree_host_impl_->ReleaseCompositorFrameSink(); |
} |
-void SingleThreadProxy::SetOutputSurface(OutputSurface* output_surface) { |
+void SingleThreadProxy::SetCompositorFrameSink( |
+ CompositorFrameSink* compositor_frame_sink) { |
DCHECK(task_runner_provider_->IsMainThread()); |
- DCHECK(output_surface_creation_requested_); |
+ DCHECK(compositor_frame_sink_creation_requested_); |
bool success; |
{ |
DebugScopedSetMainThreadBlocked main_thread_blocked(task_runner_provider_); |
DebugScopedSetImplThread impl(task_runner_provider_); |
- success = layer_tree_host_impl_->InitializeRenderer(output_surface); |
+ success = layer_tree_host_impl_->InitializeRenderer(compositor_frame_sink); |
} |
if (success) { |
- layer_tree_host_->DidInitializeOutputSurface(); |
+ layer_tree_host_->DidInitializeCompositorFrameSink(); |
if (scheduler_on_impl_thread_) |
- scheduler_on_impl_thread_->DidCreateAndInitializeOutputSurface(); |
+ scheduler_on_impl_thread_->DidCreateAndInitializeCompositorFrameSink(); |
else if (!inside_synchronous_composite_) |
SetNeedsCommit(); |
- output_surface_creation_requested_ = false; |
- output_surface_lost_ = false; |
+ compositor_frame_sink_creation_requested_ = false; |
+ compositor_frame_sink_lost_ = false; |
} else { |
- // DidFailToInitializeOutputSurface is treated as a RequestNewOutputSurface, |
- // and so output_surface_creation_requested remains true. |
- layer_tree_host_->DidFailToInitializeOutputSurface(); |
+ // DidFailToInitializeCompositorFrameSink is treated as a |
+ // RequestNewCompositorFrameSink, and so |
+ // compositor_frame_sink_creation_requested remains true. |
+ layer_tree_host_->DidFailToInitializeCompositorFrameSink(); |
} |
} |
@@ -294,9 +296,9 @@ void SingleThreadProxy::Stop() { |
DebugScopedSetMainThreadBlocked main_thread_blocked(task_runner_provider_); |
DebugScopedSetImplThread impl(task_runner_provider_); |
- // Take away the OutputSurface before destroying things so it doesn't try |
- // to call into its client mid-shutdown. |
- layer_tree_host_impl_->ReleaseOutputSurface(); |
+ // Take away the CompositorFrameSink before destroying things so it doesn't |
+ // try to call into its client mid-shutdown. |
+ layer_tree_host_impl_->ReleaseCompositorFrameSink(); |
BlockingTaskRunner::CapturePostTasks blocked( |
task_runner_provider_->blocking_main_thread_task_runner()); |
@@ -410,25 +412,27 @@ void SingleThreadProxy::DidCompletePageScaleAnimationOnImplThread() { |
layer_tree_host_->DidCompletePageScaleAnimation(); |
} |
-void SingleThreadProxy::DidLoseOutputSurfaceOnImplThread() { |
- TRACE_EVENT0("cc", "SingleThreadProxy::DidLoseOutputSurfaceOnImplThread"); |
+void SingleThreadProxy::DidLoseCompositorFrameSinkOnImplThread() { |
+ TRACE_EVENT0("cc", |
+ "SingleThreadProxy::DidLoseCompositorFrameSinkOnImplThread"); |
{ |
DebugScopedSetMainThread main(task_runner_provider_); |
// This must happen before we notify the scheduler as it may try to recreate |
// the output surface if already in BEGIN_IMPL_FRAME_STATE_IDLE. |
- layer_tree_host_->DidLoseOutputSurface(); |
+ layer_tree_host_->DidLoseCompositorFrameSink(); |
} |
client_->DidAbortSwapBuffers(); |
if (scheduler_on_impl_thread_) |
- scheduler_on_impl_thread_->DidLoseOutputSurface(); |
- output_surface_lost_ = true; |
+ scheduler_on_impl_thread_->DidLoseCompositorFrameSink(); |
+ compositor_frame_sink_lost_ = true; |
} |
void SingleThreadProxy::SetBeginFrameSource(BeginFrameSource* source) { |
DCHECK(layer_tree_host_->GetSettings().single_thread_proxy_scheduler); |
// TODO(enne): this overrides any preexisting begin frame source. Those |
// other sources will eventually be removed and this will be the only path. |
- if (!layer_tree_host_->GetSettings().use_output_surface_begin_frame_source) |
+ if (!layer_tree_host_->GetSettings() |
+ .use_compositor_frame_sink_begin_frame_source) |
return; |
if (scheduler_on_impl_thread_) |
scheduler_on_impl_thread_->SetBeginFrameSource(source); |
@@ -447,7 +451,7 @@ void SingleThreadProxy::DidSwapBuffersCompleteOnImplThread() { |
layer_tree_host_->DidCompleteSwapBuffers(); |
} |
-void SingleThreadProxy::OnDrawForOutputSurface( |
+void SingleThreadProxy::OnDrawForCompositorFrameSink( |
bool resourceless_software_draw) { |
NOTREACHED() << "Implemented by ThreadProxy for synchronous compositor."; |
} |
@@ -460,11 +464,11 @@ void SingleThreadProxy::CompositeImmediately(base::TimeTicks frame_begin_time) { |
#endif |
base::AutoReset<bool> inside_composite(&inside_synchronous_composite_, true); |
- if (output_surface_lost_) { |
- RequestNewOutputSurface(); |
- // RequestNewOutputSurface could have synchronously created an output |
+ if (compositor_frame_sink_lost_) { |
+ RequestNewCompositorFrameSink(); |
+ // RequestNewCompositorFrameSink could have synchronously created an output |
// surface, so check again before returning. |
- if (output_surface_lost_) |
+ if (compositor_frame_sink_lost_) |
return; |
} |
@@ -525,14 +529,14 @@ bool SingleThreadProxy::ShouldComposite() const { |
return layer_tree_host_impl_->visible() && layer_tree_host_impl_->CanDraw(); |
} |
-void SingleThreadProxy::ScheduleRequestNewOutputSurface() { |
- if (output_surface_creation_callback_.IsCancelled() && |
- !output_surface_creation_requested_) { |
- output_surface_creation_callback_.Reset( |
- base::Bind(&SingleThreadProxy::RequestNewOutputSurface, |
+void SingleThreadProxy::ScheduleRequestNewCompositorFrameSink() { |
+ if (compositor_frame_sink_creation_callback_.IsCancelled() && |
+ !compositor_frame_sink_creation_requested_) { |
+ compositor_frame_sink_creation_callback_.Reset( |
+ base::Bind(&SingleThreadProxy::RequestNewCompositorFrameSink, |
weak_factory_.GetWeakPtr())); |
task_runner_provider_->MainThreadTaskRunner()->PostTask( |
- FROM_HERE, output_surface_creation_callback_.callback()); |
+ FROM_HERE, compositor_frame_sink_creation_callback_.callback()); |
} |
} |
@@ -728,7 +732,7 @@ void SingleThreadProxy::ScheduledActionActivateSyncTree() { |
layer_tree_host_impl_->ActivateSyncTree(); |
} |
-void SingleThreadProxy::ScheduledActionBeginOutputSurfaceCreation() { |
+void SingleThreadProxy::ScheduledActionBeginCompositorFrameSinkCreation() { |
DebugScopedSetMainThread main(task_runner_provider_); |
DCHECK(scheduler_on_impl_thread_); |
// If possible, create the output surface in a post task. Synchronously |
@@ -736,9 +740,9 @@ void SingleThreadProxy::ScheduledActionBeginOutputSurfaceCreation() { |
// from the ThreadProxy behavior. However, sometimes there is no |
// task runner. |
if (task_runner_provider_->MainThreadTaskRunner()) { |
- ScheduleRequestNewOutputSurface(); |
+ ScheduleRequestNewCompositorFrameSink(); |
} else { |
- RequestNewOutputSurface(); |
+ RequestNewCompositorFrameSink(); |
} |
} |
@@ -748,7 +752,7 @@ void SingleThreadProxy::ScheduledActionPrepareTiles() { |
layer_tree_host_impl_->PrepareTiles(); |
} |
-void SingleThreadProxy::ScheduledActionInvalidateOutputSurface() { |
+void SingleThreadProxy::ScheduledActionInvalidateCompositorFrameSink() { |
NOTREACHED(); |
} |