cc: Remove retro frames from scheduler.

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/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) {
-}
-
-const BeginFrameArgs& BeginFrameObserverBase::LastUsedBeginFrameArgs() const {
-  return last_begin_frame_args_;
-}
-void BeginFrameObserverBase::OnBeginFrame(const BeginFrameArgs& args) {
-  DEBUG_FRAMES("BeginFrameObserverBase::OnBeginFrame",
-               "last args",
-               last_begin_frame_args_.AsValue(),
-               "new args",
-               args.AsValue());
-  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_;
-  }
-}
-
-void BeginFrameObserverBase::AsValueInto(
-    base::trace_event::TracedValue* dict) const {
-  dict->BeginDictionary("last_begin_frame_args_");
-  last_begin_frame_args_.AsValueInto(dict);
-  dict->EndDictionary();
-  dict->SetInteger("dropped_begin_frame_args_", dropped_begin_frame_args_);
-}
-
 // BeginFrameSourceBase ------------------------------------------------------
 BeginFrameSourceBase::BeginFrameSourceBase()
     : paused_(false), inside_as_value_into_(false) {}
 
 BeginFrameSourceBase::~BeginFrameSourceBase() {}
 
 void BeginFrameSourceBase::AddObserver(BeginFrameObserver* obs) {
   DEBUG_FRAMES("BeginFrameSourceBase::AddObserver", "num observers",
                observers_.size(), "to add observer", obs);
   DCHECK(obs);
@@ skipping 98 matching lines @@
   DCHECK(needs_begin_frames());
   DCHECK(!begin_frame_task_.IsCancelled());
   begin_frame_task_.Cancel();
   base::TimeTicks now = Now();
   BeginFrameArgs args = BeginFrameArgs::Create(
       BEGINFRAME_FROM_HERE, now, now + BeginFrameArgs::DefaultInterval(),
       BeginFrameArgs::DefaultInterval(), BeginFrameArgs::NORMAL);
   CallOnBeginFrame(args);
 }
 
-void BackToBackBeginFrameSource::DidFinishFrame(size_t remaining_frames) {
-  BeginFrameSourceBase::DidFinishFrame(remaining_frames);
-  if (needs_begin_frames() && remaining_frames == 0)
+void BackToBackBeginFrameSource::DidFinishFrame(BeginFrameObserver* obs) {
+  if (needs_begin_frames())
     PostBeginFrame();

[enne (OOO), 2016/04/14 23:02:26]

Hmm.  Should this only post a begin frame to the observer that finished?
Otherwise, if you have two observers, when one finishes, you'll post two new
begin frames?

 }
 
 // Tracing support
 void BackToBackBeginFrameSource::AsValueInto(
     base::trace_event::TracedValue* dict) const {
   dict->SetString("type", "BackToBackBeginFrameSource");
   BeginFrameSourceBase::AsValueInto(dict);
 }
 
 // SyntheticBeginFrameSource ---------------------------------------------
@@ skipping 21 matching lines @@
 
 BeginFrameArgs SyntheticBeginFrameSource::CreateBeginFrameArgs(
     base::TimeTicks frame_time,
     BeginFrameArgs::BeginFrameArgsType type) {
   return BeginFrameArgs::Create(BEGINFRAME_FROM_HERE, frame_time,
                                 time_source_->NextTickTime(),
                                 time_source_->Interval(), type);
 }
 
 // BeginFrameSource support
+void SyntheticBeginFrameSource::DidFinishFrame(BeginFrameObserver* obs) {
+  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);
+  }
+}
+
 void SyntheticBeginFrameSource::AddObserver(BeginFrameObserver* obs) {
   BeginFrameSourceBase::AddObserver(obs);
   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);
@@ skipping 25 matching lines @@
     base::trace_event::TracedValue* dict) const {
   dict->SetString("type", "SyntheticBeginFrameSource");
   BeginFrameSourceBase::AsValueInto(dict);
 
   dict->BeginDictionary("time_source");
   time_source_->AsValueInto(dict);
   dict->EndDictionary();
 }
 
 }  // namespace cc