cc: Handle retroactive BeginFrames in the Scheduler.

cc/scheduler/scheduler.h

 // 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.
 
 #ifndef CC_SCHEDULER_SCHEDULER_H_
 #define CC_SCHEDULER_SCHEDULER_H_
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/cancelable_callback.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/time/time.h"
 #include "cc/base/cc_export.h"
 #include "cc/output/begin_frame_args.h"
 #include "cc/scheduler/draw_swap_readback_result.h"
 #include "cc/scheduler/scheduler_settings.h"
 #include "cc/scheduler/scheduler_state_machine.h"
 #include "cc/trees/layer_tree_host.h"
 
 namespace cc {
 
 class Thread;
 
 class SchedulerClient {
  public:
-  virtual void SetNeedsBeginImplFrame(bool enable) = 0;
+  virtual void SetNeedsBeginFrame(bool enable) = 0;
+  virtual void OnBeginImplFrame(const BeginFrameArgs& args) = 0;
   virtual void ScheduledActionSendBeginMainFrame() = 0;
   virtual DrawSwapReadbackResult ScheduledActionDrawAndSwapIfPossible() = 0;
   virtual DrawSwapReadbackResult ScheduledActionDrawAndSwapForced() = 0;
   virtual DrawSwapReadbackResult ScheduledActionDrawAndReadback() = 0;
   virtual void ScheduledActionCommit() = 0;
   virtual void ScheduledActionUpdateVisibleTiles() = 0;
   virtual void ScheduledActionActivatePendingTree() = 0;
   virtual void ScheduledActionBeginOutputSurfaceCreation() = 0;
   virtual void ScheduledActionAcquireLayerTexturesForMainThread() = 0;
   virtual void ScheduledActionManageTiles() = 0;
@@ skipping 65 matching lines @@
   }
 
   bool WillDrawIfNeeded() const;
 
   base::TimeTicks AnticipatedDrawTime() const;
 
   void NotifyBeginMainFrameStarted();
 
   base::TimeTicks LastBeginImplFrameTime();
 
-  void BeginImplFrame(const BeginFrameArgs& args);
+  void BeginFrame(const BeginFrameArgs& args);
+  void BeginRetroFrame();
+  void BeginImplFrame();
   void OnBeginImplFrameDeadline();
   void PollForAnticipatedDrawTriggers();
 
   scoped_ptr<base::Value> StateAsValue() const;
 
   bool IsInsideAction(SchedulerStateMachine::Action action) {
     return inside_action_ == action;
   }
 
   bool IsBeginMainFrameSent() const;
 
  private:
   Scheduler(SchedulerClient* client,
             const SchedulerSettings& scheduler_settings,
             int layer_tree_host_id,
             const scoped_refptr<base::SequencedTaskRunner>& impl_task_runner);
 
   base::TimeTicks AdjustedBeginImplFrameDeadline() const;
   void ScheduleBeginImplFrameDeadline(base::TimeTicks deadline);
-  void SetupNextBeginImplFrameIfNeeded();
+  void SetupNextBeginFrameIfNeeded();
   void ActivatePendingTree();
   void DrawAndSwapIfPossible();
   void DrawAndSwapForced();
   void DrawAndReadback();
   void ProcessScheduledActions();
 
   bool CanCommitAndActivateBeforeDeadline() const;
   void AdvanceCommitStateIfPossible();
 
   bool IsBeginMainFrameSentOrStarted() const;
 
   const SchedulerSettings settings_;
   SchedulerClient* client_;
   int layer_tree_host_id_;
   scoped_refptr<base::SequencedTaskRunner> impl_task_runner_;
 
-  bool last_set_needs_begin_impl_frame_;
-  BeginFrameArgs last_begin_impl_frame_args_;
+  bool last_set_needs_begin_frame_;
+  bool begin_retro_frame_posted_;
+
+  BeginFrameArgs begin_frame_args_;

[Sami, 2014/04/01 13:09:10]

It seems like we could do without this field and instead pass the args to
BeginImplFrame etc. directly. Not sure if it's clearer than what we have now,
but it might make the data flow easier to see. WDYT?

[brianderson, 2014/04/01 19:12:53]

I liked the idea of having access to the original BeginFrame deadline in
addition to the adjusted BeginImplFrame deadline.

I'll change begin_frame_args_ to a deque, which will make the data flow very
explicit and also make long deadlines easier to implement in the future.

[brianderson, 2014/04/02 04:15:57]

I ended up getting rid of begin_frame_args_ like you suggested. We can store it
if we need it in the future. I still created a deque of begin_retro_frame_args
though.

+  BeginFrameArgs begin_retro_frame_args_;
+  BeginFrameArgs begin_impl_frame_args_;
+
   base::CancelableClosure begin_impl_frame_deadline_closure_;
   base::CancelableClosure poll_for_draw_triggers_closure_;
   base::RepeatingTimer<Scheduler> advance_commit_state_timer_;
 
   SchedulerStateMachine state_machine_;
   bool inside_process_scheduled_actions_;
   SchedulerStateMachine::Action inside_action_;
 
   base::WeakPtrFactory<Scheduler> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Scheduler);
 };
 
 }  // namespace cc
 
 #endif  // CC_SCHEDULER_SCHEDULER_H_