cc: Introduce BeginFrame sequence numbers and acknowledgements.

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 <stdint.h>
+#include <unordered_set>
+
 #include "base/android/context_utils.h"
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/android/jni_weak_ref.h"
 #include "base/android/scoped_java_ref.h"
+#include "base/auto_reset.h"
+#include "base/stl_util.h"
+#include "cc/output/begin_frame_args.h"
+#include "cc/scheduler/begin_frame_source.h"
 #include "jni/WindowAndroid_jni.h"
 #include "ui/android/window_android_compositor.h"
 #include "ui/android/window_android_observer.h"
 
 namespace ui {
 
 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), next_sequence_number_(1), 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,
+                      const cc::BeginFrameAck& ack) override {}
+  bool IsThrottled() const override { return true; }
+
+  void OnVSync(base::TimeTicks frame_time,
+               base::TimeDelta vsync_period);
+
+ private:
+  WindowAndroid* const window_;
+  std::unordered_set<cc::BeginFrameObserver*> observers_;
+  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_.find(obs) == observers_.end());
+
+  observers_.insert(obs);
+  obs->OnBeginFrameSourcePausedChanged(false);
+  window_->OnNeedsBeginFramesChange(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.sequence_number < last_begin_frame_args_.sequence_number) {
+      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_.find(obs) != observers_.end());
+
+  observers_.erase(obs);
+  if (observers_.empty())
+    window_->OnNeedsBeginFramesChange(false);
+}
+
+void WindowAndroid::WindowBeginFrameSource::OnVSync(
+    base::TimeTicks frame_time,
+    base::TimeDelta vsync_period) {
+  base::AutoReset<bool> auto_reset(&in_on_vsync_, true);
+
+  // 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, source_id(), next_sequence_number_++, frame_time,
+      deadline, vsync_period, cc::BeginFrameArgs::NORMAL);
+  DCHECK(last_begin_frame_args_.IsValid());
+
+  // Support SynchronousCompositorBrowserFilter: Observers added during vsync
+  // distribution receive a NORMAL args in addition to the missed ones, after
+  // all current observers were notified. We also have to support observers
+  // removing themselves during OnBeginFrame, so we iterate on set copies until
+  // all observers were notified once.
+  std::unordered_set<cc::BeginFrameObserver*> notified_observers;
+  bool observer_was_notified = true;
+  while (observer_was_notified) {
+    observer_was_notified = false;
+    std::unordered_set<cc::BeginFrameObserver*> observers(observers_);
+    for (auto* obs : observers) {
+      if (notified_observers.find(obs) == notified_observers.end()) {
+        obs->OnBeginFrame(last_begin_frame_args_);
+        notified_observers.insert(obs);
+        observer_was_notified = true;
+      }
+    }
+  }
+}
+
 WindowAndroid::WindowAndroid(JNIEnv* env, jobject obj, int display_id)
-    : display_id_(display_id), compositor_(NULL) {
+    : display_id_(display_id),
+      compositor_(NULL),
+      begin_frame_source_(new WindowBeginFrameSource(this)),
+      needs_begin_frames_(false) {
   java_window_.Reset(env, obj);
 }
 
 void WindowAndroid::Destroy(JNIEnv* env, const JavaParamRef<jobject>& obj) {
   delete this;
 }
 
 ScopedJavaLocalRef<jobject> WindowAndroid::GetJavaObject() {
   return base::android::ScopedJavaLocalRef<jobject>(java_window_);
 }
@@ skipping 26 matching lines @@
 
 void WindowAndroid::AddObserver(WindowAndroidObserver* observer) {
   if (!observer_list_.HasObserver(observer))
     observer_list_.AddObserver(observer);
 }
 
 void WindowAndroid::RemoveObserver(WindowAndroidObserver* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
+cc::BeginFrameSource* WindowAndroid::GetBeginFrameSource() {
+  return begin_frame_source_.get();
+}
+
 void WindowAndroid::AttachCompositor(WindowAndroidCompositor* compositor) {
   if (compositor_ && compositor != compositor_)
     DetachCompositor();
 
   compositor_ = compositor;
   for (WindowAndroidObserver& observer : observer_list_)
     observer.OnAttachCompositor();
 }
 
 void WindowAndroid::DetachCompositor() {
@@ skipping 18 matching lines @@
     observer.OnAnimate(begin_frame_time);
 }
 
 void WindowAndroid::OnVSync(JNIEnv* env,
                             const JavaParamRef<jobject>& obj,
                             jlong time_micros,
                             jlong period_micros) {
   base::TimeTicks frame_time(base::TimeTicks::FromInternalValue(time_micros));
   base::TimeDelta vsync_period(
       base::TimeDelta::FromMicroseconds(period_micros));
-  for (WindowAndroidObserver& observer : observer_list_)
-    observer.OnVSync(frame_time, vsync_period);
-  if (compositor_)
-    compositor_->OnVSync(frame_time, vsync_period);
+  begin_frame_source_->OnVSync(frame_time, vsync_period);
+  if (needs_begin_frames_)
+    RequestVSyncUpdate();
 }
 
 void WindowAndroid::OnVisibilityChanged(JNIEnv* env,
                                         const JavaParamRef<jobject>& obj,
                                         bool visible) {
   for (WindowAndroidObserver& observer : observer_list_)
     observer.OnRootWindowVisibilityChanged(visible);
 }
 
 void WindowAndroid::OnActivityStopped(JNIEnv* env,
@@ skipping 15 matching lines @@
       base::android::ConvertUTF8ToJavaString(env, permission));
 }
 
 bool WindowAndroid::CanRequestPermission(const std::string& permission) {
   JNIEnv* env = AttachCurrentThread();
   return Java_WindowAndroid_canRequestPermission(
       env, GetJavaObject(),
       base::android::ConvertUTF8ToJavaString(env, permission));
 }
 
+void WindowAndroid::OnNeedsBeginFramesChange(bool needs_begin_frames) {
+  if (needs_begin_frames_ == needs_begin_frames)
+    return;
+
+  needs_begin_frames_ = needs_begin_frames;
+  if (needs_begin_frames_)
+    RequestVSyncUpdate();
+}
+
 WindowAndroid* WindowAndroid::GetWindowAndroid() const {
   DCHECK(parent_ == nullptr);
   return const_cast<WindowAndroid*>(this);
 }
 
 // ----------------------------------------------------------------------------
 // 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