[android] Make RWHVAndroid a BeginFrameObserver.

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"
 #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/observer_list.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),
+        observer_count_(0),
+        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);
+
+ private:
+  WindowAndroid* const window_;
+  base::ObserverList<cc::BeginFrameObserver> observers_;
+  int observer_count_;
+  cc::BeginFrameArgs last_begin_frame_args_;
+  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) {
+      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);
+  DCHECK(last_begin_frame_args_.IsValid());
+
+  // 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.
+  base::AutoReset<bool> auto_reset(&in_on_vsync_, true);
+  std::unordered_set<cc::BeginFrameObserver*> notified_observers;
+  for (auto& obs : observers_) {
+    // An observer may remove and add itself during a single OnBeginFrame, in
+    // which case it'd appear twice during the iteration. To deal with this, we
+    // keep track of whether we already notified it.
+    if (!base::ContainsKey(notified_observers, &obs)) {
+      obs.OnBeginFrame(last_begin_frame_args_);
+      notified_observers.insert(&obs);
+    }
+  }
+}
+
 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() {
   compositor_ = NULL;
   for (WindowAndroidObserver& observer : observer_list_)
     observer.OnDetachCompositor();
   observer_list_.Clear();
 }
 
 void WindowAndroid::RequestVSyncUpdate() {
   JNIEnv* env = AttachCurrentThread();
   Java_WindowAndroid_requestVSyncUpdate(env, GetJavaObject());
 }
 
+void WindowAndroid::SetNeedsBeginFrames(bool needs_begin_frames) {
+  if (needs_begin_frames_ == needs_begin_frames)
+    return;
+
+  needs_begin_frames_ = needs_begin_frames;
+  if (needs_begin_frames_)
+    RequestVSyncUpdate();
+}
+
 void WindowAndroid::SetNeedsAnimate() {
   if (compositor_)
     compositor_->SetNeedsAnimate();
 }
 
 void WindowAndroid::Animate(base::TimeTicks begin_frame_time) {
   for (WindowAndroidObserver& observer : observer_list_)
     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 30 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