cc: Implement deadine scheduling disabled by default

cc/scheduler/scheduler_state_machine_unittest.cc

 // Copyright 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/scheduler/scheduler_state_machine.h"
 
 #include "cc/scheduler/scheduler.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-#define EXPECT_ACTION_UPDATE_STATE(action)                   \
-  EXPECT_EQ(action, state.NextAction()) << *state.AsValue(); \
-  state.UpdateState(action);
+#define EXPECT_ACTION_UPDATE_STATE(action)                                 \
+  EXPECT_EQ(action, state.NextAction()) << *state.ToValue();               \
+  if (action == SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE || \

[Sami, 2013/08/30 13:49:06]

Nit: maybe separate this part into a normal function?

[brianderson, 2013/09/03 22:51:47]

I wanted to do that, but then we lose information regarding the line number that
fails.

+      action == SchedulerStateMachine::ACTION_DRAW_AND_SWAP_FORCED) {      \
+    if (SchedulerStateMachine::COMMIT_STATE_WAITING_FOR_FIRST_DRAW ==      \
+            state.CommitState() &&                                         \
+        SchedulerStateMachine::OUTPUT_SURFACE_ACTIVE !=                    \
+            state.output_surface_state())                                  \
+      return;                                                              \
+    EXPECT_EQ(SchedulerStateMachine::BEGIN_FRAME_STATE_INSIDE_DEADLINE,    \
+              state.begin_frame_state())                                   \
+        << *state.ToValue();                                               \
+  }                                                                        \
+  state.UpdateState(action);                                               \
+  if (action == SchedulerStateMachine::ACTION_NONE) {                      \
+    state.AdvanceBeginFrameStateWhenNoActionsRemain();                     \
+  }
 
 namespace cc {
 
 namespace {
 
+const SchedulerStateMachine::BeginFrameState all_begin_frame_states[] = {
+    SchedulerStateMachine::BEGIN_FRAME_STATE_IDLE,
+    SchedulerStateMachine::BEGIN_FRAME_STATE_INSIDE_BEGIN_FRAME,
+    SchedulerStateMachine::BEGIN_FRAME_STATE_DEADLINE_PENDING,
+    SchedulerStateMachine::BEGIN_FRAME_STATE_INSIDE_DEADLINE, };
+
 const SchedulerStateMachine::CommitState all_commit_states[] = {
-  SchedulerStateMachine::COMMIT_STATE_IDLE,
-  SchedulerStateMachine::COMMIT_STATE_FRAME_IN_PROGRESS,
-  SchedulerStateMachine::COMMIT_STATE_READY_TO_COMMIT,
-  SchedulerStateMachine::COMMIT_STATE_WAITING_FOR_FIRST_DRAW
-};
+    SchedulerStateMachine::COMMIT_STATE_IDLE,
+    SchedulerStateMachine::COMMIT_STATE_FRAME_IN_PROGRESS,
+    SchedulerStateMachine::COMMIT_STATE_READY_TO_COMMIT,
+    SchedulerStateMachine::COMMIT_STATE_WAITING_FOR_ACTIVATION,
+    SchedulerStateMachine::COMMIT_STATE_WAITING_FOR_FIRST_DRAW, };
 
 // Exposes the protected state fields of the SchedulerStateMachine for testing
 class StateMachine : public SchedulerStateMachine {
  public:
   explicit StateMachine(const SchedulerSettings& scheduler_settings)
       : SchedulerStateMachine(scheduler_settings) {}
 
   void CreateAndInitializeOutputSurfaceWithActivatedCommit() {
     DidCreateAndInitializeOutputSurface();
     output_surface_state_ = OUTPUT_SURFACE_ACTIVE;
   }
 
   void SetCommitState(CommitState cs) { commit_state_ = cs; }
   CommitState CommitState() const { return commit_state_; }
 
+  void SetBeginFrameState(BeginFrameState bfs) { begin_frame_state_ = bfs; }
+  BeginFrameState begin_frame_state() const { return begin_frame_state_; }
+
   OutputSurfaceState output_surface_state() { return output_surface_state_; }
 
   bool NeedsCommit() const { return needs_commit_; }
 
   void SetNeedsRedraw(bool b) { needs_redraw_ = b; }
   bool NeedsRedraw() const { return needs_redraw_; }
 
   void SetNeedsForcedRedrawForTimeout(bool b) {
     forced_redraw_state_ = FORCED_REDRAW_STATE_WAITING_FOR_COMMIT;
     commit_state_ = COMMIT_STATE_WAITING_FOR_FIRST_DRAW;
@@ skipping 1361 matching lines @@
   EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.NextAction());
 
   state.BeginFrameAbortedByMainThread(true);
 
   EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.NextAction());
   EXPECT_FALSE(state.PendingDrawsShouldBeAborted());
 }
 
 }  // namespace
 }  // namespace cc