[cc] Adds source_id and sequence_number to BeginFrameArgs.

ui/android/window_android.cc

 // Copyright 2013 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 "ui/android/window_android.h"
 
 #include <unordered_set>
 
 #include "base/android/context_utils.h"
 #include "base/android/jni_android.h"
@@ skipping 15 matching lines @@
 using base::android::AttachCurrentThread;
 using base::android::JavaParamRef;
 using base::android::JavaRef;
 using base::android::ScopedJavaLocalRef;
 
 class WindowAndroid::WindowBeginFrameSource : public cc::BeginFrameSource {
  public:
   explicit WindowBeginFrameSource(WindowAndroid* window)
       : window_(window),
         observer_count_(0),
+        next_sequence_number_(cc::BeginFrameArgs::kStartingFrameNumber),
         in_on_vsync_(false) {}
   ~WindowBeginFrameSource() override {}
 
   // cc::BeginFrameSource implementation.
   void AddObserver(cc::BeginFrameObserver* obs) override;
   void RemoveObserver(cc::BeginFrameObserver* obs) override;
   void DidFinishFrame(cc::BeginFrameObserver* obs,
                       size_t remaining_frames) override {}
   bool IsThrottled() const override { return true; }
 
-  void OnVSync(base::TimeTicks frame_time,
-               base::TimeDelta vsync_period);
+  void OnVSync(base::TimeTicks frame_time, base::TimeDelta vsync_period);
 
  private:
   WindowAndroid* const window_;
   base::ObserverList<cc::BeginFrameObserver> observers_;
   int observer_count_;
   cc::BeginFrameArgs last_begin_frame_args_;
+  uint64_t next_sequence_number_;
   bool in_on_vsync_;
 };
 
 void WindowAndroid::WindowBeginFrameSource::AddObserver(
     cc::BeginFrameObserver* obs) {
   DCHECK(obs);
   DCHECK(!observers_.HasObserver(obs));
 
   observers_.AddObserver(obs);
   observer_count_++;
   obs->OnBeginFrameSourcePausedChanged(false);
   window_->SetNeedsBeginFrames(true);
 
   // Send a MISSED BeginFrame if possible and necessary. If an observer is added
   // during OnVSync(), it will get a NORMAL BeginFrame from OnVSync() instead.
   if (!in_on_vsync_ && last_begin_frame_args_.IsValid()) {
     cc::BeginFrameArgs last_args = obs->LastUsedBeginFrameArgs();
     if (!last_args.IsValid() ||
         last_args.frame_time < last_begin_frame_args_.frame_time) {
+      DCHECK(last_args.sequence_number <
+                 last_begin_frame_args_.sequence_number ||
+             last_args.source_id != last_begin_frame_args_.source_id);
       last_begin_frame_args_.type = cc::BeginFrameArgs::MISSED;
       // TODO(crbug.com/602485): A deadline doesn't make too much sense
       // for a missed BeginFrame (the intention rather is 'immediately'),
       // but currently the retro frame logic is very strict in discarding
       // BeginFrames.
       last_begin_frame_args_.deadline =
           base::TimeTicks::Now() + last_begin_frame_args_.interval;
       obs->OnBeginFrame(last_begin_frame_args_);
     }
   }
 }
 
 void WindowAndroid::WindowBeginFrameSource::RemoveObserver(
     cc::BeginFrameObserver* obs) {
   DCHECK(obs);
   DCHECK(observers_.HasObserver(obs));
 
   observers_.RemoveObserver(obs);
   observer_count_--;
   if (observer_count_ <= 0)
     window_->SetNeedsBeginFrames(false);
 }
 
 void WindowAndroid::WindowBeginFrameSource::OnVSync(
     base::TimeTicks frame_time,
     base::TimeDelta vsync_period) {
   // frame time is in the past, so give the next vsync period as the deadline.
   base::TimeTicks deadline = frame_time + vsync_period;
-  last_begin_frame_args_ =
-      cc::BeginFrameArgs::Create(BEGINFRAME_FROM_HERE, frame_time, deadline,
-                                 vsync_period, cc::BeginFrameArgs::NORMAL);
+  last_begin_frame_args_ = cc::BeginFrameArgs::Create(
+      BEGINFRAME_FROM_HERE, source_id(), next_sequence_number_, frame_time,
+      deadline, vsync_period, cc::BeginFrameArgs::NORMAL);
   DCHECK(last_begin_frame_args_.IsValid());
+  next_sequence_number_++;
 
   // We support adding/removing observers during observer iteration through
   // base::ObserverList. We also prevent observers that are added during
   // observer iteration from receiving a MISSED BeginFrame by means of
   // |in_on_vsync_| - they will receive the current NORMAL one during the
   // iteration instead. Note that SynchronousCompositorBrowserFilter relies on
   // this behavior.
   // TODO(eseckler): Remove SynchronousCompositorBrowserFilter's dependency on
   // this and replace observers_ by a std::unordered_set, iterate on a copy.
   base::AutoReset<bool> auto_reset(&in_on_vsync_, true);
@@ skipping 163 matching lines @@
 // ----------------------------------------------------------------------------
 // Native JNI methods
 // ----------------------------------------------------------------------------
 
 jlong Init(JNIEnv* env, const JavaParamRef<jobject>& obj, int sdk_display_id) {
   WindowAndroid* window = new WindowAndroid(env, obj, sdk_display_id);
   return reinterpret_cast<intptr_t>(window);
 }
 
 }  // namespace ui