Remove "mixin" from BeginFrameSource/Observer base classes.

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 "base/auto_reset.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.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"
 
 #ifdef NDEBUG
 #define DEBUG_FRAMES(...)
 #else
 #define DEBUG_FRAMES(name, arg1_name, arg1_val, arg2_name, arg2_val)   \
   TRACE_EVENT2(TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler.frames"), \
                name,                                                   \
                arg1_name,                                              \
                arg1_val,                                               \
                arg2_name,                                              \
                arg2_val);
 #endif
 
 namespace cc {
 
-// BeginFrameObserverMixIn -----------------------------------------------
-BeginFrameObserverMixIn::BeginFrameObserverMixIn()
+// BeginFrameObserverBase -----------------------------------------------
+BeginFrameObserverBase::BeginFrameObserverBase()
     : last_begin_frame_args_(), dropped_begin_frame_args_(0) {
 }
 
-const BeginFrameArgs BeginFrameObserverMixIn::LastUsedBeginFrameArgs() const {
+const BeginFrameArgs BeginFrameObserverBase::LastUsedBeginFrameArgs() const {
   return last_begin_frame_args_;
 }
-void BeginFrameObserverMixIn::OnBeginFrame(const BeginFrameArgs& args) {
-  DEBUG_FRAMES("BeginFrameObserverMixIn::OnBeginFrame",
+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 = OnBeginFrameMixInDelegate(args);
+  bool used = OnBeginFrameDerivedImpl(args);
   if (used) {
     last_begin_frame_args_ = args;
   } else {
     ++dropped_begin_frame_args_;
   }
 }
 
-void BeginFrameObserverMixIn::AsValueInto(
+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_);
 }
 
-// BeginFrameSourceMixIn ------------------------------------------------------
-BeginFrameSourceMixIn::BeginFrameSourceMixIn()
+// BeginFrameSourceBase ------------------------------------------------------
+BeginFrameSourceBase::BeginFrameSourceBase()
     : observer_(NULL),
       needs_begin_frames_(false),
       inside_as_value_into_(false) {
   DCHECK(!observer_);
   DCHECK_EQ(inside_as_value_into_, false);
 }
 
-bool BeginFrameSourceMixIn::NeedsBeginFrames() const {
+bool BeginFrameSourceBase::NeedsBeginFrames() const {
   return needs_begin_frames_;
 }
 
-void BeginFrameSourceMixIn::SetNeedsBeginFrames(bool needs_begin_frames) {
-  DEBUG_FRAMES("BeginFrameSourceMixIn::SetNeedsBeginFrames",
+void BeginFrameSourceBase::SetNeedsBeginFrames(bool needs_begin_frames) {
+  DEBUG_FRAMES("BeginFrameSourceBase::SetNeedsBeginFrames",
                "current state",
                needs_begin_frames_,
                "new state",
                needs_begin_frames);
   if (needs_begin_frames_ != needs_begin_frames) {
     needs_begin_frames_ = needs_begin_frames;
     OnNeedsBeginFramesChange(needs_begin_frames);
   }
 }
 
-void BeginFrameSourceMixIn::AddObserver(BeginFrameObserver* obs) {
-  DEBUG_FRAMES("BeginFrameSourceMixIn::AddObserver",
+void BeginFrameSourceBase::AddObserver(BeginFrameObserver* obs) {
+  DEBUG_FRAMES("BeginFrameSourceBase::AddObserver",
                "current observer",
                observer_,
                "to add observer",
                obs);
   DCHECK(!observer_);
   observer_ = obs;
 }
 
-void BeginFrameSourceMixIn::RemoveObserver(BeginFrameObserver* obs) {
-  DEBUG_FRAMES("BeginFrameSourceMixIn::RemoveObserver",
+void BeginFrameSourceBase::RemoveObserver(BeginFrameObserver* obs) {
+  DEBUG_FRAMES("BeginFrameSourceBase::RemoveObserver",
                "current observer",
                observer_,
                "to remove observer",
                obs);
   DCHECK_EQ(observer_, obs);
   observer_ = NULL;
 }
 
-void BeginFrameSourceMixIn::CallOnBeginFrame(const BeginFrameArgs& args) {
-  DEBUG_FRAMES("BeginFrameSourceMixIn::CallOnBeginFrame",
+void BeginFrameSourceBase::CallOnBeginFrame(const BeginFrameArgs& args) {
+  DEBUG_FRAMES("BeginFrameSourceBase::CallOnBeginFrame",
                "current observer",
                observer_,
                "args",
                args.AsValue());
   if (observer_) {
     return observer_->OnBeginFrame(args);
   }
 }
 
 // Tracing support
-void BeginFrameSourceMixIn::AsValueInto(
+void BeginFrameSourceBase::AsValueInto(
     base::trace_event::TracedValue* dict) const {
   // As the observer might try to trace the source, prevent an infinte loop
   // from occuring.
   if (inside_as_value_into_) {
     dict->SetString("observer", "<loop detected>");
     return;
   }
 
   if (observer_) {
     base::AutoReset<bool> prevent_loops(
         const_cast<bool*>(&inside_as_value_into_), true);
     dict->BeginDictionary("observer");
     observer_->AsValueInto(dict);
     dict->EndDictionary();
   } else {
     dict->SetString("observer", "NULL");
   }
   dict->SetBoolean("needs_begin_frames", NeedsBeginFrames());
 }
 
-// BackToBackBeginFrameSourceMixIn --------------------------------------------
+// BackToBackBeginFrameSource --------------------------------------------
 scoped_ptr<BackToBackBeginFrameSource> BackToBackBeginFrameSource::Create(
     base::SingleThreadTaskRunner* task_runner) {
   return make_scoped_ptr(new BackToBackBeginFrameSource(task_runner));
 }
 
 BackToBackBeginFrameSource::BackToBackBeginFrameSource(
     base::SingleThreadTaskRunner* task_runner)
-    : BeginFrameSourceMixIn(),
+    : BeginFrameSourceBase(),
       task_runner_(task_runner),
       send_begin_frame_posted_(false),
       weak_factory_(this) {
   DCHECK(task_runner);
   DCHECK_EQ(needs_begin_frames_, false);
   DCHECK_EQ(send_begin_frame_posted_, false);
 }
 
 BackToBackBeginFrameSource::~BackToBackBeginFrameSource() {
 }
@@ skipping 34 matching lines @@
 void BackToBackBeginFrameSource::DidFinishFrame(size_t remaining_frames) {
   if (remaining_frames == 0) {
     OnNeedsBeginFramesChange(NeedsBeginFrames());
   }
 }
 
 // Tracing support
 void BackToBackBeginFrameSource::AsValueInto(
     base::trace_event::TracedValue* dict) const {
   dict->SetString("type", "BackToBackBeginFrameSource");
-  BeginFrameSourceMixIn::AsValueInto(dict);
+  BeginFrameSourceBase::AsValueInto(dict);
   dict->SetBoolean("send_begin_frame_posted_", send_begin_frame_posted_);
 }
 
 // SyntheticBeginFrameSource ---------------------------------------------
 scoped_ptr<SyntheticBeginFrameSource> SyntheticBeginFrameSource::Create(
     base::SingleThreadTaskRunner* task_runner,
     base::TimeTicks initial_vsync_timebase,
     base::TimeDelta initial_vsync_interval) {
   scoped_refptr<DelayBasedTimeSource> time_source;
   time_source =
       DelayBasedTimeSource::Create(initial_vsync_interval, task_runner);
   return make_scoped_ptr(new SyntheticBeginFrameSource(time_source));
 }
 
 SyntheticBeginFrameSource::SyntheticBeginFrameSource(
     scoped_refptr<DelayBasedTimeSource> time_source)
-    : BeginFrameSourceMixIn(), time_source_(time_source) {
+    : BeginFrameSourceBase(), time_source_(time_source) {
   time_source_->SetActive(false);
   time_source_->SetClient(this);
 }
 
 SyntheticBeginFrameSource::~SyntheticBeginFrameSource() {
   if (NeedsBeginFrames())
     time_source_->SetActive(false);
 }
 
 void SyntheticBeginFrameSource::OnUpdateVSyncParameters(
     base::TimeTicks new_vsync_timebase,
     base::TimeDelta new_vsync_interval) {
   time_source_->SetTimebaseAndInterval(new_vsync_timebase, new_vsync_interval);
 }
 
 BeginFrameArgs SyntheticBeginFrameSource::CreateBeginFrameArgs(
     base::TimeTicks frame_time,
     BeginFrameArgs::BeginFrameArgsType type) {
   base::TimeTicks deadline = time_source_->NextTickTime();
   return BeginFrameArgs::Create(BEGINFRAME_FROM_HERE, frame_time, deadline,
                                 time_source_->Interval(), type);
 }
 
 // TimeSourceClient support
 void SyntheticBeginFrameSource::OnTimerTick() {
   CallOnBeginFrame(CreateBeginFrameArgs(time_source_->LastTickTime(),
                                         BeginFrameArgs::NORMAL));
 }
 
-// BeginFrameSourceMixIn support
+// BeginFrameSourceBase support
 void SyntheticBeginFrameSource::OnNeedsBeginFramesChange(
     bool needs_begin_frames) {
   base::TimeTicks missed_tick_time =
       time_source_->SetActive(needs_begin_frames);
   if (!missed_tick_time.is_null()) {
     CallOnBeginFrame(
         CreateBeginFrameArgs(missed_tick_time, BeginFrameArgs::MISSED));
   }
 }
 
 // Tracing support
 void SyntheticBeginFrameSource::AsValueInto(
     base::trace_event::TracedValue* dict) const {
   dict->SetString("type", "SyntheticBeginFrameSource");
-  BeginFrameSourceMixIn::AsValueInto(dict);
+  BeginFrameSourceBase::AsValueInto(dict);
 
   dict->BeginDictionary("time_source");
   time_source_->AsValueInto(dict);
   dict->EndDictionary();
 }
 
 // BeginFrameSourceMultiplexer -------------------------------------------
 scoped_ptr<BeginFrameSourceMultiplexer> BeginFrameSourceMultiplexer::Create() {
   return make_scoped_ptr(new BeginFrameSourceMultiplexer());
 }
 
 BeginFrameSourceMultiplexer::BeginFrameSourceMultiplexer()
-    : BeginFrameSourceMixIn(),
+    : BeginFrameSourceBase(),
       minimum_interval_(base::TimeDelta()),
       active_source_(NULL),
       source_list_() {
 }
 
 BeginFrameSourceMultiplexer::BeginFrameSourceMultiplexer(
     base::TimeDelta minimum_interval)
-    : BeginFrameSourceMixIn(),
+    : BeginFrameSourceBase(),
       minimum_interval_(minimum_interval),
       active_source_(NULL),
       source_list_() {
 }
 
 BeginFrameSourceMultiplexer::~BeginFrameSourceMultiplexer() {
   if (active_source_) {
     active_source_->SetNeedsBeginFrames(false);
     active_source_->RemoveObserver(this);
   }
@@ skipping 165 matching lines @@
   if (!observer_->LastUsedBeginFrameArgs().IsValid())
     return true;
 
   // Only allow new args have a *strictly bigger* frame_time value and statisfy
   // minimum interval requirement.
   return (args.frame_time >=
           observer_->LastUsedBeginFrameArgs().frame_time + minimum_interval_);
 }
 
 }  // namespace cc