cc: Adding a BeginFrameObserverMultiplexer.

cc/scheduler/begin_frame_source.h

 // 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.
 
 #ifndef CC_SCHEDULER_BEGIN_FRAME_SOURCE_H_
 #define CC_SCHEDULER_BEGIN_FRAME_SOURCE_H_
 
 #include <set>
 #include <string>
 
@@ skipping 68 matching lines @@
 
  protected:
   // Subclasses should override this method!
   // Return true if the given argument is (or will be) used.
   virtual bool OnBeginFrameMixInDelegate(const BeginFrameArgs& args) = 0;
 
   BeginFrameArgs last_begin_frame_args_;
   int64_t dropped_begin_frame_args_;
 };
 
+// A "virtual" frame observer which forwards any received BeginFrame messages
+// to all registered observers. Also provides a callback allowing detection of
+// observers existing.
+class CC_EXPORT BeginFrameObserverMultiplexer : public BeginFrameObserverMixIn {

[simonhong, 2015/03/25 02:03:22]

As dana said, how about subclassing BeginFrameObserver directly?
I think OnBeginFrameMixInDelegate() can be replaced with
BeginFrameObserver::OnBeginFrame().

[mithro-old, 2015/03/25 02:34:47]

Implementing BeginFrameObserver means duplicating the code inside the
BeginFrameObserverMixIn. Having two places which implement identical logic
substantially increases the risk of them getting out of sync leading to subtle
bugs which are hard to debug.

Using inheritance here should makes sure you don't forget to maintain the
BeginFrameObserver contract by not updating the LastBeginFrameArgs output.

An alternative to using inheritance here would be to make the code in
BFSOberverMixIn some type of "helper library" but we would need to be vigilant
in making sure it always used.

+ public:
+  using HasObserversCallback = base::Callback<void(bool has_observers)>;
+
+  static scoped_ptr<BeginFrameObserverMultiplexer> Create();
+  ~BeginFrameObserverMultiplexer() override;
+
+  void AddObserver(BeginFrameObserver* obs);
+  void RemoveObserver(BeginFrameObserver* obs);
+  bool HasObservers();
+  void SetHasObserverCallback(const HasObserversCallback& cb);
+
+  void AsValueInto(base::trace_event::TracedValue* dict) const override;
+
+ protected:
+  BeginFrameObserverMultiplexer();
+
+  bool last_callback_state_;
+  HasObserversCallback has_observers_callback_;
+  void CallCallbackOnChange();
+  void CallCallback(bool has_observers);
+
+  // BeginFrameObserverMixIn
+  bool OnBeginFrameMixInDelegate(const BeginFrameArgs& args) override;
+
+  ObserverList<BeginFrameObserver> observer_list_;
+};
+
 // Interface for a class which produces BeginFrame calls to a
 // BeginFrameObserver.
 //
 // BeginFrame calls *normally* occur just after a vsync interrupt when input
 // processing has been finished and provide information about the time values
 // of the vsync times. *However*, these values can be heavily modified or even
 // plain made up (when no vsync signal is available or vsync throttling is
 // turned off). See the BeginFrameObserver for information about the guarantees
 // all BeginFrameSources *must* provide.
 class CC_EXPORT BeginFrameSource {
@@ skipping 175 matching lines @@
 
   base::TimeDelta minimum_interval_;
 
   BeginFrameSource* active_source_;
   std::set<BeginFrameSource*> source_list_;
 };
 
 }  // namespace cc
 
 #endif  // CC_SCHEDULER_BEGIN_FRAME_SOURCE_H_