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

content/browser/renderer_host/render_widget_host_view_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/render_widget_host_view_android.h"
 
 #include <android/bitmap.h>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 59 matching lines @@
 }  // anonymous namespace
 
 RenderWidgetHostViewAndroid::RenderWidgetHostViewAndroid(
     RenderWidgetHostImpl* widget_host,
     ContentViewCoreImpl* content_view_core)
     : host_(widget_host),
       is_layer_attached_(true),
       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);
 }
 
 RenderWidgetHostViewAndroid::~RenderWidgetHostViewAndroid() {
   SetContentViewCore(NULL);
+  DCHECK(ack_callbacks_.empty());
   if (texture_id_in_layer_ || !last_mailbox_.IsZero()) {
     ImageTransportFactoryAndroid* factory =
         ImageTransportFactoryAndroid::GetInstance();
     // TODO: crbug.com/230137 - make workaround obsolete with refcounting.
     // Don't let the last frame we sent leak in the mailbox.
     if (!last_mailbox_.IsZero()) {
       if (!texture_id_in_layer_)
         texture_id_in_layer_ = factory->CreateTexture();
       factory->AcquireTexture(texture_id_in_layer_, last_mailbox_.name);
       factory->GetContext3D()->getError();  // Clear error if mailbox was empty.
     }
     factory->DeleteTexture(texture_id_in_layer_);
   }
+
+  if (texture_layer_)
+    texture_layer_->ClearClient();
 }
 
 
 bool RenderWidgetHostViewAndroid::OnMessageReceived(
     const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(RenderWidgetHostViewAndroid, message)
     IPC_MESSAGE_HANDLER(ViewHostMsg_ImeBatchStateChanged_ACK,
                         OnProcessImeBatchStateAck)
     IPC_MESSAGE_HANDLER(ViewHostMsg_StartContentIntent, OnStartContentIntent)
@@ skipping 24 matching lines @@
 }
 
 void RenderWidgetHostViewAndroid::WasShown() {
   if (!host_->is_hidden())
     return;
 
   host_->WasShown();
 }
 
 void RenderWidgetHostViewAndroid::WasHidden() {
+  RunAckCallbacks();
+
   if (host_->is_hidden())
     return;
 
   // Inform the renderer that we are being hidden so it can reduce its resource
   // utilization.
   host_->WasHidden();
 }
 
 void RenderWidgetHostViewAndroid::WasResized() {
   if (surface_texture_transport_.get() && content_view_core_)
@@ skipping 423 matching lines @@
   // need to delay the ACK until after commit and use more than a single
   // texture.
   DCHECK(!CompositorImpl::IsThreadingEnabled());
 
   if (texture_id_in_layer_) {
     DCHECK(!current_mailbox_.IsZero());
     ImageTransportFactoryAndroid::GetInstance()->ReleaseTexture(
         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(
       texture_id_in_layer_, mailbox.name);
 
   texture_layer_->SetNeedsDisplay();
   texture_layer_->SetBounds(gfx::Size(content_size.width(),
                                       content_size.height()));
 
   // Calculate the uv_max based on the content size relative to the texture
   // size.
   gfx::PointF uv_max;
   if (texture_size.GetArea() > 0) {
     uv_max.SetPoint(content_size.width() / texture_size.width(),
                     content_size.height() / texture_size.height());
   }
   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(
     const GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params& params,
     int gpu_host_id) {
   NOTREACHED();
 }
 
 void RenderWidgetHostViewAndroid::AcceleratedSurfaceSuspend() {
   NOTREACHED();
 }
 
 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;
     current_mailbox_ = gpu::Mailbox();
   }
 }
 
 bool RenderWidgetHostViewAndroid::HasAcceleratedSurface(
     const gfx::Size& desired_size) {
   NOTREACHED();
@@ skipping 105 matching lines @@
   if (host_)
     host_->MoveCaret(point);
 }
 
 SkColor RenderWidgetHostViewAndroid::GetCachedBackgroundColor() const {
   return cached_background_color_;
 }
 
 void RenderWidgetHostViewAndroid::SetContentViewCore(
     ContentViewCoreImpl* content_view_core) {
+  RunAckCallbacks();
+
   if (content_view_core_ && is_layer_attached_)
     content_view_core_->RemoveLayer(layer_);
 
   content_view_core_ = content_view_core;
   if (content_view_core_ && is_layer_attached_)
     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) {
   const gfx::Display& display =
       gfx::Screen::GetNativeScreen()->GetPrimaryDisplay();
   results->rect = display.bounds();
   // TODO(husky): Remove any system controls from availableRect.
   results->availableRect = display.work_area();
   results->deviceScaleFactor = display.device_scale_factor();
   gfx::DeviceDisplayInfo info;
   results->depth = info.GetBitsPerPixel();
   results->depthPerComponent = info.GetBitsPerComponent();
   results->isMonochrome = (results->depthPerComponent == 0);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostView, public:
 
 // static
 RenderWidgetHostView*
 RenderWidgetHostView::CreateViewForWidget(RenderWidgetHost* widget) {
   RenderWidgetHostImpl* rwhi = RenderWidgetHostImpl::From(widget);
   return new RenderWidgetHostViewAndroid(rwhi, NULL);
 }
 
 } // namespace content