cc: Send all begin frames using a PostTask.

cc/scheduler/begin_frame_source.cc

 // Copyright 2014 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/begin_frame_source.h"
 
 #include <stddef.h>
 
 #include "base/auto_reset.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
-#include "cc/scheduler/delay_based_time_source.h"
 #include "cc/scheduler/scheduler.h"
 
 namespace cc {
 
 namespace {
 // kDoubleTickDivisor prevents the SyntheticBFS from sending BeginFrames too
 // often to an observer.
 static const double kDoubleTickDivisor = 2.0;
 }
 
 // BeginFrameObserverBase -----------------------------------------------
 BeginFrameObserverBase::BeginFrameObserverBase()
-    : last_begin_frame_args_(), dropped_begin_frame_args_(0) {
-}
+    : last_begin_frame_args_(), dropped_begin_frame_args_(0) {}
 
 const BeginFrameArgs& BeginFrameObserverBase::LastUsedBeginFrameArgs() const {
   return last_begin_frame_args_;
 }
 void BeginFrameObserverBase::OnBeginFrame(const BeginFrameArgs& args) {
   DCHECK(args.IsValid());
   DCHECK(args.frame_time >= last_begin_frame_args_.frame_time);
   bool used = OnBeginFrameDerivedImpl(args);
   if (used) {
     last_begin_frame_args_ = args;
   } else {
     ++dropped_begin_frame_args_;
   }
 }
 
 // SyntheticBeginFrameSource ---------------------------------------------
 SyntheticBeginFrameSource::~SyntheticBeginFrameSource() = default;
 
 // BackToBackBeginFrameSource --------------------------------------------
 BackToBackBeginFrameSource::BackToBackBeginFrameSource(
-    std::unique_ptr<DelayBasedTimeSource> time_source)
-    : time_source_(std::move(time_source)), weak_factory_(this) {
-  time_source_->SetClient(this);
-  // The time_source_ ticks immediately, so we SetActive(true) for a single
-  // tick when we need it, and keep it as SetActive(false) otherwise.
-  time_source_->SetTimebaseAndInterval(base::TimeTicks(), base::TimeDelta());
-}
+    base::SingleThreadTaskRunner* task_runner)
+    : BackToBackBeginFrameSource(task_runner, nullptr) {}
+
+BackToBackBeginFrameSource::BackToBackBeginFrameSource(
+    base::SingleThreadTaskRunner* task_runner,
+    base::TickClock* clock)
+    : task_runner_(task_runner), clock_(clock), weak_factory_(this) {}
 
 BackToBackBeginFrameSource::~BackToBackBeginFrameSource() = default;
 
 void BackToBackBeginFrameSource::AddObserver(BeginFrameObserver* obs) {
   DCHECK(obs);
   DCHECK(observers_.find(obs) == observers_.end());
   observers_.insert(obs);
-  pending_begin_frame_observers_.insert(obs);
+  if (pending_observers_.empty()) {
+    DCHECK(begin_frame_callback_.IsCancelled());
+    begin_frame_callback_.Reset(
+        base::Bind(&BackToBackBeginFrameSource::SendBeginFrame,
+                   weak_factory_.GetWeakPtr()));
+    task_runner_->PostTask(FROM_HERE, begin_frame_callback_.callback());
+  }
+  pending_observers_.insert(obs);
   obs->OnBeginFrameSourcePausedChanged(false);
-  time_source_->SetActive(true);
 }
 
 void BackToBackBeginFrameSource::RemoveObserver(BeginFrameObserver* obs) {
   DCHECK(obs);
   DCHECK(observers_.find(obs) != observers_.end());
   observers_.erase(obs);
-  pending_begin_frame_observers_.erase(obs);
-  if (observers_.empty())
-    time_source_->SetActive(false);
+  pending_observers_.erase(obs);
+  if (pending_observers_.empty())
+    begin_frame_callback_.Cancel();
 }
 
 void BackToBackBeginFrameSource::DidFinishFrame(BeginFrameObserver* obs,
                                                 size_t remaining_frames) {
   if (remaining_frames == 0 && observers_.find(obs) != observers_.end()) {
-    pending_begin_frame_observers_.insert(obs);
-    time_source_->SetActive(true);
+    if (pending_observers_.empty()) {
+      DCHECK(begin_frame_callback_.IsCancelled());
+      begin_frame_callback_.Reset(
+          base::Bind(&BackToBackBeginFrameSource::SendBeginFrame,
+                     weak_factory_.GetWeakPtr()));
+      task_runner_->PostTask(FROM_HERE, begin_frame_callback_.callback());
+    }
+    pending_observers_.insert(obs);
   }
 }
 
