cc: Add support for sending BeginFrames for video.

cc/scheduler/scheduler_state_machine.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 "base/format_macros.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 34 matching lines @@
       has_pending_tree_(false),
       pending_tree_is_ready_for_activation_(false),
       active_tree_needs_first_draw_(false),
       did_create_and_initialize_first_output_surface_(false),
       impl_latency_takes_priority_(false),
       skip_next_begin_main_frame_to_reduce_latency_(false),
       skip_begin_main_frame_to_reduce_latency_(false),
       continuous_painting_(false),
       children_need_begin_frames_(false),
       defer_commits_(false),
+      video_needs_begin_frames_(false),
       last_commit_had_no_updates_(false),
       wait_for_active_tree_ready_to_draw_(false),
       did_request_swap_in_last_frame_(false),
       did_perform_swap_in_last_draw_(false) {
 }
 
 const char* SchedulerStateMachine::OutputSurfaceStateToString(
     OutputSurfaceState state) {
   switch (state) {
     case OUTPUT_SURFACE_ACTIVE:
@@ skipping 171 matching lines @@
   state->SetBoolean("impl_latency_takes_priority",
                     impl_latency_takes_priority_);
   state->SetBoolean("main_thread_is_in_high_latency_mode",
                     MainThreadIsInHighLatencyMode());
   state->SetBoolean("skip_begin_main_frame_to_reduce_latency",
                     skip_begin_main_frame_to_reduce_latency_);
   state->SetBoolean("skip_next_begin_main_frame_to_reduce_latency",
                     skip_next_begin_main_frame_to_reduce_latency_);
   state->SetBoolean("continuous_painting", continuous_painting_);
   state->SetBoolean("children_need_begin_frames", children_need_begin_frames_);
+  state->SetBoolean("video_needs_begin_frames", video_needs_begin_frames_);
   state->SetBoolean("defer_commits", defer_commits_);
   state->SetBoolean("last_commit_had_no_updates", last_commit_had_no_updates_);
   state->SetBoolean("did_request_swap_in_last_frame",
                     did_request_swap_in_last_frame_);
   state->SetBoolean("did_perform_swap_in_last_draw",
                     did_perform_swap_in_last_draw_);
   state->EndDictionary();
 }
 
 bool SchedulerStateMachine::PendingDrawsShouldBeAborted() const {
@@ skipping 452 matching lines @@
 void SchedulerStateMachine::SetSkipNextBeginMainFrameToReduceLatency() {
   TRACE_EVENT_INSTANT0("cc",
                        "Scheduler: SkipNextBeginMainFrameToReduceLatency",
                        TRACE_EVENT_SCOPE_THREAD);
   skip_next_begin_main_frame_to_reduce_latency_ = true;
 }
 
 bool SchedulerStateMachine::BeginFrameRequiredForChildren() const {
   return children_need_begin_frames_;
 }
+bool SchedulerStateMachine::BeginFrameNeededForVideo() const {
+  return video_needs_begin_frames_;
+}
 
 bool SchedulerStateMachine::BeginFrameNeeded() const {
   // We can't handle BeginFrames when output surface isn't initialized.
   // TODO(brianderson): Support output surface creation inside a BeginFrame.
   if (!HasInitializedOutputSurface())
     return false;
 
   // If we are not visible, we don't need BeginFrame messages.
   if (!visible_)
     return false;
 
   return (BeginFrameRequiredForAction() || BeginFrameRequiredForChildren() ||
-          ProactiveBeginFrameWanted());
+          BeginFrameNeededForVideo() || ProactiveBeginFrameWanted());

[brianderson, 2015/04/16 01:42:23]

To confirm: Video doesn't need BeginFrames when the Renderer isn't visible
because it has it's own timeout mechanism?

[sunnyps, 2015/04/16 20:56:11]

Yes, video doesn't need BeginFrames when the renderer is invisible.

 }
 
 void SchedulerStateMachine::SetChildrenNeedBeginFrames(
     bool children_need_begin_frames) {
   children_need_begin_frames_ = children_need_begin_frames;
 }
 
+void SchedulerStateMachine::SetVideoNeedsBeginFrames(
+    bool video_needs_begin_frames) {
+  video_needs_begin_frames_ = video_needs_begin_frames;
+}
+
 void SchedulerStateMachine::SetDeferCommits(bool defer_commits) {
   defer_commits_ = defer_commits;
 }
 
 // These are the cases where we require a BeginFrame message to make progress
 // on requested actions.
 bool SchedulerStateMachine::BeginFrameRequiredForAction() const {
   // The forced draw respects our normal draw scheduling, so we need to
   // request a BeginImplFrame for it.
   if (forced_redraw_state_ == FORCED_REDRAW_STATE_WAITING_FOR_DRAW)
@@ skipping 368 matching lines @@
       static_cast<int>(begin_impl_frame_state_),
       static_cast<int>(commit_state_),
       has_pending_tree_ ? 'T' : 'F',
       pending_tree_is_ready_for_activation_ ? 'T' : 'F',
       active_tree_needs_first_draw_ ? 'T' : 'F',
       max_pending_swaps_,
       pending_swaps_);
 }
 
 }  // namespace cc