Android: Throttle render compositor if browser (compositor) is behind.

content/browser/renderer_host/render_widget_host_view_android.cc

Index: content/browser/renderer_host/render_widget_host_view_android.cc
diff --git a/content/browser/renderer_host/render_widget_host_view_android.cc b/content/browser/renderer_host/render_widget_host_view_android.cc
index e247e3b7b9dcda1813adbbe7c0c1a4f9d9cc33a5..4227a6894d5264a792ca9cf987fa8b80ddd49000 100644
--- a/content/browser/renderer_host/render_widget_host_view_android.cc
+++ b/content/browser/renderer_host/render_widget_host_view_android.cc
@@ -77,17 +77,18 @@ RenderWidgetHostViewAndroid::RenderWidgetHostViewAndroid(
       content_view_core_(NULL),
       ime_adapter_android_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       cached_background_color_(SK_ColorWHITE),
-      texture_id_in_layer_(0) {
+      texture_id_in_layer_(0),
+      consumed_current_texture_(true) {
   if (CompositorImpl::UsesDirectGL()) {
     surface_texture_transport_.reset(new SurfaceTextureTransportClient());
     layer_ = surface_texture_transport_->Initialize();
+    layer_->SetIsDrawable(true);
   } else {
-    texture_layer_ = cc::TextureLayer::Create(NULL);
+    texture_layer_ = cc::TextureLayer::Create(this);
     layer_ = texture_layer_;
   }
 
   layer_->SetContentsOpaque(true);
-  layer_->SetIsDrawable(true);
 
   host_->SetView(this);
   SetContentViewCore(content_view_core);
@@ -95,6 +96,7 @@ RenderWidgetHostViewAndroid::RenderWidgetHostViewAndroid(
 
 RenderWidgetHostViewAndroid::~RenderWidgetHostViewAndroid() {
   SetContentViewCore(NULL);
+  DCHECK(ack_callbacks_.empty());
   if (texture_id_in_layer_ || !last_mailbox_.IsZero()) {
     ImageTransportFactoryAndroid* factory =
         ImageTransportFactoryAndroid::GetInstance();
@@ -108,6 +110,9 @@ RenderWidgetHostViewAndroid::~RenderWidgetHostViewAndroid() {
     }
     factory->DeleteTexture(texture_id_in_layer_);
   }
+
+  if (texture_layer_)
+    texture_layer_->ClearClient();
 }
 
 
@@ -152,6 +157,8 @@ void RenderWidgetHostViewAndroid::WasShown() {
 }
 
 void RenderWidgetHostViewAndroid::WasHidden() {
+  RunAckCallbacks();
+
   if (host_->is_hidden())
     return;
 
@@ -595,7 +602,7 @@ void RenderWidgetHostViewAndroid::BuffersSwapped(
         texture_id_in_layer_, current_mailbox_.name);
   } else {
     texture_id_in_layer_ = factory->CreateTexture();
-    texture_layer_->SetTextureId(texture_id_in_layer_);
+    texture_layer_->SetIsDrawable(true);
   }
 
   ImageTransportFactoryAndroid::GetInstance()->AcquireTexture(
@@ -615,7 +622,13 @@ void RenderWidgetHostViewAndroid::BuffersSwapped(
   texture_layer_->SetUV(gfx::PointF(0, 0), uv_max);
   texture_size_in_layer_ = texture_size;
   current_mailbox_ = mailbox;
-  ack_callback.Run();
+
+  if (consumed_current_texture_ || host_->is_hidden())
+    ack_callback.Run();

[piman, 2013/04/19 18:09:12]

Note: this can add a frame of latency when GPU-bound, because the renderer will
ready a frame early, but it'll be queued until after this frame was pushed.
Furthermore, the renderer may submit GPU work (for the next frame) before the
composite for this frame, delaying even more.
I don't know if it's a concern. It'll do the trick to limit renderer throughput.

[brianderson, 2013/04/19 18:49:19]

I'm not sure if this is still true, but I tried to do something similar to this
patch a few months ago and running the callback after the swap kept the renderer
and browser properly ordered on the gpu thread. i.e. even when the renderer
submitted gpu work ahead of time it would always alternate with the browser on
the gpu thread. At the time, the browser was inserting a sync point after the
swap that would unblock the next renderer frame on the gpu thread. The mailbox
path likely behaves differently though.

I agree with the increased latency part if we keep maxFramesPending==2. However,
we should only get increased latency if the renderer is producing faster than
the later pipeline stages (including the gpu hardware) can consume. Ideally we
could avoid setting maxFramesPending==1 since that would reduce concurrency, but
still keep latency low.

Keeping the latency low with maxFramesPending==2 would require us detecting that
we are in a high latency mode and then recovering from it. Unfortunately, we
currently don't have enough feedback to detect that we are in a high latency
mode.

+  else
+    ack_callbacks_.push(ack_callback);
+
+  consumed_current_texture_ = false;
 }
 
 void RenderWidgetHostViewAndroid::AcceleratedSurfacePostSubBuffer(
@@ -632,6 +645,7 @@ void RenderWidgetHostViewAndroid::AcceleratedSurfaceRelease() {
   // This tells us we should free the frontbuffer.
   if (texture_id_in_layer_) {
     texture_layer_->SetTextureId(0);
+    texture_layer_->SetIsDrawable(false);
     ImageTransportFactoryAndroid::GetInstance()->DeleteTexture(
         texture_id_in_layer_);
     texture_id_in_layer_ = 0;
@@ -757,6 +771,8 @@ SkColor RenderWidgetHostViewAndroid::GetCachedBackgroundColor() const {
 
 void RenderWidgetHostViewAndroid::SetContentViewCore(
     ContentViewCoreImpl* content_view_core) {
+  RunAckCallbacks();
+
   if (content_view_core_ && is_layer_attached_)
     content_view_core_->RemoveLayer(layer_);
 
@@ -765,12 +781,30 @@ void RenderWidgetHostViewAndroid::SetContentViewCore(
     content_view_core_->AttachLayer(layer_);
 }
 
+void RenderWidgetHostViewAndroid::RunAckCallbacks() {
+  while (!ack_callbacks_.empty()) {
+    ack_callbacks_.front().Run();
+    ack_callbacks_.pop();
+  }
+}
+
 void RenderWidgetHostViewAndroid::HasTouchEventHandlers(
     bool need_touch_events) {
   if (content_view_core_)
     content_view_core_->HasTouchEventHandlers(need_touch_events);
 }
 
+unsigned RenderWidgetHostViewAndroid::PrepareTexture(

[no sievers, 2013/04/19 17:57:17]

Well, it's update resources, not really post commit. But doesn't matter for what
we have now (single-threaded browser compositor).

Soon I should be able to change this to share the frontbuffer texture and pass
the mailbox to the texture layer.

About delegated layers: Do you think it would be straightforward to also have a
callback on the layer for when commit happened and unused resources are
returned? I really like not having the path back from the compositor to all the
views for didCommit on Android (since we don't have the whole aura ui layer on
top of things to abstract this nicely, and already have too many pointers
between native and Java objects in this area).

+    cc::ResourceUpdateQueue* queue) {
+  RunAckCallbacks();
+  consumed_current_texture_ = true;
+  return texture_id_in_layer_;
+}
+
+WebKit::WebGraphicsContext3D* RenderWidgetHostViewAndroid::Context3d() {
+  return ImageTransportFactoryAndroid::GetInstance()->GetContext3D();
+}
+
 // static
 void RenderWidgetHostViewPort::GetDefaultScreenInfo(
     WebKit::WebScreenInfo* results) {