summaryrefslogtreecommitdiffstats
path: root/cc
diff options
context:
space:
mode:
Diffstat (limited to 'cc')
-rw-r--r--cc/scheduler/scheduler.cc27
-rw-r--r--cc/scheduler/scheduler.h15
-rw-r--r--cc/scheduler/scheduler_state_machine.cc4
-rw-r--r--cc/test/fake_layer_tree_host_client.h2
-rw-r--r--cc/test/layer_tree_test.cc48
-rw-r--r--cc/test/layer_tree_test.h6
-rw-r--r--cc/trees/layer_tree_host.cc2
-rw-r--r--cc/trees/layer_tree_host_single_thread_client.h4
-rw-r--r--cc/trees/layer_tree_host_unittest.cc6
-rw-r--r--cc/trees/layer_tree_host_unittest_animation.cc9
-rw-r--r--cc/trees/layer_tree_host_unittest_context.cc80
-rw-r--r--cc/trees/layer_tree_host_unittest_no_message_loop.cc2
-rw-r--r--cc/trees/layer_tree_settings.cc1
-rw-r--r--cc/trees/layer_tree_settings.h1
-rw-r--r--cc/trees/single_thread_proxy.cc339
-rw-r--r--cc/trees/single_thread_proxy.h48
-rw-r--r--cc/trees/thread_proxy.cc5
17 files changed, 211 insertions, 388 deletions
diff --git a/cc/scheduler/scheduler.cc b/cc/scheduler/scheduler.cc
index 8f127e9..4a682cd 100644
--- a/cc/scheduler/scheduler.cc
+++ b/cc/scheduler/scheduler.cc
@@ -77,11 +77,11 @@ Scheduler::Scheduler(
SchedulerClient* client,
const SchedulerSettings& scheduler_settings,
int layer_tree_host_id,
- const scoped_refptr<base::SingleThreadTaskRunner>& task_runner)
+ const scoped_refptr<base::SingleThreadTaskRunner>& impl_task_runner)
: settings_(scheduler_settings),
client_(client),
layer_tree_host_id_(layer_tree_host_id),
- task_runner_(task_runner),
+ impl_task_runner_(impl_task_runner),
vsync_interval_(BeginFrameArgs::DefaultInterval()),
last_set_needs_begin_frame_(false),
begin_unthrottled_frame_posted_(false),
@@ -126,7 +126,7 @@ Scheduler::~Scheduler() {
void Scheduler::SetupSyntheticBeginFrames() {
DCHECK(!synthetic_begin_frame_source_);
synthetic_begin_frame_source_.reset(
- new SyntheticBeginFrameSource(this, task_runner_.get()));
+ new SyntheticBeginFrameSource(this, impl_task_runner_.get()));
}
void Scheduler::CommitVSyncParameters(base::TimeTicks timebase,
@@ -272,9 +272,6 @@ base::TimeTicks Scheduler::LastBeginImplFrameTime() {
}
void Scheduler::SetupNextBeginFrameIfNeeded() {
- if (!task_runner_)
- return;
-
bool needs_begin_frame = state_machine_.BeginFrameNeeded();
if (settings_.throttle_frame_production) {
@@ -329,7 +326,7 @@ void Scheduler::SetupNextBeginFrameWhenVSyncThrottlingDisabled(
}
begin_unthrottled_frame_posted_ = true;
- task_runner_->PostTask(FROM_HERE, begin_unthrottled_frame_closure_);
+ impl_task_runner_->PostTask(FROM_HERE, begin_unthrottled_frame_closure_);
}
// BeginUnthrottledFrame is used when we aren't throttling frame production.
@@ -363,7 +360,7 @@ void Scheduler::SetupPollingMechanisms(bool needs_begin_frame) {
base::TimeDelta delay = begin_impl_frame_args_.IsValid()
? begin_impl_frame_args_.interval
: BeginFrameArgs::DefaultInterval();
- task_runner_->PostDelayedTask(
+ impl_task_runner_->PostDelayedTask(
FROM_HERE, poll_for_draw_triggers_task_.callback(), delay);
}
} else {
@@ -388,9 +385,9 @@ void Scheduler::SetupPollingMechanisms(bool needs_begin_frame) {
// Since we'd rather get a BeginImplFrame by the normal mechanism, we
// set the interval to twice the interval from the previous frame.
advance_commit_state_task_.Reset(advance_commit_state_closure_);
- task_runner_->PostDelayedTask(FROM_HERE,
- advance_commit_state_task_.callback(),
- begin_impl_frame_args_.interval * 2);
+ impl_task_runner_->PostDelayedTask(FROM_HERE,
+ advance_commit_state_task_.callback(),
+ begin_impl_frame_args_.interval * 2);
}
} else {
advance_commit_state_task_.Cancel();
@@ -492,7 +489,7 @@ void Scheduler::PostBeginRetroFrameIfNeeded() {
return;
begin_retro_frame_posted_ = true;
- task_runner_->PostTask(FROM_HERE, begin_retro_frame_closure_);
+ impl_task_runner_->PostTask(FROM_HERE, begin_retro_frame_closure_);
}
// BeginImplFrame starts a compositor frame that will wait up until a deadline
@@ -500,8 +497,8 @@ void Scheduler::PostBeginRetroFrameIfNeeded() {
// any asynchronous animation and scroll/pinch updates.
void Scheduler::BeginImplFrame(const BeginFrameArgs& args) {
TRACE_EVENT1("cc", "Scheduler::BeginImplFrame", "args", ToTrace(args));
- DCHECK_EQ(state_machine_.begin_impl_frame_state(),
- SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE);
+ DCHECK(state_machine_.begin_impl_frame_state() ==
+ SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE);
DCHECK(state_machine_.HasInitializedOutputSurface());
advance_commit_state_task_.Cancel();
@@ -568,7 +565,7 @@ void Scheduler::ScheduleBeginImplFrameDeadline(base::TimeTicks deadline) {
base::TimeDelta delta = deadline - gfx::FrameTime::Now();
if (delta <= base::TimeDelta())
delta = base::TimeDelta();
- task_runner_->PostDelayedTask(
+ impl_task_runner_->PostDelayedTask(
FROM_HERE, begin_impl_frame_deadline_task_.callback(), delta);
}
diff --git a/cc/scheduler/scheduler.h b/cc/scheduler/scheduler.h
index f392047..3de06ac 100644
--- a/cc/scheduler/scheduler.h
+++ b/cc/scheduler/scheduler.h
@@ -54,9 +54,9 @@ class CC_EXPORT Scheduler {
SchedulerClient* client,
const SchedulerSettings& scheduler_settings,
int layer_tree_host_id,
- const scoped_refptr<base::SingleThreadTaskRunner>& task_runner) {
+ const scoped_refptr<base::SingleThreadTaskRunner>& impl_task_runner) {
return make_scoped_ptr(new Scheduler(
- client, scheduler_settings, layer_tree_host_id, task_runner));
+ client, scheduler_settings, layer_tree_host_id, impl_task_runner));
}
virtual ~Scheduler();
@@ -170,15 +170,16 @@ class CC_EXPORT Scheduler {
scoped_refptr<DelayBasedTimeSource> time_source_;
};
- Scheduler(SchedulerClient* client,
- const SchedulerSettings& scheduler_settings,
- int layer_tree_host_id,
- const scoped_refptr<base::SingleThreadTaskRunner>& task_runner);
+ Scheduler(
+ SchedulerClient* client,
+ const SchedulerSettings& scheduler_settings,
+ int layer_tree_host_id,
+ const scoped_refptr<base::SingleThreadTaskRunner>& impl_task_runner);
const SchedulerSettings settings_;
SchedulerClient* client_;
int layer_tree_host_id_;
- scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
+ scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner_;
base::TimeDelta vsync_interval_;
base::TimeDelta estimated_parent_draw_time_;
diff --git a/cc/scheduler/scheduler_state_machine.cc b/cc/scheduler/scheduler_state_machine.cc
index e2e8168..dea25b40 100644
--- a/cc/scheduler/scheduler_state_machine.cc
+++ b/cc/scheduler/scheduler_state_machine.cc
@@ -1006,9 +1006,7 @@ void SchedulerStateMachine::DidDrawIfPossibleCompleted(DrawResult result) {
}
}
-void SchedulerStateMachine::SetNeedsCommit() {
- needs_commit_ = true;
-}
+void SchedulerStateMachine::SetNeedsCommit() { needs_commit_ = true; }
void SchedulerStateMachine::NotifyReadyToCommit() {
DCHECK(commit_state_ == COMMIT_STATE_BEGIN_MAIN_FRAME_STARTED) << *AsValue();
diff --git a/cc/test/fake_layer_tree_host_client.h b/cc/test/fake_layer_tree_host_client.h
index 7f7bd35..f928453 100644
--- a/cc/test/fake_layer_tree_host_client.h
+++ b/cc/test/fake_layer_tree_host_client.h
@@ -42,6 +42,8 @@ class FakeLayerTreeHostClient : public LayerTreeHostClient,
virtual void DidCompleteSwapBuffers() OVERRIDE {}
// LayerTreeHostSingleThreadClient implementation.
+ virtual void ScheduleComposite() OVERRIDE {}
+ virtual void ScheduleAnimation() OVERRIDE {}
virtual void DidPostSwapBuffers() OVERRIDE {}
virtual void DidAbortSwapBuffers() OVERRIDE {}
diff --git a/cc/test/layer_tree_test.cc b/cc/test/layer_tree_test.cc
index a680441..3437f8c 100644
--- a/cc/test/layer_tree_test.cc
+++ b/cc/test/layer_tree_test.cc
@@ -321,6 +321,14 @@ class LayerTreeHostClientForTesting : public LayerTreeHostClient,
test_hooks_->DidCompleteSwapBuffers();
}
+ virtual void ScheduleComposite() OVERRIDE {
+ test_hooks_->ScheduleComposite();
+ }
+
+ virtual void ScheduleAnimation() OVERRIDE {
+ test_hooks_->ScheduleAnimation();
+ }
+
virtual void DidPostSwapBuffers() OVERRIDE {}
virtual void DidAbortSwapBuffers() OVERRIDE {}
@@ -393,6 +401,7 @@ LayerTreeTest::LayerTreeTest()
end_when_begin_returns_(false),
timed_out_(false),
scheduled_(false),
+ schedule_when_set_visible_true_(false),
started_(false),
ended_(false),
delegating_renderer_(false),
@@ -555,6 +564,15 @@ void LayerTreeTest::Timeout() {
EndTest();
}
+void LayerTreeTest::ScheduleComposite() {
+ if (!started_ || scheduled_)
+ return;
+ scheduled_ = true;
+ main_task_runner_->PostTask(
+ FROM_HERE,
+ base::Bind(&LayerTreeTest::DispatchComposite, main_thread_weak_ptr_));
+}
+
void LayerTreeTest::RealEndTest() {
if (layer_tree_host_ && proxy()->CommitPendingForTesting()) {
main_task_runner_->PostTask(
@@ -606,8 +624,16 @@ void LayerTreeTest::DispatchSetNeedsRedrawRect(const gfx::Rect& damage_rect) {
void LayerTreeTest::DispatchSetVisible(bool visible) {
DCHECK(!proxy() || proxy()->IsMainThread());
- if (layer_tree_host_)
- layer_tree_host_->SetVisible(visible);
+
+ if (!layer_tree_host_)
+ return;
+
+ layer_tree_host_->SetVisible(visible);
+
+ // If the LTH is being made visible and a previous ScheduleComposite() was
+ // deferred because the LTH was not visible, re-schedule the composite now.
+ if (layer_tree_host_->visible() && schedule_when_set_visible_true_)
+ ScheduleComposite();
}
void LayerTreeTest::DispatchSetNextCommitForcesRedraw() {
@@ -617,6 +643,24 @@ void LayerTreeTest::DispatchSetNextCommitForcesRedraw() {
layer_tree_host_->SetNextCommitForcesRedraw();
}
+void LayerTreeTest::DispatchComposite() {
+ scheduled_ = false;
+
+ if (!layer_tree_host_)
+ return;
+
+ // If the LTH is not visible, defer the composite until the LTH is made
+ // visible.
+ if (!layer_tree_host_->visible()) {
+ schedule_when_set_visible_true_ = true;
+ return;
+ }
+
+ schedule_when_set_visible_true_ = false;
+ base::TimeTicks now = gfx::FrameTime::Now();
+ layer_tree_host_->Composite(now);
+}
+
void LayerTreeTest::RunTest(bool threaded,
bool delegating_renderer,
bool impl_side_painting) {
diff --git a/cc/test/layer_tree_test.h b/cc/test/layer_tree_test.h
index 619ae96..8f38dda 100644
--- a/cc/test/layer_tree_test.h
+++ b/cc/test/layer_tree_test.h
@@ -71,6 +71,8 @@ class TestHooks : public AnimationDelegate {
virtual void DidCommit() {}
virtual void DidCommitAndDrawFrame() {}
virtual void DidCompleteSwapBuffers() {}
+ virtual void ScheduleComposite() {}
+ virtual void ScheduleAnimation() {}
virtual void DidDeferCommit() {}
virtual void DidSetVisibleOnImplTree(LayerTreeHostImpl* host_impl,
bool visible) {}
@@ -137,6 +139,8 @@ class LayerTreeTest : public testing::Test, public TestHooks {
virtual void InitializeSettings(LayerTreeSettings* settings) {}
+ virtual void ScheduleComposite() OVERRIDE;
+
void RealEndTest();
virtual void DispatchAddAnimation(Layer* layer_to_receive_animation,
@@ -147,6 +151,7 @@ class LayerTreeTest : public testing::Test, public TestHooks {
void DispatchSetNeedsRedrawRect(const gfx::Rect& damage_rect);
void DispatchSetVisible(bool visible);
void DispatchSetNextCommitForcesRedraw();
+ void DispatchComposite();
void DispatchDidAddAnimation();
virtual void AfterTest() = 0;
@@ -199,6 +204,7 @@ class LayerTreeTest : public testing::Test, public TestHooks {
bool end_when_begin_returns_;
bool timed_out_;
bool scheduled_;
+ bool schedule_when_set_visible_true_;
bool started_;
bool ended_;
bool delegating_renderer_;
diff --git a/cc/trees/layer_tree_host.cc b/cc/trees/layer_tree_host.cc
index 6f995d8..51b9b4f 100644
--- a/cc/trees/layer_tree_host.cc
+++ b/cc/trees/layer_tree_host.cc
@@ -677,8 +677,6 @@ void LayerTreeHost::Composite(base::TimeTicks frame_begin_time) {
DCHECK(!proxy_->HasImplThread());
SingleThreadProxy* proxy = static_cast<SingleThreadProxy*>(proxy_.get());
- SetLayerTreeHostClientReady();
-
if (output_surface_lost_)
proxy->CreateAndInitializeOutputSurface();
if (output_surface_lost_)
diff --git a/cc/trees/layer_tree_host_single_thread_client.h b/cc/trees/layer_tree_host_single_thread_client.h
index dbca28c..cb61450 100644
--- a/cc/trees/layer_tree_host_single_thread_client.h
+++ b/cc/trees/layer_tree_host_single_thread_client.h
@@ -10,10 +10,10 @@ namespace cc {
class LayerTreeHostSingleThreadClient {
public:
// Request that the client schedule a composite.
- virtual void ScheduleComposite() {}
+ virtual void ScheduleComposite() = 0;
// Request that the client schedule a composite now, and calculate appropriate
// delay for potential future frame.
- virtual void ScheduleAnimation() {}
+ virtual void ScheduleAnimation() = 0;
// Called whenever the compositor posts a SwapBuffers (either full or
// partial). After DidPostSwapBuffers(), exactly one of
diff --git a/cc/trees/layer_tree_host_unittest.cc b/cc/trees/layer_tree_host_unittest.cc
index 95c44bcf..b194491 100644
--- a/cc/trees/layer_tree_host_unittest.cc
+++ b/cc/trees/layer_tree_host_unittest.cc
@@ -91,8 +91,8 @@ class LayerTreeHostTestSetNeedsCommit1 : public LayerTreeHostTest {
}
virtual void AfterTest() OVERRIDE {
- EXPECT_LE(1, num_commits_);
- EXPECT_LE(1, num_draws_);
+ EXPECT_GE(1, num_commits_);
+ EXPECT_GE(1, num_draws_);
}
private:
@@ -1967,7 +1967,7 @@ class LayerTreeHostTestDeferCommits : public LayerTreeHostTest {
int num_complete_commits_;
};
-SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestDeferCommits);
+MULTI_THREAD_TEST_F(LayerTreeHostTestDeferCommits);
class LayerTreeHostWithProxy : public LayerTreeHost {
public:
diff --git a/cc/trees/layer_tree_host_unittest_animation.cc b/cc/trees/layer_tree_host_unittest_animation.cc
index 3b2de64..1542a14 100644
--- a/cc/trees/layer_tree_host_unittest_animation.cc
+++ b/cc/trees/layer_tree_host_unittest_animation.cc
@@ -726,7 +726,9 @@ class LayerTreeHostAnimationTestContinuousAnimate
: public LayerTreeHostAnimationTest {
public:
LayerTreeHostAnimationTestContinuousAnimate()
- : num_commit_complete_(0), num_draw_layers_(0), have_animated_(false) {}
+ : num_commit_complete_(0),
+ num_draw_layers_(0) {
+ }
virtual void SetupTree() OVERRIDE {
LayerTreeHostAnimationTest::SetupTree();
@@ -745,7 +747,6 @@ class LayerTreeHostAnimationTestContinuousAnimate
if (num_draw_layers_ == 2)
return;
layer_tree_host()->SetNeedsAnimate();
- have_animated_ = true;
}
virtual void Layout() OVERRIDE {
@@ -766,18 +767,16 @@ class LayerTreeHostAnimationTestContinuousAnimate
virtual void AfterTest() OVERRIDE {
// Check that we didn't commit twice between first and second draw.
EXPECT_EQ(1, num_commit_complete_);
- EXPECT_TRUE(have_animated_);
}
private:
int num_commit_complete_;
int num_draw_layers_;
- bool have_animated_;
FakeContentLayerClient client_;
scoped_refptr<FakeContentLayer> content_;
};
-SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostAnimationTestContinuousAnimate);
+MULTI_THREAD_TEST_F(LayerTreeHostAnimationTestContinuousAnimate);
class LayerTreeHostAnimationTestCancelAnimateCommit
: public LayerTreeHostAnimationTest {
diff --git a/cc/trees/layer_tree_host_unittest_context.cc b/cc/trees/layer_tree_host_unittest_context.cc
index 548ff36..879e534 100644
--- a/cc/trees/layer_tree_host_unittest_context.cc
+++ b/cc/trees/layer_tree_host_unittest_context.cc
@@ -65,9 +65,6 @@ class LayerTreeHostContextTest : public LayerTreeTest {
}
void LoseContext() {
- // For sanity-checking tests, they should only call this when the
- // context is not lost.
- CHECK(context3d_);
context3d_->loseContextCHROMIUM(GL_GUILTY_CONTEXT_RESET_ARB,
GL_INNOCENT_CONTEXT_RESET_ARB);
context3d_ = NULL;
@@ -203,53 +200,45 @@ class LayerTreeHostContextTestLostContextSucceeds
static const TestCase kTests[] = {
// Losing the context and failing to recreate it (or losing it again
// immediately) a small number of times should succeed.
- {
- 1, // times_to_lose_during_commit
+ {1, // times_to_lose_during_commit
0, // times_to_lose_during_draw
0, // times_to_fail_recreate
false, // fallback_context_works
},
- {
- 0, // times_to_lose_during_commit
+ {0, // times_to_lose_during_commit
1, // times_to_lose_during_draw
0, // times_to_fail_recreate
false, // fallback_context_works
},
- {
- 1, // times_to_lose_during_commit
+ {1, // times_to_lose_during_commit
0, // times_to_lose_during_draw
3, // times_to_fail_recreate
false, // fallback_context_works
},
- {
- 0, // times_to_lose_during_commit
+ {0, // times_to_lose_during_commit
1, // times_to_lose_during_draw
3, // times_to_fail_recreate
false, // fallback_context_works
},
// Losing the context and recreating it any number of times should
// succeed.
- {
- 10, // times_to_lose_during_commit
+ {10, // times_to_lose_during_commit
0, // times_to_lose_during_draw
0, // times_to_fail_recreate
false, // fallback_context_works
},
- {
- 0, // times_to_lose_during_commit
+ {0, // times_to_lose_during_commit
10, // times_to_lose_during_draw
0, // times_to_fail_recreate
false, // fallback_context_works
},
// Losing the context, failing to reinitialize it, and making a fallback
// context should work.
- {
- 0, // times_to_lose_during_commit
+ {0, // times_to_lose_during_commit
1, // times_to_lose_during_draw
0, // times_to_fail_recreate
true, // fallback_context_works
- },
- };
+ }, };
if (test_case_ >= arraysize(kTests))
return false;
@@ -311,8 +300,7 @@ class LayerTreeHostClientNotReadyDoesNotCreateOutputSurface
}
};
-SINGLE_AND_MULTI_THREAD_TEST_F(
- LayerTreeHostClientNotReadyDoesNotCreateOutputSurface);
+MULTI_THREAD_TEST_F(LayerTreeHostClientNotReadyDoesNotCreateOutputSurface);
class LayerTreeHostContextTestLostContextSucceedsWithContent
: public LayerTreeHostContextTestLostContextSucceeds {
@@ -370,11 +358,10 @@ class LayerTreeHostContextTestCreateOutputSurfaceFails
: times_to_fail_(times_to_fail),
expect_fallback_attempt_(expect_fallback_attempt),
did_attempt_fallback_(false),
- times_initialized_(0) {
- times_to_fail_create_ = times_to_fail_;
- }
+ times_initialized_(0) {}
virtual void BeginTest() OVERRIDE {
+ times_to_fail_create_ = times_to_fail_;
PostSetNeedsCommitToMainThread();
}
@@ -988,6 +975,12 @@ class ScrollbarLayerLostContext : public LayerTreeHostContextTest {
EXPECT_EQ(2, scrollbar_layer_->update_count());
EndTest();
break;
+ case 3:
+ // Single thread proxy issues extra commits after context lost.
+ // http://crbug.com/287250
+ if (HasImplThread())
+ NOTREACHED();
+ break;
default:
NOTREACHED();
}
@@ -1031,10 +1024,12 @@ class UIResourceLostTest : public LayerTreeHostContextTest {
void PostLoseContextToImplThread() {
EXPECT_TRUE(layer_tree_host()->proxy()->IsMainThread());
- ImplThreadTaskRunner()->PostTask(
- FROM_HERE,
- base::Bind(&LayerTreeHostContextTest::LoseContext,
- base::Unretained(this)));
+ base::SingleThreadTaskRunner* task_runner =
+ HasImplThread() ? ImplThreadTaskRunner()
+ : base::MessageLoopProxy::current();
+ task_runner->PostTask(FROM_HERE,
+ base::Bind(&LayerTreeHostContextTest::LoseContext,
+ base::Unretained(this)));
}
protected:
@@ -1089,8 +1084,13 @@ class UIResourceLostAfterCommit : public UIResourceLostTestSimple {
EndTest();
break;
case 5:
- NOTREACHED();
+ // Single thread proxy issues extra commits after context lost.
+ // http://crbug.com/287250
+ if (HasImplThread())
+ NOTREACHED();
break;
+ case 6:
+ NOTREACHED();
}
}
@@ -1178,8 +1178,13 @@ class UIResourceLostBeforeCommit : public UIResourceLostTestSimple {
EndTest();
break;
case 6:
- NOTREACHED();
+ // Single thread proxy issues extra commits after context lost.
+ // http://crbug.com/287250
+ if (HasImplThread())
+ NOTREACHED();
break;
+ case 8:
+ NOTREACHED();
}
}
@@ -1200,8 +1205,15 @@ class UIResourceLostBeforeCommit : public UIResourceLostTestSimple {
// Sequence 2 (continued):
// The previous resource should have been deleted.
EXPECT_EQ(0u, impl->ResourceIdForUIResource(test_id0_));
- // The second resource should have been created.
- EXPECT_NE(0u, impl->ResourceIdForUIResource(test_id1_));
+ if (HasImplThread()) {
+ // The second resource should have been created.
+ EXPECT_NE(0u, impl->ResourceIdForUIResource(test_id1_));
+ } else {
+ // The extra commit that happens at context lost in the single thread
+ // proxy changes the timing so that the resource has been destroyed.
+ // http://crbug.com/287250
+ EXPECT_EQ(0u, impl->ResourceIdForUIResource(test_id1_));
+ }
// The second resource called the resource callback once and since the
// context is lost, a "resource lost" callback was also issued.
EXPECT_EQ(2, ui_resource_->resource_create_count);
@@ -1517,8 +1529,8 @@ class LayerTreeHostContextTestLoseAfterSendingBeginMainFrame
bool deferred_;
};
-SINGLE_AND_MULTI_THREAD_TEST_F(
- LayerTreeHostContextTestLoseAfterSendingBeginMainFrame);
+// TODO(danakj): We don't use scheduler with SingleThreadProxy yet.
+MULTI_THREAD_TEST_F(LayerTreeHostContextTestLoseAfterSendingBeginMainFrame);
} // namespace
} // namespace cc
diff --git a/cc/trees/layer_tree_host_unittest_no_message_loop.cc b/cc/trees/layer_tree_host_unittest_no_message_loop.cc
index f687efb..4c6796f 100644
--- a/cc/trees/layer_tree_host_unittest_no_message_loop.cc
+++ b/cc/trees/layer_tree_host_unittest_no_message_loop.cc
@@ -74,6 +74,8 @@ class LayerTreeHostNoMessageLoopTest
virtual void DidCompleteSwapBuffers() OVERRIDE {}
// LayerTreeHostSingleThreadClient overrides.
+ virtual void ScheduleComposite() OVERRIDE {}
+ virtual void ScheduleAnimation() OVERRIDE {}
virtual void DidPostSwapBuffers() OVERRIDE {}
virtual void DidAbortSwapBuffers() OVERRIDE {}
diff --git a/cc/trees/layer_tree_settings.cc b/cc/trees/layer_tree_settings.cc
index 5193b2d..4b56d7c 100644
--- a/cc/trees/layer_tree_settings.cc
+++ b/cc/trees/layer_tree_settings.cc
@@ -16,7 +16,6 @@ LayerTreeSettings::LayerTreeSettings()
: impl_side_painting(false),
allow_antialiasing(true),
throttle_frame_production(true),
- single_thread_proxy_scheduler(true),
begin_frame_scheduling_enabled(false),
main_frame_before_draw_enabled(true),
main_frame_before_activation_enabled(false),
diff --git a/cc/trees/layer_tree_settings.h b/cc/trees/layer_tree_settings.h
index ef2a4955..21d72c9 100644
--- a/cc/trees/layer_tree_settings.h
+++ b/cc/trees/layer_tree_settings.h
@@ -21,7 +21,6 @@ class CC_EXPORT LayerTreeSettings {
bool impl_side_painting;
bool allow_antialiasing;
bool throttle_frame_production;
- bool single_thread_proxy_scheduler;
bool begin_frame_scheduling_enabled;
bool main_frame_before_draw_enabled;
bool main_frame_before_activation_enabled;
diff --git a/cc/trees/single_thread_proxy.cc b/cc/trees/single_thread_proxy.cc
index 46d0814..c254311 100644
--- a/cc/trees/single_thread_proxy.cc
+++ b/cc/trees/single_thread_proxy.cc
@@ -33,11 +33,7 @@ SingleThreadProxy::SingleThreadProxy(LayerTreeHost* layer_tree_host,
layer_tree_host_(layer_tree_host),
client_(client),
next_frame_is_newly_committed_frame_(false),
- inside_draw_(false),
- defer_commits_(false),
- commit_was_deferred_(false),
- commit_requested_(false),
- weak_factory_(this) {
+ inside_draw_(false) {
TRACE_EVENT0("cc", "SingleThreadProxy::SingleThreadProxy");
DCHECK(Proxy::IsMainThread());
DCHECK(layer_tree_host);
@@ -77,26 +73,13 @@ void SingleThreadProxy::SetLayerTreeHostClientReady() {
TRACE_EVENT0("cc", "SingleThreadProxy::SetLayerTreeHostClientReady");
// Scheduling is controlled by the embedder in the single thread case, so
// nothing to do.
- DCHECK(Proxy::IsMainThread());
- DebugScopedSetImplThread impl(this);
- if (layer_tree_host_->settings().single_thread_proxy_scheduler &&
- !scheduler_on_impl_thread_) {
- SchedulerSettings scheduler_settings(layer_tree_host_->settings());
- scheduler_on_impl_thread_ = Scheduler::Create(this,
- scheduler_settings,
- layer_tree_host_->id(),
- MainThreadTaskRunner());
- scheduler_on_impl_thread_->SetCanStart();
- scheduler_on_impl_thread_->SetVisible(layer_tree_host_impl_->visible());
- }
}
void SingleThreadProxy::SetVisible(bool visible) {
TRACE_EVENT0("cc", "SingleThreadProxy::SetVisible");
DebugScopedSetImplThread impl(this);
layer_tree_host_impl_->SetVisible(visible);
- if (scheduler_on_impl_thread_)
- scheduler_on_impl_thread_->SetVisible(layer_tree_host_impl_->visible());
+
// Changing visibility could change ShouldComposite().
UpdateBackgroundAnimateTicking();
}
@@ -123,14 +106,9 @@ void SingleThreadProxy::CreateAndInitializeOutputSurface() {
layer_tree_host_->OnCreateAndInitializeOutputSurfaceAttempted(success);
- if (success) {
- if (scheduler_on_impl_thread_)
- scheduler_on_impl_thread_->DidCreateAndInitializeOutputSurface();
- } else if (Proxy::MainThreadTaskRunner()) {
- Proxy::MainThreadTaskRunner()->PostTask(
- FROM_HERE,
- base::Bind(&SingleThreadProxy::CreateAndInitializeOutputSurface,
- weak_factory_.GetWeakPtr()));
+ if (!success) {
+ // Force another recreation attempt to happen by requesting another commit.
+ SetNeedsCommit();
}
}
@@ -144,40 +122,17 @@ void SingleThreadProxy::SetNeedsAnimate() {
TRACE_EVENT0("cc", "SingleThreadProxy::SetNeedsAnimate");
DCHECK(Proxy::IsMainThread());
client_->ScheduleAnimation();
- SetNeedsCommit();
}
void SingleThreadProxy::SetNeedsUpdateLayers() {
TRACE_EVENT0("cc", "SingleThreadProxy::SetNeedsUpdateLayers");
DCHECK(Proxy::IsMainThread());
- SetNeedsCommit();
+ client_->ScheduleComposite();
}
-void SingleThreadProxy::DoCommit(base::TimeTicks frame_begin_time) {
+void SingleThreadProxy::DoCommit(scoped_ptr<ResourceUpdateQueue> queue) {
TRACE_EVENT0("cc", "SingleThreadProxy::DoCommit");
DCHECK(Proxy::IsMainThread());
- layer_tree_host_->WillBeginMainFrame();
- layer_tree_host_->Layout();
- layer_tree_host_->UpdateClientAnimations(frame_begin_time);
- layer_tree_host_->AnimateLayers(frame_begin_time);
- commit_requested_ = false;
-
- if (PrioritizedResourceManager* contents_texture_manager =
- layer_tree_host_->contents_texture_manager()) {
- contents_texture_manager->UnlinkAndClearEvictedBackings();
- contents_texture_manager->SetMaxMemoryLimitBytes(
- layer_tree_host_impl_->memory_allocation_limit_bytes());
- contents_texture_manager->SetExternalPriorityCutoff(
- layer_tree_host_impl_->memory_allocation_priority_cutoff());
- }
-
- scoped_ptr<ResourceUpdateQueue> queue =
- make_scoped_ptr(new ResourceUpdateQueue);
-
- layer_tree_host_->UpdateLayers(queue.get());
-
- layer_tree_host_->WillCommit();
-
// Commit immediately.
{
DebugScopedSetMainThreadBlocked main_thread_blocked(this);
@@ -211,8 +166,6 @@ void SingleThreadProxy::DoCommit(base::TimeTicks frame_begin_time) {
layer_tree_host_impl_->CommitComplete();
- UpdateBackgroundAnimateTicking();
-
#if DCHECK_IS_ON
// In the single-threaded case, the scale and scroll deltas should never be
// touched on the impl layer tree.
@@ -229,64 +182,32 @@ void SingleThreadProxy::DoCommit(base::TimeTicks frame_begin_time) {
stats_instrumentation->AccumulateAndClearMainThreadStats();
}
layer_tree_host_->CommitComplete();
- layer_tree_host_->DidBeginMainFrame();
- timing_history_.DidCommit();
-
next_frame_is_newly_committed_frame_ = true;
}
void SingleThreadProxy::SetNeedsCommit() {
DCHECK(Proxy::IsMainThread());
- DebugScopedSetImplThread impl(this);
client_->ScheduleComposite();
- if (scheduler_on_impl_thread_)
- scheduler_on_impl_thread_->SetNeedsCommit();
- commit_requested_ = true;
}
void SingleThreadProxy::SetNeedsRedraw(const gfx::Rect& damage_rect) {
TRACE_EVENT0("cc", "SingleThreadProxy::SetNeedsRedraw");
- DCHECK(Proxy::IsMainThread());
- DebugScopedSetImplThread impl(this);
- client_->ScheduleComposite();
SetNeedsRedrawRectOnImplThread(damage_rect);
+ client_->ScheduleComposite();
}
void SingleThreadProxy::SetNextCommitWaitsForActivation() {
// There is no activation here other than commit. So do nothing.
- DCHECK(Proxy::IsMainThread());
}
void SingleThreadProxy::SetDeferCommits(bool defer_commits) {
- DCHECK(Proxy::IsMainThread());
- // Deferring commits only makes sense if there's a scheduler.
- if (!scheduler_on_impl_thread_)
- return;
- if (defer_commits_ == defer_commits)
- return;
-
- if (defer_commits)
- TRACE_EVENT_ASYNC_BEGIN0("cc", "SingleThreadProxy::SetDeferCommits", this);
- else
- TRACE_EVENT_ASYNC_END0("cc", "SingleThreadProxy::SetDeferCommits", this);
-
- defer_commits_ = defer_commits;
- if (!defer_commits_ && commit_was_deferred_) {
- scheduler_on_impl_thread_->NotifyBeginMainFrameStarted();
- scheduler_on_impl_thread_->NotifyReadyToCommit();
- commit_was_deferred_ = false;
- }
+ // Thread-only feature.
+ NOTREACHED();
}
-bool SingleThreadProxy::CommitRequested() const {
- DCHECK(Proxy::IsMainThread());
- return commit_requested_;
-}
+bool SingleThreadProxy::CommitRequested() const { return false; }
-bool SingleThreadProxy::BeginMainFrameRequested() const {
- DCHECK(Proxy::IsMainThread());
- return commit_requested_;
-}
+bool SingleThreadProxy::BeginMainFrameRequested() const { return false; }
size_t SingleThreadProxy::MaxPartialTextureUpdates() const {
return std::numeric_limits<size_t>::max();
@@ -302,7 +223,6 @@ void SingleThreadProxy::Stop() {
BlockingTaskRunner::CapturePostTasks blocked;
layer_tree_host_->DeleteContentsTexturesOnImplThread(
layer_tree_host_impl_->resource_provider());
- scheduler_on_impl_thread_.reset();
layer_tree_host_impl_.reset();
}
layer_tree_host_ = NULL;
@@ -313,19 +233,15 @@ void SingleThreadProxy::OnCanDrawStateChanged(bool can_draw) {
"cc", "SingleThreadProxy::OnCanDrawStateChanged", "can_draw", can_draw);
DCHECK(Proxy::IsImplThread());
UpdateBackgroundAnimateTicking();
- if (scheduler_on_impl_thread_)
- scheduler_on_impl_thread_->SetCanDraw(can_draw);
}
void SingleThreadProxy::NotifyReadyToActivate() {
- // Impl-side painting only.
+ // Thread-only feature.
NOTREACHED();
}
void SingleThreadProxy::SetNeedsRedrawOnImplThread() {
client_->ScheduleComposite();
- if (scheduler_on_impl_thread_)
- scheduler_on_impl_thread_->SetNeedsRedraw();
}
void SingleThreadProxy::SetNeedsAnimateOnImplThread() {
@@ -333,14 +249,17 @@ void SingleThreadProxy::SetNeedsAnimateOnImplThread() {
}
void SingleThreadProxy::SetNeedsManageTilesOnImplThread() {
- // Impl-side painting only.
+ // Thread-only/Impl-side-painting-only feature.
NOTREACHED();
}
void SingleThreadProxy::SetNeedsRedrawRectOnImplThread(
const gfx::Rect& damage_rect) {
+ // TODO(brianderson): Once we move render_widget scheduling into this class,
+ // we can treat redraw requests more efficiently than CommitAndRedraw
+ // requests.
layer_tree_host_impl_->SetViewportDamage(damage_rect);
- SetNeedsRedrawOnImplThread();
+ SetNeedsCommit();
}
void SingleThreadProxy::DidInitializeVisibleTileOnImplThread() {
@@ -350,8 +269,6 @@ void SingleThreadProxy::DidInitializeVisibleTileOnImplThread() {
void SingleThreadProxy::SetNeedsCommitOnImplThread() {
client_->ScheduleComposite();
- if (scheduler_on_impl_thread_)
- scheduler_on_impl_thread_->SetNeedsCommit();
}
void SingleThreadProxy::PostAnimationEventsToMainThreadOnImplThread(
@@ -388,58 +305,66 @@ void SingleThreadProxy::UpdateRendererCapabilitiesOnImplThread() {
layer_tree_host_impl_->GetRendererCapabilities().MainThreadCapabilities();
}
-void SingleThreadProxy::DidActivatePendingTree() {
- // Impl-side painting only.
- NOTREACHED();
-}
-
-void SingleThreadProxy::DidManageTiles() {
- // Impl-side painting only.
- NOTREACHED();
-}
-
void SingleThreadProxy::DidLoseOutputSurfaceOnImplThread() {
TRACE_EVENT0("cc", "SingleThreadProxy::DidLoseOutputSurfaceOnImplThread");
- {
- DebugScopedSetMainThread main(this);
- // 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();
- }
+ // Cause a commit so we can notice the lost context.
+ SetNeedsCommitOnImplThread();
client_->DidAbortSwapBuffers();
- if (scheduler_on_impl_thread_)
- scheduler_on_impl_thread_->DidLoseOutputSurface();
}
void SingleThreadProxy::DidSwapBuffersOnImplThread() {
- TRACE_EVENT0("cc", "SingleThreadProxy::DidSwapBuffersOnImplThread");
- if (scheduler_on_impl_thread_)
- scheduler_on_impl_thread_->DidSwapBuffers();
client_->DidPostSwapBuffers();
}
void SingleThreadProxy::DidSwapBuffersCompleteOnImplThread() {
TRACE_EVENT0("cc", "SingleThreadProxy::DidSwapBuffersCompleteOnImplThread");
- if (scheduler_on_impl_thread_)
- scheduler_on_impl_thread_->DidSwapBuffersComplete();
- layer_tree_host_->DidCompleteSwapBuffers();
-}
-
-void SingleThreadProxy::BeginFrame(const BeginFrameArgs& args) {
- TRACE_EVENT0("cc", "SingleThreadProxy::BeginFrame");
- if (scheduler_on_impl_thread_)
- scheduler_on_impl_thread_->BeginImplFrame(args);
+ 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");
DCHECK(Proxy::IsMainThread());
DCHECK(!layer_tree_host_->output_surface_lost());
- DoCommit(frame_begin_time);
+ layer_tree_host_->AnimateLayers(frame_begin_time);
+
+ if (PrioritizedResourceManager* contents_texture_manager =
+ layer_tree_host_->contents_texture_manager()) {
+ contents_texture_manager->UnlinkAndClearEvictedBackings();
+ contents_texture_manager->SetMaxMemoryLimitBytes(
+ layer_tree_host_impl_->memory_allocation_limit_bytes());
+ contents_texture_manager->SetExternalPriorityCutoff(
+ layer_tree_host_impl_->memory_allocation_priority_cutoff());
+ }
+
+ scoped_ptr<ResourceUpdateQueue> queue =
+ make_scoped_ptr(new ResourceUpdateQueue);
+ layer_tree_host_->UpdateLayers(queue.get());
+ layer_tree_host_->WillCommit();
+ DoCommit(queue.Pass());
+ layer_tree_host_->DidBeginMainFrame();
LayerTreeHostImpl::FrameData frame;
- DoComposite(frame_begin_time, &frame);
+ if (DoComposite(frame_begin_time, &frame)) {
+ {
+ DebugScopedSetMainThreadBlocked main_thread_blocked(this);
+ DebugScopedSetImplThread impl(this);
+
+ // This CapturePostTasks should be destroyed before
+ // DidCommitAndDrawFrame() is called since that goes out to the embedder,
+ // and we want the embedder to receive its callbacks before that.
+ // NOTE: This maintains consistent ordering with the ThreadProxy since
+ // the DidCommitAndDrawFrame() must be post-tasked from the impl thread
+ // there as the main thread is not blocked, so any posted tasks inside
+ // the swap buffers will execute first.
+ BlockingTaskRunner::CapturePostTasks blocked;
+
+ layer_tree_host_impl_->SwapBuffers(frame);
+ }
+ DidSwapFrame();
+ }
}
scoped_ptr<base::Value> SingleThreadProxy::AsValue() const {
@@ -478,11 +403,13 @@ void SingleThreadProxy::UpdateBackgroundAnimateTicking() {
!ShouldComposite() && layer_tree_host_impl_->active_tree()->root_layer());
}
-DrawResult SingleThreadProxy::DoComposite(base::TimeTicks frame_begin_time,
- LayerTreeHostImpl::FrameData* frame) {
+bool SingleThreadProxy::DoComposite(
+ base::TimeTicks frame_begin_time,
+ LayerTreeHostImpl::FrameData* frame) {
TRACE_EVENT0("cc", "SingleThreadProxy::DoComposite");
DCHECK(!layer_tree_host_->output_surface_lost());
+ bool lost_output_surface = false;
{
DebugScopedSetImplThread impl(this);
base::AutoReset<bool> mark_inside(&inside_draw_, true);
@@ -493,11 +420,9 @@ DrawResult SingleThreadProxy::DoComposite(base::TimeTicks frame_begin_time,
// CanDraw() as well.
if (!ShouldComposite()) {
UpdateBackgroundAnimateTicking();
- return DRAW_ABORTED_CANT_DRAW;
+ return false;
}
- timing_history_.DidStartDrawing();
-
layer_tree_host_impl_->Animate(
layer_tree_host_impl_->CurrentFrameTimeTicks());
UpdateBackgroundAnimateTicking();
@@ -507,42 +432,24 @@ DrawResult SingleThreadProxy::DoComposite(base::TimeTicks frame_begin_time,
layer_tree_host_impl_->DrawLayers(frame, frame_begin_time);
layer_tree_host_impl_->DidDrawAllLayers(*frame);
}
+ lost_output_surface = layer_tree_host_impl_->IsContextLost();
bool start_ready_animations = true;
layer_tree_host_impl_->UpdateAnimationState(start_ready_animations);
layer_tree_host_impl_->ResetCurrentFrameTimeForNextFrame();
-
- timing_history_.DidFinishDrawing();
}
- {
- DebugScopedSetImplThread impl(this);
-
- if (layer_tree_host_impl_->IsContextLost()) {
- DidLoseOutputSurfaceOnImplThread();
- } else {
- // This CapturePostTasks should be destroyed before
- // DidCommitAndDrawFrame() is called since that goes out to the embedder,
- // and we want the embedder to receive its callbacks before that.
- // NOTE: This maintains consistent ordering with the ThreadProxy since
- // the DidCommitAndDrawFrame() must be post-tasked from the impl thread
- // there as the main thread is not blocked, so any posted tasks inside
- // the swap buffers will execute first.
- DebugScopedSetMainThreadBlocked main_thread_blocked(this);
-
- BlockingTaskRunner::CapturePostTasks blocked;
- layer_tree_host_impl_->SwapBuffers(*frame);
- }
+ if (lost_output_surface) {
+ layer_tree_host_->DidLoseOutputSurface();
+ return false;
}
- DidCommitAndDrawFrame();
- return DRAW_SUCCESS;
+ return true;
}
-void SingleThreadProxy::DidCommitAndDrawFrame() {
+void SingleThreadProxy::DidSwapFrame() {
if (next_frame_is_newly_committed_frame_) {
- DebugScopedSetMainThread main(this);
next_frame_is_newly_committed_frame_ = false;
layer_tree_host_->DidCommitAndDrawFrame();
}
@@ -550,112 +457,4 @@ void SingleThreadProxy::DidCommitAndDrawFrame() {
bool SingleThreadProxy::CommitPendingForTesting() { return false; }
-scoped_ptr<base::Value> SingleThreadProxy::SchedulerAsValueForTesting() {
- DebugScopedSetImplThread impl(this);
- if (!scheduler_on_impl_thread_)
- return make_scoped_ptr(base::Value::CreateNullValue()).Pass();
- return scheduler_on_impl_thread_->AsValue().Pass();
-}
-
-void SingleThreadProxy::SetNeedsBeginFrame(bool enable) {
- layer_tree_host_impl_->SetNeedsBeginFrame(enable);
-}
-
-void SingleThreadProxy::WillBeginImplFrame(const BeginFrameArgs& args) {
- layer_tree_host_impl_->WillBeginImplFrame(args);
-}
-
-void SingleThreadProxy::ScheduledActionSendBeginMainFrame() {
- TRACE_EVENT0("cc", "SingleThreadProxy::ScheduledActionSendBeginMainFrame");
- if (defer_commits_) {
- DCHECK(!commit_was_deferred_);
- commit_was_deferred_ = true;
- layer_tree_host_->DidDeferCommit();
- return;
- }
- timing_history_.DidBeginMainFrame();
-
- DCHECK(scheduler_on_impl_thread_);
- scheduler_on_impl_thread_->NotifyBeginMainFrameStarted();
- scheduler_on_impl_thread_->NotifyReadyToCommit();
-}
-
-DrawResult SingleThreadProxy::ScheduledActionDrawAndSwapIfPossible() {
- DebugScopedSetImplThread impl(this);
- if (layer_tree_host_impl_->IsContextLost()) {
- DidCommitAndDrawFrame();
- return DRAW_SUCCESS;
- }
-
- LayerTreeHostImpl::FrameData frame;
- return DoComposite(layer_tree_host_impl_->CurrentFrameTimeTicks(), &frame);
-}
-
-DrawResult SingleThreadProxy::ScheduledActionDrawAndSwapForced() {
- NOTREACHED();
- return INVALID_RESULT;
-}
-
-void SingleThreadProxy::ScheduledActionCommit() {
- DebugScopedSetMainThread main(this);
- DoCommit(layer_tree_host_impl_->CurrentFrameTimeTicks());
-}
-
-void SingleThreadProxy::ScheduledActionAnimate() {
- TRACE_EVENT0("cc", "ScheduledActionAnimate");
- layer_tree_host_impl_->Animate(
- layer_tree_host_impl_->CurrentFrameTimeTicks());
-}
-
-void SingleThreadProxy::ScheduledActionUpdateVisibleTiles() {
- // Impl-side painting only.
- NOTREACHED();
-}
-
-void SingleThreadProxy::ScheduledActionActivatePendingTree() {
- // Impl-side painting only.
- NOTREACHED();
-}
-
-void SingleThreadProxy::ScheduledActionBeginOutputSurfaceCreation() {
- DebugScopedSetMainThread main(this);
- DCHECK(scheduler_on_impl_thread_);
- // If possible, create the output surface in a post task. Synchronously
- // creating the output surface makes tests more awkward since this differs
- // from the ThreadProxy behavior. However, sometimes there is no
- // task runner.
- if (Proxy::MainThreadTaskRunner()) {
- Proxy::MainThreadTaskRunner()->PostTask(
- FROM_HERE,
- base::Bind(&SingleThreadProxy::CreateAndInitializeOutputSurface,
- weak_factory_.GetWeakPtr()));
- } else {
- CreateAndInitializeOutputSurface();
- }
-}
-
-void SingleThreadProxy::ScheduledActionManageTiles() {
- // Impl-side painting only.
- NOTREACHED();
-}
-
-void SingleThreadProxy::DidAnticipatedDrawTimeChange(base::TimeTicks time) {
-}
-
-base::TimeDelta SingleThreadProxy::DrawDurationEstimate() {
- return timing_history_.DrawDurationEstimate();
-}
-
-base::TimeDelta SingleThreadProxy::BeginMainFrameToCommitDurationEstimate() {
- return timing_history_.BeginMainFrameToCommitDurationEstimate();
-}
-
-base::TimeDelta SingleThreadProxy::CommitToActivateDurationEstimate() {
- return timing_history_.CommitToActivateDurationEstimate();
-}
-
-void SingleThreadProxy::DidBeginImplFrameDeadline() {
- layer_tree_host_impl_->ResetCurrentFrameTimeForNextFrame();
-}
-
} // namespace cc
diff --git a/cc/trees/single_thread_proxy.h b/cc/trees/single_thread_proxy.h
index fcc04fd..7ad48b4 100644
--- a/cc/trees/single_thread_proxy.h
+++ b/cc/trees/single_thread_proxy.h
@@ -10,10 +10,8 @@
#include "base/time/time.h"
#include "cc/animation/animation_events.h"
#include "cc/output/begin_frame_args.h"
-#include "cc/scheduler/scheduler.h"
#include "cc/trees/layer_tree_host_impl.h"
#include "cc/trees/proxy.h"
-#include "cc/trees/proxy_timing_history.h"
namespace cc {
@@ -22,8 +20,7 @@ class LayerTreeHost;
class LayerTreeHostSingleThreadClient;
class CC_EXPORT SingleThreadProxy : public Proxy,
- NON_EXPORTED_BASE(LayerTreeHostImplClient),
- SchedulerClient {
+ NON_EXPORTED_BASE(LayerTreeHostImplClient) {
public:
static scoped_ptr<Proxy> Create(
LayerTreeHost* layer_tree_host,
@@ -52,25 +49,6 @@ class CC_EXPORT SingleThreadProxy : public Proxy,
virtual void ForceSerializeOnSwapBuffers() OVERRIDE;
virtual scoped_ptr<base::Value> AsValue() const OVERRIDE;
virtual bool CommitPendingForTesting() OVERRIDE;
- virtual scoped_ptr<base::Value> SchedulerAsValueForTesting() OVERRIDE;
-
- // SchedulerClient implementation
- virtual void SetNeedsBeginFrame(bool enable) OVERRIDE;
- virtual void WillBeginImplFrame(const BeginFrameArgs& args) OVERRIDE;
- virtual void ScheduledActionSendBeginMainFrame() OVERRIDE;
- virtual DrawResult ScheduledActionDrawAndSwapIfPossible() OVERRIDE;
- virtual DrawResult ScheduledActionDrawAndSwapForced() OVERRIDE;
- virtual void ScheduledActionCommit() OVERRIDE;
- virtual void ScheduledActionAnimate() OVERRIDE;
- virtual void ScheduledActionUpdateVisibleTiles() OVERRIDE;
- virtual void ScheduledActionActivatePendingTree() OVERRIDE;
- virtual void ScheduledActionBeginOutputSurfaceCreation() OVERRIDE;
- virtual void ScheduledActionManageTiles() OVERRIDE;
- virtual void DidAnticipatedDrawTimeChange(base::TimeTicks time) OVERRIDE;
- virtual base::TimeDelta DrawDurationEstimate() OVERRIDE;
- virtual base::TimeDelta BeginMainFrameToCommitDurationEstimate() OVERRIDE;
- virtual base::TimeDelta CommitToActivateDurationEstimate() OVERRIDE;
- virtual void DidBeginImplFrameDeadline() OVERRIDE;
// LayerTreeHostImplClient implementation
virtual void UpdateRendererCapabilitiesOnImplThread() OVERRIDE;
@@ -81,7 +59,7 @@ class CC_EXPORT SingleThreadProxy : public Proxy,
virtual void SetMaxSwapsPendingOnImplThread(int max) OVERRIDE {}
virtual void DidSwapBuffersOnImplThread() OVERRIDE;
virtual void DidSwapBuffersCompleteOnImplThread() OVERRIDE;
- virtual void BeginFrame(const BeginFrameArgs& args) OVERRIDE;
+ virtual void BeginFrame(const BeginFrameArgs& args) OVERRIDE {}
virtual void OnCanDrawStateChanged(bool can_draw) OVERRIDE;
virtual void NotifyReadyToActivate() OVERRIDE;
virtual void SetNeedsRedrawOnImplThread() OVERRIDE;
@@ -101,8 +79,8 @@ class CC_EXPORT SingleThreadProxy : public Proxy,
virtual void PostDelayedScrollbarFadeOnImplThread(
const base::Closure& start_fade,
base::TimeDelta delay) OVERRIDE {}
- virtual void DidActivatePendingTree() OVERRIDE;
- virtual void DidManageTiles() OVERRIDE;
+ virtual void DidActivatePendingTree() OVERRIDE {}
+ virtual void DidManageTiles() OVERRIDE {}
virtual void SetDebugState(const LayerTreeDebugState& debug_state) OVERRIDE {}
// Attempts to create the context and renderer synchronously. Calls
@@ -116,11 +94,10 @@ class CC_EXPORT SingleThreadProxy : public Proxy,
SingleThreadProxy(LayerTreeHost* layer_tree_host,
LayerTreeHostSingleThreadClient* client);
- void DoCommit(base::TimeTicks frame_begin_time);
- DrawResult DoComposite(base::TimeTicks frame_begin_time,
- LayerTreeHostImpl::FrameData* frame);
- void DoSwap();
- void DidCommitAndDrawFrame();
+ void DoCommit(scoped_ptr<ResourceUpdateQueue> queue);
+ bool DoComposite(base::TimeTicks frame_begin_time,
+ LayerTreeHostImpl::FrameData* frame);
+ void DidSwapFrame();
bool ShouldComposite() const;
void UpdateBackgroundAnimateTicking();
@@ -134,18 +111,9 @@ class CC_EXPORT SingleThreadProxy : public Proxy,
scoped_ptr<LayerTreeHostImpl> layer_tree_host_impl_;
RendererCapabilities renderer_capabilities_for_main_thread_;
- // Accessed from both threads.
- scoped_ptr<Scheduler> scheduler_on_impl_thread_;
- ProxyTimingHistory timing_history_;
-
bool next_frame_is_newly_committed_frame_;
bool inside_draw_;
- bool defer_commits_;
- bool commit_was_deferred_;
- bool commit_requested_;
-
- base::WeakPtrFactory<SingleThreadProxy> weak_factory_;
DISALLOW_COPY_AND_ASSIGN(SingleThreadProxy);
};
diff --git a/cc/trees/thread_proxy.cc b/cc/trees/thread_proxy.cc
index 3dbf0d6..e16adb9 100644
--- a/cc/trees/thread_proxy.cc
+++ b/cc/trees/thread_proxy.cc
@@ -454,10 +454,9 @@ void ThreadProxy::SetNextCommitWaitsForActivation() {
void ThreadProxy::SetDeferCommits(bool defer_commits) {
DCHECK(IsMainThread());
- if (main().defer_commits == defer_commits)
- return;
-
+ DCHECK_NE(main().defer_commits, defer_commits);
main().defer_commits = defer_commits;
+
if (main().defer_commits)
TRACE_EVENT_ASYNC_BEGIN0("cc", "ThreadProxy::SetDeferCommits", this);
else