Android: Move scheduling logic to CompositorImpl

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 "base/android/jni_android.h"
@@ skipping 220 matching lines @@
 }
 
 CompositorImpl::CompositorImpl(CompositorClient* client,
                                gfx::NativeWindow root_window)
     : root_layer_(cc::Layer::Create()),
       has_transparent_background_(false),
       device_scale_factor_(1),
       window_(NULL),
       surface_id_(0),
       client_(client),
-      root_window_(root_window) {
+      root_window_(root_window),
+      did_post_swapbuffers_(false),
+      need_to_composite_(false),
+      can_composite_outside_vsync_(true),
+      pending_swapbuffers_(0U),
+      weak_factory_(this) {
   DCHECK(client);
   DCHECK(root_window);
   ImageTransportFactoryAndroid::AddObserver(this);
   root_window->AttachCompositor(this);
 }
 
 CompositorImpl::~CompositorImpl() {
   root_window_->DetachCompositor();
   ImageTransportFactoryAndroid::RemoveObserver(this);
   // Clean-up any surface references.
   SetSurface(NULL);
 }
 
-void CompositorImpl::Composite() {
-  if (host_)
-    host_->Composite(gfx::FrameTime::Now());
+void CompositorImpl::Composite(bool is_vsync) {
+  if (!host_)
+    return;
+
+  if (!need_to_composite_)
+    return;
+
+  if (!is_vsync && !can_composite_outside_vsync_) {
+    TRACE_EVENT0("compositor", "CompositorImpl_DeferComposite");
+    root_window_->RequestVSyncUpdate();
+    return;
+  }
+
+  const unsigned int kMaxSwapBuffers = 2U;
+  DCHECK_LE(pending_swapbuffers_, kMaxSwapBuffers);
+  if (pending_swapbuffers_ == kMaxSwapBuffers) {
+    TRACE_EVENT0("compositor", "CompositorImpl_SwapLimit");
+    root_window_->RequestVSyncUpdate();
+    return;
+  }
+
+  // Don't allow compositing immediately more than once per vsync.
+  can_composite_outside_vsync_ = false;
+
+  did_post_swapbuffers_ = false;
+  host_->Composite(gfx::FrameTime::Now());
+  if (did_post_swapbuffers_)
+    pending_swapbuffers_++;
+
+  need_to_composite_ = false;
 }
 
 void CompositorImpl::SetRootLayer(scoped_refptr<cc::Layer> root_layer) {
   root_layer_->RemoveAllChildren();
   root_layer_->AddChild(root_layer);
 }
 
 void CompositorImpl::SetWindowSurface(ANativeWindow* window) {
   GpuSurfaceTracker* tracker = GpuSurfaceTracker::Get();
 
@@ skipping 190 matching lines @@
   return make_scoped_ptr(
       new WebGraphicsContext3DCommandBufferImpl(surface_id,
                                                 url,
                                                 gpu_channel_host.get(),
                                                 attributes,
                                                 lose_context_when_out_of_memory,
                                                 limits,
                                                 NULL));
 }
 
+void CompositorImpl::Layout() {
+  client_->Layout();
+}
+
 scoped_ptr<cc::OutputSurface> CompositorImpl::CreateOutputSurface(
     bool fallback) {
   blink::WebGraphicsContext3D::Attributes attrs;
   attrs.shareResources = true;
   attrs.noAutomaticFlushes = true;
 
   DCHECK(window_);
   DCHECK(surface_id_);
 
   scoped_refptr<ContextProviderCommandBuffer> context_provider =
@@ skipping 13 matching lines @@
 }
 
 scoped_refptr<cc::ContextProvider> CompositorImpl::OffscreenContextProvider() {
   // There is no support for offscreen contexts, or compositor filters that
   // would require them in this compositor instance. If they are needed,
   // then implement a context provider that provides contexts from
   // ImageTransportSurfaceAndroid.
   return NULL;
 }
 
-void CompositorImpl::DidCompleteSwapBuffers() {
-  client_->OnSwapBuffersCompleted();
-}
+void CompositorImpl::ScheduleComposite() {
+  // We already scheduled something.

[Sami, 2014/04/16 15:16:30]

The consumePendingRendererFrame() logic made sure this only took the fast path
if there was a new frame to composite. IIRC I had to add it because something in
the browser (loading spinner, tab switcher, dunno) was often scheduling
compositing and kicking the renderer into high latency mode. It would be good to
double check this doesn't happen with this patch.

+  if (need_to_composite_)
+    return;
 
-void CompositorImpl::ScheduleComposite() {
-  client_->ScheduleComposite();
+  need_to_composite_ = true;
+  base::MessageLoop::current()->PostTask(

[no sievers, 2014/04/16 02:17:28]

It definitely loses the 'post to front of queue' behavior you had added here for
an issue. Is it still necessary?
If so we need to figure out how we handle this with the cc scheduler.

[Sami, 2014/04/16 15:16:30]

I *think* it's still an issue (here's the original description for reference:
https://gerrit-int.chromium.org/43697). It should be fairly obvious from a trace
when it happens. Basically the browser compositor for frame N is delayed by
input for frame N+1. Maybe we could throttle the input to avoid that situation.

[no sievers, 2014/05/09 00:30:05]

Do you mind if I follow up on this separately? Handling this the other way
around by deferring input or so sounds good.

+      FROM_HERE,
+      base::Bind(
+          &CompositorImpl::Composite, weak_factory_.GetWeakPtr(), false));
 }
 
 void CompositorImpl::ScheduleAnimation() {
   ScheduleComposite();
 }
 
 void CompositorImpl::DidPostSwapBuffers() {
   TRACE_EVENT0("compositor", "CompositorImpl::DidPostSwapBuffers");
   client_->OnSwapBuffersPosted();
+  did_post_swapbuffers_ = true;
+}
+
+void CompositorImpl::DidCompleteSwapBuffers() {
+  TRACE_EVENT0("compositor", "CompositorImpl::DidCompleteSwapBuffers");
+  DCHECK_GT(pending_swapbuffers_, 0U);
+  pending_swapbuffers_--;
 }
 
 void CompositorImpl::DidAbortSwapBuffers() {
   TRACE_EVENT0("compositor", "CompositorImpl::DidAbortSwapBuffers");
-  client_->OnSwapBuffersCompleted();
+  DCHECK_GT(pending_swapbuffers_, 0U);
+  pending_swapbuffers_--;
 }
 
 void CompositorImpl::DidCommit() {
   root_window_->OnCompositingDidCommit();
 }
 
 void CompositorImpl::AttachLayerForReadback(scoped_refptr<cc::Layer> layer) {
   root_layer_->AddChild(layer);
 }
 
+void CompositorImpl::OnVSync(base::TimeTicks frame_time,
+                             base::TimeDelta vsync_period) {
+  Composite(true);
+  can_composite_outside_vsync_ = true;
+}
+
 }  // namespace content