Android: Browser-side scheduling latency tweaks

content/browser/renderer_host/compositor_impl_android.cc

 // Copyright (c) 2012 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 "content/browser/renderer_host/compositor_impl_android.h"
 
 #include <android/bitmap.h>
 #include <android/native_window_jni.h>
 #include <stdint.h>
 
@@ skipping 68 matching lines @@
                                  public CompositorImpl::VSyncObserver {
  public:
   ExternalBeginFrameSource(CompositorImpl* compositor)
       : compositor_(compositor) {
     compositor_->AddObserver(this);
   }
 
   ~ExternalBeginFrameSource() override { compositor_->RemoveObserver(this); }
 
   // cc::BeginFrameSourceBase implementation:
+  void AddObserver(cc::BeginFrameObserver* obs) override {
+    cc::BeginFrameSourceBase::AddObserver(obs);
+    DCHECK(needs_begin_frames());
+    if (!last_begin_frame_args_.IsValid())
+      return;
+
+    // Send a MISSED begin frame if necessary.
+    cc::BeginFrameArgs last_args = obs->LastUsedBeginFrameArgs();
+    if (!last_args.IsValid() ||
+        (last_begin_frame_args_.frame_time > last_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 OnNeedsBeginFramesChanged(bool needs_begin_frames) override {
+    TRACE_EVENT1("compositor", "OnNeedsBeginFramesChanged",
+                 "needs_begin_frames", needs_begin_frames);
     compositor_->OnNeedsBeginFramesChange(needs_begin_frames);
   }
 
   // CompositorImpl::VSyncObserver implementation:
   void OnVSync(base::TimeTicks frame_time,
                base::TimeDelta vsync_period) override {
-    CallOnBeginFrame(cc::BeginFrameArgs::Create(
-        BEGINFRAME_FROM_HERE, frame_time, base::TimeTicks::Now(), vsync_period,
-        cc::BeginFrameArgs::NORMAL));
+    base::TimeTicks deadline = std::max(base::TimeTicks::Now(), frame_time);
+    last_begin_frame_args_ =
+        cc::BeginFrameArgs::Create(BEGINFRAME_FROM_HERE, frame_time, deadline,
+                                   vsync_period, cc::BeginFrameArgs::NORMAL);
+    CallOnBeginFrame(last_begin_frame_args_);
   }
 
  private:
   CompositorImpl* compositor_;
+  cc::BeginFrameArgs last_begin_frame_args_;
 };
 
 // Used to override capabilities_.adjust_deadline_for_parent to false
 class OutputSurfaceWithoutParent : public cc::OutputSurface,
                                    public CompositorImpl::VSyncObserver {
  public:
   OutputSurfaceWithoutParent(
       CompositorImpl* compositor,
       const scoped_refptr<ContextProviderCommandBuffer>& context_provider,
       const base::Callback<void(gpu::Capabilities)>&
@@ skipping 295 matching lines @@
 
 void CompositorImpl::SetHasTransparentBackground(bool flag) {
   has_transparent_background_ = flag;
   if (host_)
     host_->set_has_transparent_background(flag);
 }
 
 void CompositorImpl::SetNeedsComposite() {
   if (!host_->visible())
     return;
+  TRACE_EVENT0("compositor", "Compositor::SetNeedsComposite");
   host_->SetNeedsAnimate();
 }
 
 void CompositorImpl::UpdateLayerTreeHost() {
   client_->UpdateLayerTreeHost();
   if (needs_animate_) {
     needs_animate_ = false;
     root_window_->Animate(base::TimeTicks::Now());
   }
 }
@@ skipping 160 matching lines @@
 void CompositorImpl::AddObserver(VSyncObserver* observer) {
   observer_list_.AddObserver(observer);
 }
 
 void CompositorImpl::RemoveObserver(VSyncObserver* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
 cc::UIResourceId CompositorImpl::CreateUIResource(
     cc::UIResourceClient* client) {
+  TRACE_EVENT0("compositor", "CompositorImpl::CreateUIResource");
   return host_->CreateUIResource(client);
 }
 
 void CompositorImpl::DeleteUIResource(cc::UIResourceId resource_id) {
+  TRACE_EVENT0("compositor", "CompositorImpl::DeleteUIResource");
   host_->DeleteUIResource(resource_id);
 }
 
 bool CompositorImpl::SupportsETC1NonPowerOfTwo() const {
   return gpu_capabilities_.texture_format_etc1_npot;
 }
 
 void CompositorImpl::DidPostSwapBuffers() {
   TRACE_EVENT0("compositor", "CompositorImpl::DidPostSwapBuffers");
   pending_swapbuffers_++;
@@ skipping 40 matching lines @@
   needs_begin_frames_ = needs_begin_frames;
   if (needs_begin_frames_)
     root_window_->RequestVSyncUpdate();
 }
 
 void CompositorImpl::SetNeedsAnimate() {
   needs_animate_ = true;
   if (!host_->visible())
     return;
 
+  TRACE_EVENT0("compositor", "Compositor::SetNeedsAnimate");
   host_->SetNeedsAnimate();
 }
 
 }  // namespace content