-void BackToBackBeginFrameSource::OnTimerTick() {
-  base::TimeTicks frame_time = time_source_->LastTickTime();
+void BackToBackBeginFrameSource::SendBeginFrame() {
+  DCHECK(!pending_observers_.empty());
+  begin_frame_callback_.Cancel();
+  std::unordered_set<BeginFrameObserver*> pending_observers;
+  pending_observers.swap(pending_observers_);
+
+  base::TimeTicks frame_time =
+      clock_ ? clock_->NowTicks() : base::TimeTicks::Now();

[brianderson, 2016/07/13 21:14:49]

Maybe use a base::DefaultTickClock instead of checking for NULL?

[sunnyps, 2016/07/13 21:24:53]

I tried that but then DelayBasedTimeSource ended up owning the clock (unless you
want to instantiate a base::DefaultTickClock everywhere) which is fine except
that tests instantiate both back to back and delay based begin frame sources.
That can obviously be worked around and I'll probably do that.

   base::TimeDelta default_interval = BeginFrameArgs::DefaultInterval();
   BeginFrameArgs args = BeginFrameArgs::Create(
       BEGINFRAME_FROM_HERE, frame_time, frame_time + default_interval,
       default_interval, BeginFrameArgs::NORMAL);
 
-  // This must happen after getting the LastTickTime() from the time source.
-  time_source_->SetActive(false);
-
-  std::unordered_set<BeginFrameObserver*> pending_observers;
-  pending_observers.swap(pending_begin_frame_observers_);
   for (BeginFrameObserver* obs : pending_observers)
     obs->OnBeginFrame(args);
 }
 
 // DelayBasedBeginFrameSource ---------------------------------------------
 DelayBasedBeginFrameSource::DelayBasedBeginFrameSource(
-    std::unique_ptr<DelayBasedTimeSource> time_source)
-    : time_source_(std::move(time_source)) {
+    base::SingleThreadTaskRunner* task_runner)
+    : DelayBasedBeginFrameSource(task_runner, nullptr) {}
+
+DelayBasedBeginFrameSource::DelayBasedBeginFrameSource(
+    base::SingleThreadTaskRunner* task_runner,
+    base::TickClock* clock)
+    : time_source_(new DelayBasedTimeSource(task_runner, clock)),
+      task_runner_(task_runner),
+      weak_factory_(this) {
   time_source_->SetClient(this);
 }
 
 DelayBasedBeginFrameSource::~DelayBasedBeginFrameSource() = default;
 
 void DelayBasedBeginFrameSource::OnUpdateVSyncParameters(
     base::TimeTicks timebase,
     base::TimeDelta interval) {
   if (!authoritative_interval_.is_zero()) {
     interval = authoritative_interval_;
@@ skipping 20 matching lines @@
                                 time_source_->Interval(), type);
 }
 
 void DelayBasedBeginFrameSource::AddObserver(BeginFrameObserver* obs) {
   DCHECK(obs);
   DCHECK(observers_.find(obs) == observers_.end());
 
   observers_.insert(obs);
   obs->OnBeginFrameSourcePausedChanged(false);
   time_source_->SetActive(true);
-  BeginFrameArgs args = CreateBeginFrameArgs(
-      time_source_->NextTickTime() - time_source_->Interval(),
-      BeginFrameArgs::MISSED);
-  BeginFrameArgs last_args = obs->LastUsedBeginFrameArgs();
-  if (!last_args.IsValid() ||
-      (args.frame_time >
-       last_args.frame_time + args.interval / kDoubleTickDivisor)) {
-    obs->OnBeginFrame(args);
+
+  if (missed_frame_observers_.empty()) {
+    DCHECK(missed_frame_callback_.IsCancelled());
+    missed_frame_callback_.Reset(
+        base::Bind(&DelayBasedBeginFrameSource::SendMissedBeginFrame,
+                   weak_factory_.GetWeakPtr()));
+    task_runner_->PostTask(FROM_HERE, missed_frame_callback_.callback());
   }
+  missed_frame_observers_.insert(obs);
 }
 
 void DelayBasedBeginFrameSource::RemoveObserver(BeginFrameObserver* obs) {
   DCHECK(obs);
   DCHECK(observers_.find(obs) != observers_.end());
-
+  missed_frame_observers_.erase(obs);
+  if (missed_frame_observers_.empty())
+    missed_frame_callback_.Cancel();
   observers_.erase(obs);
   if (observers_.empty())
     time_source_->SetActive(false);
 }
 
 void DelayBasedBeginFrameSource::OnTimerTick() {
+  missed_frame_callback_.Cancel();
+  missed_frame_observers_.clear();
   BeginFrameArgs args = CreateBeginFrameArgs(time_source_->LastTickTime(),
                                              BeginFrameArgs::NORMAL);
   std::unordered_set<BeginFrameObserver*> observers(observers_);
   for (auto& obs : observers) {
     BeginFrameArgs last_args = obs->LastUsedBeginFrameArgs();
     if (!last_args.IsValid() ||
         (args.frame_time >
          last_args.frame_time + args.interval / kDoubleTickDivisor))
       obs->OnBeginFrame(args);
   }
 }
 
+void DelayBasedBeginFrameSource::SendMissedBeginFrame() {
+  DCHECK(!missed_frame_observers_.empty());
+  missed_frame_callback_.Cancel();
+  std::unordered_set<BeginFrameObserver*> missed_frame_observers;
+  missed_frame_observers.swap(missed_frame_observers_);
+
+  BeginFrameArgs args = CreateBeginFrameArgs(
+      time_source_->NextTickTime() - time_source_->Interval(),
+      BeginFrameArgs::MISSED);
+
+  for (BeginFrameObserver* obs : missed_frame_observers) {
+    BeginFrameArgs last_args = obs->LastUsedBeginFrameArgs();
+    if (!last_args.IsValid() ||
+        (args.frame_time >
+         last_args.frame_time + args.interval / kDoubleTickDivisor)) {
+      obs->OnBeginFrame(args);
+    }
+  }
+}
+
 }  // namespace cc