[cc] Track observer status in ExternalBeginFrameSource.

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 <stddef.h>
 #include <stdint.h>
 
 #include <set>
 #include <string>
 
+#include "base/containers/flat_set.h"
+#include "base/containers/small_map.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/output/begin_frame_args.h"
 #include "cc/scheduler/delay_based_time_source.h"
 
 namespace cc {
 
 // (Pure) Interface for observing BeginFrame messages from BeginFrameSource
 // objects.
 class CC_EXPORT BeginFrameObserver {
  public:
   virtual ~BeginFrameObserver() {}
 
   // The |args| given to OnBeginFrame is guaranteed to have
   // |args|.IsValid()==true. If |args|.source_id did not change between
   // invocations, |args|.sequence_number is guaranteed to be be strictly greater
   // than the previous call. Further, |args|.frame_time is guaranteed to be
   // greater than or equal to the previous call even if the source_id changes.
   //
   // Side effects: This function can (and most of the time *will*) change the
   // return value of the LastUsedBeginFrameArgs method. See the documentation
   // on that method for more information.
+  //
+  // The observer is required call BeginFrameSource::DidFinishFrame() as soon as
+  // it has completed handling the BeginFrame.
   virtual void OnBeginFrame(const BeginFrameArgs& args) = 0;
 
   // Returns the last BeginFrameArgs used by the observer. This method's return
   // value is affected by the OnBeginFrame method!
   //
   //  - Before the first call of OnBeginFrame, this method should return a
   //    BeginFrameArgs on which IsValid() returns false.
   //
   //  - If the |args| passed to OnBeginFrame is (or *will be*) used, then
   //    LastUsedBeginFrameArgs return value should become the |args| given to
@@ skipping 176 matching lines @@
   std::unique_ptr<DelayBasedTimeSource> time_source_;
   std::unordered_set<BeginFrameObserver*> observers_;
   base::TimeTicks last_timebase_;
   base::TimeDelta authoritative_interval_;
   BeginFrameArgs current_begin_frame_args_;
   uint64_t next_sequence_number_;
 
   DISALLOW_COPY_AND_ASSIGN(DelayBasedBeginFrameSource);
 };
 
+// Helper class that tracks outstanding acknowledgments from
+// BeginFrameObservers.
+class CC_EXPORT BeginFrameObserverAckTracker {
+ public:
+  BeginFrameObserverAckTracker();
+  virtual ~BeginFrameObserverAckTracker();
+
+  // The BeginFrameSource uses these methods to notify us when a BeginFrame was
+  // started, an observer finished a frame, or an observer was added/removed.
+  void OnBeginFrame(const BeginFrameArgs& args);
+  void OnObserverFinishedFrame(BeginFrameObserver* obs,
+                               const BeginFrameAck& ack);
+  void OnObserverAdded(BeginFrameObserver* obs);
+  void OnObserverRemoved(BeginFrameObserver* obs);
+
+  // Returns |true| if all the source's observers completed the current frame.
+  bool AllObserversFinishedFrame() const;
+
+  // Returns |true| if any observer had damage during the current frame.
+  bool AnyObserversHadDamage() const;
+
+  // Return the sequence number of the latest frame that all active observers
+  // have confirmed.
+  uint64_t LatestConfirmedSequenceNumber() const;
+
+ private:
+  void SourceChanged(const BeginFrameArgs& args);
+
+  uint32_t current_source_id_;
+  uint64_t current_sequence_number_;
+  // Small sets, but order matters for intersection computation.
+  base::flat_set<BeginFrameObserver*> observers_;
+  base::flat_set<BeginFrameObserver*> finished_observers_;
+  bool observers_had_damage_;
+  base::SmallMap<std::map<BeginFrameObserver*, uint64_t>, 4>
+      latest_confirmed_sequence_numbers_;
+};
+
 class CC_EXPORT ExternalBeginFrameSourceClient {
  public:
   // Only called when changed.  Assumed false by default.
   virtual void OnNeedsBeginFrames(bool needs_begin_frames) = 0;
+  // Called when all observers have completed a frame.
+  virtual void OnDidFinishFrame(const BeginFrameAck& ack) = 0;
 };
 
 // A BeginFrameSource that is only ticked manually.  Usually the endpoint
 // of messages from some other thread/process that send OnBeginFrame and
 // receive SetNeedsBeginFrame messages.  This turns such messages back into
 // an observable BeginFrameSource.
 class CC_EXPORT ExternalBeginFrameSource : public BeginFrameSource {
  public:
   // Client lifetime must be preserved by owner past the lifetime of this class.
   explicit ExternalBeginFrameSource(ExternalBeginFrameSourceClient* client);
   ~ExternalBeginFrameSource() override;
 
   // BeginFrameSource implementation.
   void AddObserver(BeginFrameObserver* obs) override;
   void RemoveObserver(BeginFrameObserver* obs) override;
   void DidFinishFrame(BeginFrameObserver* obs,
-                      const BeginFrameAck& ack) override {}
+                      const BeginFrameAck& ack) override;
   bool IsThrottled() const override;
 
   void OnSetBeginFrameSourcePaused(bool paused);
   void OnBeginFrame(const BeginFrameArgs& args);
 
  protected:
+  void MaybeFinishFrame();
+  void FinishFrame();
+
   BeginFrameArgs missed_begin_frame_args_;
   std::unordered_set<BeginFrameObserver*> observers_;
   ExternalBeginFrameSourceClient* client_;
   bool paused_ = false;
+  bool frame_active_ = false;
+  BeginFrameObserverAckTracker ack_tracker_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ExternalBeginFrameSource);
 };
 
 }  // namespace cc
 
 #endif  // CC_SCHEDULER_BEGIN_FRAME_SOURCE_H_