cc: Post the missed BeginFrame to a new stack

cc/surfaces/display_scheduler.cc

 // Copyright 2015 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/surfaces/display_scheduler.h"
 
 #include <vector>
 
 #include "base/stl_util.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 79 matching lines @@
   } else {
     child_surface_ids_damaged_.insert(surface_id);
 
     // TODO(mithro): Use hints from SetNeedsBeginFrames and SwapAborts.
     all_active_child_surfaces_ready_to_draw_ = base::STLIncludes(
         child_surface_ids_damaged_, child_surface_ids_to_expect_damage_from_);
   }
 
   if (!output_surface_lost_ && !observing_begin_frame_source_) {
     observing_begin_frame_source_ = true;
+    // When we call AddObserver() this will cause a missed BeginFrame to
+    // occur. We need to detect this and not process it immediately in the
+    // same call stack.
+    inside_add_observer_ = true;

[sunnyps, 2016/07/27 02:00:14]

nit: base::AutoReset<bool> mark_inside(&inside_add_observer_, true)

[danakj, 2016/07/27 02:19:04]

Done.

     begin_frame_source_->AddObserver(this);
+    inside_add_observer_ = false;
   }
 
   ScheduleBeginFrameDeadline();
 }
 
 void DisplayScheduler::OutputSurfaceLost() {
   TRACE_EVENT0("cc", "DisplayScheduler::OutputSurfaceLost");
   output_surface_lost_ = true;
   ScheduleBeginFrameDeadline();
 }
@@ skipping 20 matching lines @@
 
   expect_damage_from_root_surface_ = root_surface_damaged_;
   root_surface_damaged_ = false;
 }
 
 bool DisplayScheduler::OnBeginFrameDerivedImpl(const BeginFrameArgs& args) {
   base::TimeTicks now = base::TimeTicks::Now();
   TRACE_EVENT2("cc", "DisplayScheduler::BeginFrame", "args", args.AsValue(),
                "now", now);
 
+  if (inside_add_observer_) {
+    // Repost this so that we don't run a missed BeginFrame on the same
+    // callstack. Otherwise we end up running unexpected scheduler actions
+    // immediately while inside some other action (such as submitting a frame
+    // for a SurfaceFactory).
+    DCHECK_EQ(args.type, BeginFrameArgs::MISSED);
+    DCHECK(missed_begin_frame_task_.IsCancelled());
+    missed_begin_frame_task_.Reset(base::Bind(
+        base::IgnoreResult(&DisplayScheduler::OnBeginFrameDerivedImpl),
+        weak_ptr_factory_.GetWeakPtr(), args));
+    task_runner_->PostTask(FROM_HERE, missed_begin_frame_task_.callback());
+    return true;
+  } else {
+    // If we get another BeginFrame before a posted missed frame, just drop the
+    // missed frame.
+    missed_begin_frame_task_.Cancel();
+  }
+
   // If we get another BeginFrame before the previous deadline,
   // synchronously trigger the previous deadline before progressing.
   if (inside_begin_frame_deadline_interval_) {
     OnBeginFrameDeadline();
   }
 
   // Schedule the deadline.
   current_begin_frame_args_ = args;
   current_begin_frame_args_.deadline -=
       BeginFrameArgs::DefaultEstimatedParentDrawTime();
@@ skipping 150 matching lines @@
 }
 
 void DisplayScheduler::DidSwapBuffersComplete() {
   pending_swaps_--;
   TRACE_EVENT_ASYNC_END1("cc", "DisplayScheduler:pending_swaps", this,
                          "pending_frames", pending_swaps_);
   ScheduleBeginFrameDeadline();
 }
 
 }  // namespace cc