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();
+  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(
+    cc::ResourceUpdateQueue* queue) {
+  RunAckCallbacks();
+  consumed_current_texture_ = true;
+  return texture_id_in_layer_;
+}
+
+WebKit::WebGraphicsContext3D* RenderWidgetHostViewAndroid::Context3d() {
+  return ImageTransportFactoryAndroid::GetInstance()->GetContext3D();
+}
+
+bool RenderWidgetHostViewAndroid::PrepareTextureMailbox(
+    cc::TextureMailbox* mailbox) {
+  return false;
+}
+
 // 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