cc: Remove SetLayerTreeHostClientReady()

There are no call sites that need this anymore, the behavior
can be achieved in other ways now that OutputSurface creation
has been async for a while.

Also make the default LTH state invisible to match the scheduler
init state. This also avoids races where we'd otherwise schedule
actions when starting the proxy (i.e. LTH creation time)
which were previously delayed until setLTHClientReady().

BUG=538714,539991

TBR=dtrainor@chromium.org

CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel

Review URL: https://codereview.chromium.org/1385043002

Cr-Commit-Position: refs/heads/master@{#352742}

6 files changed, 14 insertions, 54 deletions

diff --git a/cc/scheduler/scheduler.cc b/cc/scheduler/scheduler.cc
index 082fbee..a78e629 100644
--- a/cc/scheduler/scheduler.cc
+++ b/cc/scheduler/scheduler.cc
@@ -131,11 +131,6 @@ void Scheduler::SetEstimatedParentDrawTime(base::TimeDelta draw_time) {
   estimated_parent_draw_time_ = draw_time;
 }
 
-void Scheduler::SetCanStart() {
-  state_machine_.SetCanStart();
-  ProcessScheduledActions();
-}
-
 void Scheduler::SetVisible(bool visible) {
   state_machine_.SetVisible(visible);
   UpdateCompositorTimingHistoryRecordingEnabled();
diff --git a/cc/scheduler/scheduler.h b/cc/scheduler/scheduler.h
index 8e9abce..089e0bed 100644
--- a/cc/scheduler/scheduler.h
+++ b/cc/scheduler/scheduler.h
@@ -75,9 +75,8 @@ class CC_EXPORT Scheduler : public BeginFrameObserverBase {
                              base::TimeDelta interval);
   void SetEstimatedParentDrawTime(base::TimeDelta draw_time);
 
-  void SetCanStart();
-
   void SetVisible(bool visible);
+  bool visible() { return state_machine_.visible(); }
   void SetCanDraw(bool can_draw);
   void NotifyReadyToActivate();
   void NotifyReadyToDraw();
diff --git a/cc/scheduler/scheduler_state_machine.cc b/cc/scheduler/scheduler_state_machine.cc
index 8c61756..661dc7a 100644
--- a/cc/scheduler/scheduler_state_machine.cc
+++ b/cc/scheduler/scheduler_state_machine.cc
@@ -15,7 +15,7 @@ namespace cc {
 
 SchedulerStateMachine::SchedulerStateMachine(const SchedulerSettings& settings)
     : settings_(settings),
-      output_surface_state_(OUTPUT_SURFACE_LOST),
+      output_surface_state_(OUTPUT_SURFACE_NONE),
       begin_impl_frame_state_(BEGIN_IMPL_FRAME_STATE_IDLE),
       begin_main_frame_state_(BEGIN_MAIN_FRAME_STATE_IDLE),
       forced_redraw_state_(FORCED_REDRAW_STATE_IDLE),
@@ -40,7 +40,6 @@ SchedulerStateMachine::SchedulerStateMachine(const SchedulerSettings& settings)
       needs_prepare_tiles_(false),
       needs_begin_main_frame_(false),
       visible_(false),
-      can_start_(false),
       can_draw_(false),
       has_pending_tree_(false),
       pending_tree_is_ready_for_activation_(false),
@@ -60,10 +59,10 @@ SchedulerStateMachine::SchedulerStateMachine(const SchedulerSettings& settings)
 const char* SchedulerStateMachine::OutputSurfaceStateToString(
     OutputSurfaceState state) {
   switch (state) {
+    case OUTPUT_SURFACE_NONE:
+      return "OUTPUT_SURFACE_NONE";
     case OUTPUT_SURFACE_ACTIVE:
       return "OUTPUT_SURFACE_ACTIVE";
-    case OUTPUT_SURFACE_LOST:
-      return "OUTPUT_SURFACE_LOST";
     case OUTPUT_SURFACE_CREATING:
       return "OUTPUT_SURFACE_CREATING";
     case OUTPUT_SURFACE_WAITING_FOR_FIRST_COMMIT:
@@ -225,7 +224,6 @@ void SchedulerStateMachine::AsValueInto(
   state->SetBoolean("needs_prepare_tiles", needs_prepare_tiles_);
   state->SetBoolean("needs_begin_main_frame", needs_begin_main_frame_);
   state->SetBoolean("visible", visible_);
-  state->SetBoolean("can_start", can_start_);
   state->SetBoolean("can_draw", can_draw_);
   state->SetBoolean("has_pending_tree", has_pending_tree_);
   state->SetBoolean("pending_tree_is_ready_for_activation",
@@ -257,7 +255,7 @@ bool SchedulerStateMachine::PendingDrawsShouldBeAborted() const {
   // draws will be aborted. However, when the embedder is Android WebView,
   // software draws could be scheduled by the Android OS at any time and draws
   // should not be aborted in this case.
-  bool is_output_surface_lost = (output_surface_state_ == OUTPUT_SURFACE_LOST);
+  bool is_output_surface_lost = (output_surface_state_ == OUTPUT_SURFACE_NONE);
   if (settings_.using_synchronous_renderer_compositor)
     return is_output_surface_lost || !can_draw_;
 
@@ -274,7 +272,7 @@ bool SchedulerStateMachine::PendingActivationsShouldBeForced() const {
   // There is no output surface to trigger our activations.
   // If we do not force activations to make forward progress, we might deadlock
   // with the main thread.
-  if (output_surface_state_ == OUTPUT_SURFACE_LOST)
+  if (output_surface_state_ == OUTPUT_SURFACE_NONE)
     return true;
 
   // If we're not visible, we should force activation.
@@ -294,10 +292,6 @@ bool SchedulerStateMachine::ShouldBeginOutputSurfaceCreation() const {
   if (!visible_)
     return false;
 
-  // Don't try to initialize too early.
-  if (!can_start_)
-    return false;
-
   // We only want to start output surface initialization after the
   // previous commit is complete.
   if (begin_main_frame_state_ != BEGIN_MAIN_FRAME_STATE_IDLE)
@@ -317,7 +311,7 @@ bool SchedulerStateMachine::ShouldBeginOutputSurfaceCreation() const {
 
   // We need to create the output surface if we don't have one and we haven't
   // started creating one yet.
-  return output_surface_state_ == OUTPUT_SURFACE_LOST;
+  return output_surface_state_ == OUTPUT_SURFACE_NONE;
 }
 
 bool SchedulerStateMachine::ShouldDraw() const {
@@ -676,7 +670,7 @@ void SchedulerStateMachine::WillPrepareTiles() {
 }
 
 void SchedulerStateMachine::WillBeginOutputSurfaceCreation() {
-  DCHECK_EQ(output_surface_state_, OUTPUT_SURFACE_LOST);
+  DCHECK_EQ(output_surface_state_, OUTPUT_SURFACE_NONE);
   output_surface_state_ = OUTPUT_SURFACE_CREATING;
 
   // The following DCHECKs make sure we are in the proper quiescent state.
@@ -1063,10 +1057,10 @@ void SchedulerStateMachine::DidPrepareTiles() {
 }
 
 void SchedulerStateMachine::DidLoseOutputSurface() {
-  if (output_surface_state_ == OUTPUT_SURFACE_LOST ||
+  if (output_surface_state_ == OUTPUT_SURFACE_NONE ||
       output_surface_state_ == OUTPUT_SURFACE_CREATING)
     return;
-  output_surface_state_ = OUTPUT_SURFACE_LOST;
+  output_surface_state_ = OUTPUT_SURFACE_NONE;
   needs_redraw_ = false;
   wait_for_ready_to_draw_ = false;
 }
@@ -1102,7 +1096,7 @@ void SchedulerStateMachine::NotifyBeginMainFrameStarted() {
 
 bool SchedulerStateMachine::HasInitializedOutputSurface() const {
   switch (output_surface_state_) {
-    case OUTPUT_SURFACE_LOST:
+    case OUTPUT_SURFACE_NONE:
     case OUTPUT_SURFACE_CREATING:
       return false;
 
diff --git a/cc/scheduler/scheduler_state_machine.h b/cc/scheduler/scheduler_state_machine.h
index d84211a..c188941 100644
--- a/cc/scheduler/scheduler_state_machine.h
+++ b/cc/scheduler/scheduler_state_machine.h
@@ -42,8 +42,8 @@ class CC_EXPORT SchedulerStateMachine {
   explicit SchedulerStateMachine(const SchedulerSettings& settings);
 
   enum OutputSurfaceState {
+    OUTPUT_SURFACE_NONE,
     OUTPUT_SURFACE_ACTIVE,
-    OUTPUT_SURFACE_LOST,
     OUTPUT_SURFACE_CREATING,
     OUTPUT_SURFACE_WAITING_FOR_FIRST_COMMIT,
     OUTPUT_SURFACE_WAITING_FOR_FIRST_ACTIVATION,
@@ -216,11 +216,6 @@ class CC_EXPORT SchedulerStateMachine {
   // from NextAction if the client rejects the BeginMainFrame message.
   void BeginMainFrameAborted(CommitEarlyOutReason reason);
 
-  // Set that we can create the first OutputSurface and start the scheduler.
-  void SetCanStart() { can_start_ = true; }
-  // Allow access of the can_start_ state in tests.
-  bool CanStartForTesting() const { return can_start_; }
-
   // Indicates production should be skipped to recover latency.
   void SetSkipNextBeginMainFrameToReduceLatency();
 
@@ -324,7 +319,6 @@ class CC_EXPORT SchedulerStateMachine {
   bool needs_prepare_tiles_;
   bool needs_begin_main_frame_;
   bool visible_;
-  bool can_start_;
   bool can_draw_;
   bool has_pending_tree_;
   bool pending_tree_is_ready_for_activation_;
diff --git a/cc/scheduler/scheduler_state_machine_unittest.cc b/cc/scheduler/scheduler_state_machine_unittest.cc
index 6d00594..7d9605f 100644
--- a/cc/scheduler/scheduler_state_machine_unittest.cc
+++ b/cc/scheduler/scheduler_state_machine_unittest.cc
@@ -51,7 +51,6 @@
   }
 
 #define SET_UP_STATE(state)                                         \
-  state.SetCanStart();                                              \
   state.SetVisible(true);                                           \
   EXPECT_ACTION_UPDATE_STATE(                                       \
       SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION); \
@@ -205,7 +204,6 @@ class StateMachine : public SchedulerStateMachine {
 TEST(SchedulerStateMachineTest, BeginFrameNeeded) {
   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
-  state.SetCanStart();
   state.SetVisible(true);
   EXPECT_ACTION_UPDATE_STATE(
       SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
@@ -254,7 +252,6 @@ TEST(SchedulerStateMachineTest, TestNextActionBeginsMainFrameIfNeeded) {
   // If no commit needed, do nothing.
   {
     StateMachine state(default_scheduler_settings);
-    state.SetCanStart();
     state.SetVisible(true);
     EXPECT_ACTION_UPDATE_STATE(
         SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
@@ -275,13 +272,12 @@ TEST(SchedulerStateMachineTest, TestNextActionBeginsMainFrameIfNeeded) {
     EXPECT_FALSE(state.NeedsCommit());
   }
 
-  // If commit requested but can_start is still false, do nothing.
+  // If commit requested but not visible yet, do nothing.
   {
     StateMachine state(default_scheduler_settings);
     state.SetBeginMainFrameState(
         SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_IDLE);
     state.SetNeedsRedraw(false);
-    state.SetVisible(true);
     state.SetNeedsBeginMainFrame();
 
     EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
@@ -300,7 +296,6 @@ TEST(SchedulerStateMachineTest, TestNextActionBeginsMainFrameIfNeeded) {
     StateMachine state(default_scheduler_settings);
     state.SetBeginMainFrameState(
         SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_IDLE);
-    state.SetCanStart();
     state.SetVisible(true);
     EXPECT_ACTION_UPDATE_STATE(
         SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
@@ -328,7 +323,6 @@ TEST(SchedulerStateMachineTest, TestNextActionBeginsMainFrameIfNeeded) {
     StateMachine state(default_scheduler_settings);
     state.SetBeginMainFrameState(
         SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_IDLE);
-    state.SetCanStart();
     state.SetVisible(true);
     EXPECT_ACTION_UPDATE_STATE(
         SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
@@ -720,7 +714,6 @@ TEST(SchedulerStateMachineTest, TestNextActionDrawsOnBeginImplFrame) {
   for (size_t i = 0; i < num_begin_main_frame_states; ++i) {
     for (size_t j = 0; j < num_begin_impl_frame_states; ++j) {
       StateMachine state(default_scheduler_settings);
-      state.SetCanStart();
       state.SetVisible(true);
       EXPECT_ACTION_UPDATE_STATE(
           SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
@@ -749,7 +742,6 @@ TEST(SchedulerStateMachineTest, TestNextActionDrawsOnBeginImplFrame) {
   // except if we're ready to commit, in which case we expect a commit first.
   for (size_t i = 0; i < num_begin_main_frame_states; ++i) {
     StateMachine state(default_scheduler_settings);
-    state.SetCanStart();
     state.SetVisible(true);
     EXPECT_ACTION_UPDATE_STATE(
         SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
@@ -790,7 +782,6 @@ TEST(SchedulerStateMachineTest, TestNoBeginMainFrameStatesRedrawWhenInvisible) {
     // There shouldn't be any drawing regardless of BeginImplFrame.
     for (size_t j = 0; j < 2; ++j) {
       StateMachine state(default_scheduler_settings);
-      state.SetCanStart();
       state.SetVisible(true);
       EXPECT_ACTION_UPDATE_STATE(
           SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
@@ -827,7 +818,6 @@ TEST(SchedulerStateMachineTest, TestCanRedraw_StopsDraw) {
     // There shouldn't be any drawing regardless of BeginImplFrame.
     for (size_t j = 0; j < 2; ++j) {
       StateMachine state(default_scheduler_settings);
-      state.SetCanStart();
       state.SetVisible(true);
       EXPECT_ACTION_UPDATE_STATE(
           SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
@@ -850,7 +840,6 @@ TEST(SchedulerStateMachineTest,
      TestCanRedrawWithWaitingForFirstDrawMakesProgress) {
   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
-  state.SetCanStart();
   state.SetVisible(true);
   EXPECT_ACTION_UPDATE_STATE(
       SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
@@ -1195,7 +1184,6 @@ TEST(SchedulerStateMachineTest, TestFullCycleWithCommitRequestInbetween) {
 TEST(SchedulerStateMachineTest, TestNoRequestCommitWhenInvisible) {
   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
-  state.SetCanStart();
   state.SetVisible(true);
   EXPECT_ACTION_UPDATE_STATE(
       SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
@@ -1209,7 +1197,6 @@ TEST(SchedulerStateMachineTest, TestNoRequestCommitWhenInvisible) {
 TEST(SchedulerStateMachineTest, TestNoRequestOutputSurfaceWhenInvisible) {
   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
-  state.SetCanStart();
   // We should not request an OutputSurface when we are still invisible.
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
   state.SetVisible(true);
@@ -1283,7 +1270,6 @@ TEST(SchedulerStateMachineTest, TestAbortBeginMainFrameBecauseInvisible) {
 TEST(SchedulerStateMachineTest, TestAbortBeginMainFrameBecauseCommitNotNeeded) {
   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
-  state.SetCanStart();
   state.SetVisible(true);
   EXPECT_ACTION_UPDATE_STATE(
       SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
@@ -1331,7 +1317,6 @@ TEST(SchedulerStateMachineTest, TestAbortBeginMainFrameBecauseCommitNotNeeded) {
 TEST(SchedulerStateMachineTest, TestFirstContextCreation) {
   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
-  state.SetCanStart();
   state.SetVisible(true);
   state.SetCanDraw(true);
 
@@ -1388,7 +1373,7 @@ TEST(SchedulerStateMachineTest,
             state.NextAction());
   state.DidLoseOutputSurface();
   EXPECT_EQ(state.output_surface_state(),
-            SchedulerStateMachine::OUTPUT_SURFACE_LOST);
+            SchedulerStateMachine::OUTPUT_SURFACE_NONE);
 
   EXPECT_ACTION_UPDATE_STATE(
       SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
@@ -1695,7 +1680,6 @@ TEST(SchedulerStateMachineTest,
 TEST(SchedulerStateMachineTest, TestNoBeginFrameNeededWhenInvisible) {
   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
-  state.SetCanStart();
   state.SetVisible(true);
   EXPECT_ACTION_UPDATE_STATE(
       SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
@@ -1716,7 +1700,6 @@ TEST(SchedulerStateMachineTest, TestNoBeginFrameNeededWhenInvisible) {
 TEST(SchedulerStateMachineTest, TestNoBeginMainFrameWhenInvisible) {
   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
-  state.SetCanStart();
   state.SetVisible(true);
   EXPECT_ACTION_UPDATE_STATE(
       SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
@@ -1738,7 +1721,6 @@ TEST(SchedulerStateMachineTest, TestNoBeginMainFrameWhenInvisible) {
 TEST(SchedulerStateMachineTest, TestFinishCommitWhenCommitInProgress) {
   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
-  state.SetCanStart();
   state.SetVisible(true);
   EXPECT_ACTION_UPDATE_STATE(
       SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
diff --git a/cc/scheduler/scheduler_unittest.cc b/cc/scheduler/scheduler_unittest.cc
index 669ed3b..0d39262 100644
--- a/cc/scheduler/scheduler_unittest.cc
+++ b/cc/scheduler/scheduler_unittest.cc
@@ -289,8 +289,6 @@ class SchedulerTest : public testing::Test {
     EXPECT_FALSE(client_->needs_begin_frames());
 
     // Start the initial output surface creation.
-    EXPECT_FALSE(scheduler_->CanStart());
-    scheduler_->SetCanStart();
     scheduler_->SetVisible(true);
     scheduler_->SetCanDraw(true);
     EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client_);
@@ -411,7 +409,6 @@ class SchedulerTest : public testing::Test {
 TEST_F(SchedulerTest, InitializeOutputSurfaceDoesNotBeginImplFrame) {
   scheduler_settings_.use_external_begin_frame_source = true;
   SetUpScheduler(false);
-  scheduler_->SetCanStart();
   scheduler_->SetVisible(true);
   scheduler_->SetCanDraw(true);
 
@@ -2599,7 +2596,6 @@ TEST_F(SchedulerTest, DidLoseOutputSurfaceAfterOutputSurfaceIsInitialized) {
   scheduler_settings_.use_external_begin_frame_source = true;
   SetUpScheduler(false);
 
-  scheduler_->SetCanStart();
   scheduler_->SetVisible(true);
   scheduler_->SetCanDraw(true);