Drop frontbuffers with ui-use-gpu-process, synchronized with browser, decoupled from backbuffer dro…

content/browser/renderer_host/render_widget_host_view_aura.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_aura.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/logging.h"
-#include "base/memory/weak_ptr.h"
 #include "base/message_loop.h"
 #include "base/string_number_conversions.h"
 #include "content/browser/renderer_host/backing_store_skia.h"
 #include "content/browser/renderer_host/dip_util.h"
 #include "content/browser/renderer_host/image_transport_client.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/browser/renderer_host/web_input_event_aura.h"
 #include "content/common/gpu/client/gl_helper.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/port/browser/render_widget_host_view_port.h"
@@ skipping 184 matching lines @@
       ALLOW_THIS_IN_INITIALIZER_LIST(window_(new aura::Window(this))),
       in_shutdown_(false),
       is_fullscreen_(false),
       popup_parent_host_view_(NULL),
       popup_child_host_view_(NULL),
       is_loading_(false),
       text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
       can_compose_inline_(true),
       has_composition_text_(false),
       current_surface_(0),
+      route_id_(0),
+      gpu_host_id_(0),
+      weak_factory_(this),
+      current_valid_release_front_request_id_(0),
+      is_thumbnailing_(false),
       paint_canvas_(NULL),
       synthetic_move_sent_(false),
       needs_update_texture_(false) {
   host_->SetView(this);
   window_observer_.reset(new WindowObserver(this));
   window_->AddObserver(window_observer_.get());
   aura::client::SetTooltipText(window_, &tooltip_);
   aura::client::SetActivationDelegate(window_, this);
 }
 
 RenderWidgetHostViewAura::~RenderWidgetHostViewAura() {
   if (!shared_surface_handle_.is_null()) {
     ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
     factory->DestroySharedSurfaceHandle(shared_surface_handle_);
     factory->RemoveObserver(this);
   }
   window_->RemoveObserver(window_observer_.get());
   UnlockMouse();
   if (popup_type_ != WebKit::WebPopupTypeNone) {
     DCHECK(popup_parent_host_view_);
     popup_parent_host_view_->popup_child_host_view_ = NULL;
   }
   aura::client::SetTooltipText(window_, NULL);
+  weak_factory_.InvalidateWeakPtrs();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura, RenderWidgetHostView implementation:
 
 void RenderWidgetHostViewAura::InitAsChild(
     gfx::NativeView parent_view) {
   window_->Init(ui::LAYER_TEXTURED);
   window_->SetName("RenderWidgetHostViewAura");
 }
@@ skipping 27 matching lines @@
   Show();
   Focus();
 }
 
 RenderWidgetHost* RenderWidgetHostViewAura::GetRenderWidgetHost() const {
   return host_;
 }
 
 void RenderWidgetHostViewAura::DidBecomeSelected() {
   host_->WasRestored();
+  InvalidatePendingRequestReleaseFrontRequest();
+  if (!route_id_ || !gpu_host_id_)
+    return;
+  RenderWidgetHostImpl::SendFrontSurfaceIsProtected(true,
+                                                    route_id_,
+                                                    gpu_host_id_);
 }
 
 void RenderWidgetHostViewAura::WasHidden() {
   host_->WasHidden();
+  InvalidatePendingRequestReleaseFrontRequest();
+  if (!route_id_ || !gpu_host_id_)
+    return;
+  RenderWidgetHostImpl::SendFrontSurfaceIsProtected(false,
+                                                    route_id_,
+                                                    gpu_host_id_);
 }
 
 void RenderWidgetHostViewAura::SetSize(const gfx::Size& size) {
   SetBounds(gfx::Rect(window_->bounds().origin(), size));
 }
 
 void RenderWidgetHostViewAura::SetBounds(const gfx::Rect& rect) {
   if (window_->bounds().size() != rect.size() &&
       host_->is_accelerated_compositing_active()) {
     resize_locks_.push_back(make_linked_ptr(
@@ skipping 142 matching lines @@
 BackingStore* RenderWidgetHostViewAura::AllocBackingStore(
     const gfx::Size& size) {
   return new BackingStoreSkia(host_, size);
 }
 
 void RenderWidgetHostViewAura::CopyFromCompositingSurface(
     const gfx::Size& size,
     skia::PlatformCanvas* output,
     base::Callback<void(bool)> callback) {
   base::ScopedClosureRunner scoped_callback_runner(base::Bind(callback, false));
+  if (is_thumbnailing_)
+    return;
+
   ui::Compositor* compositor = GetCompositor();
   if (!compositor)
     return;
 
   std::map<uint64, scoped_refptr<ImageTransportClient> >::iterator it =
       image_transport_clients_.find(current_surface_);
   if (it == image_transport_clients_.end())
     return;
 
   ImageTransportClient* container = it->second;
   DCHECK(container);
 
   gfx::Size size_in_pixel = content::ConvertSizeToPixel(this, size);
   if (!output->initialize(
       size_in_pixel.width(), size_in_pixel.height(), true))
     return;
 
   ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
   content::GLHelper* gl_helper = factory->GetGLHelper(compositor);
   if (!gl_helper)
     return;
 
   unsigned char* addr = static_cast<unsigned char*>(
       output->getTopDevice()->accessBitmap(true).getPixels());
   scoped_callback_runner.Release();
+  is_thumbnailing_ = true;
+  base::Callback<void(bool)> internal_callback = base::Bind(
+      &RenderWidgetHostViewAura::CopyFromCompositingSurfaceFinished,
+      weak_factory_.GetWeakPtr(),
+      callback);
   gl_helper->CopyTextureTo(container->texture_id(),
                            container->size(),
                            size_in_pixel,
                            addr,
-                           callback);
+                           internal_callback);
+}
+
+void RenderWidgetHostViewAura::CopyFromCompositingSurfaceFinished(
+    base::Callback<void(bool)> callback, bool result) {
+  is_thumbnailing_ = false;
+  for (size_t i = 0; i != delayed_release_front_acks_.size(); ++i)
+    delayed_release_front_acks_[i].Run();
+  delayed_release_front_acks_.clear();
+  callback.Run(result);
 }
 
 void RenderWidgetHostViewAura::OnAcceleratedCompositingStateChange() {
   // Delay UpdateExternalTexture until we actually got a software frame.
   // Sometimes (e.g. on a page load) the renderer will spuriously disable then
   // re-enable accelerated compositing, causing us to flash.
   // TODO(piman): factor the enable/disable accelerated compositing message into
   // the UpdateRect/AcceleratedSurfaceBuffersSwapped messages so that we have
   // fewer inconsistent temporary states.
   needs_update_texture_ = true;
@@ skipping 52 matching lines @@
     }
   } else {
     window_->SetExternalTexture(NULL);
     resize_locks_.clear();
   }
 }
 
 void RenderWidgetHostViewAura::AcceleratedSurfaceBuffersSwapped(
     const GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params& params_in_pixel,
     int gpu_host_id) {
+  InvalidatePendingRequestReleaseFrontRequest();
   current_surface_ = params_in_pixel.surface_handle;
   UpdateExternalTexture();
 
   ui::Compositor* compositor = GetCompositor();
   if (!compositor) {
     // We have no compositor, so we have no way to display the surface.
     // Must still send the ACK.
     RenderWidgetHostImpl::AcknowledgeSwapBuffers(params_in_pixel.route_id,
         gpu_host_id);
   } else {
@@ skipping 17 matching lines @@
                      params_in_pixel.route_id, gpu_host_id));
       if (!compositor->HasObserver(this))
         compositor->AddObserver(this);
     }
   }
 }
 
 void RenderWidgetHostViewAura::AcceleratedSurfacePostSubBuffer(
     const GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params& params_in_pixel,
     int gpu_host_id) {
+  InvalidatePendingRequestReleaseFrontRequest();
   current_surface_ = params_in_pixel.surface_handle;
   UpdateExternalTexture();
 
   ui::Compositor* compositor = GetCompositor();
   if (!compositor) {
     // We have no compositor, so we have no way to display the surface
     // Must still send the ACK
     RenderWidgetHostImpl::AcknowledgePostSubBuffer(
         params_in_pixel.route_id, gpu_host_id);
   } else {
+    DCHECK(image_transport_clients_.find(params_in_pixel.surface_handle) !=
+           image_transport_clients_.end());
     gfx::Size surface_size_in_pixel =
         image_transport_clients_[params_in_pixel.surface_handle]->size();
 
     // Co-ordinates come in OpenGL co-ordinate space.
     // We need to convert to layer space.
     gfx::Rect rect_to_paint = content::ConvertRectToDIP(this, gfx::Rect(
         params_in_pixel.x,
         surface_size_in_pixel.height() - params_in_pixel.y -
             params_in_pixel.height,
         params_in_pixel.width,
@@ skipping 26 matching lines @@
   // Aura doesn't use GetBackingStore for accelerated pages, so it doesn't
   // matter what is returned here as GetBackingStore is the only caller of this
   // method. TODO(jbates) implement this if other Aura code needs it.
   return false;
 }
 
 void RenderWidgetHostViewAura::AcceleratedSurfaceNew(
       int32 width_in_pixel,
       int32 height_in_pixel,
       uint64* surface_handle,
-      TransportDIB::Handle* shm_handle) {
+      TransportDIB::Handle* shm_handle,
+      int32 route_id,
+      int gpu_host_id) {
   ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
   scoped_refptr<ImageTransportClient> surface(factory->CreateTransportClient(
         gfx::Size(width_in_pixel, height_in_pixel), surface_handle));
   if (!surface) {
     LOG(ERROR) << "Failed to create ImageTransportClient";
     return;
   }
   *shm_handle = surface->Handle();
 
   image_transport_clients_[*surface_handle] = surface;
+
+  route_id_ = route_id;
+  gpu_host_id_ = gpu_host_id;
+  RenderWidgetHostImpl::SendFrontSurfaceIsProtected(host_->IsVisible(),
+                                                    route_id_,
+                                                    gpu_host_id_);
 }
 
 void RenderWidgetHostViewAura::AcceleratedSurfaceRelease(
     uint64 surface_handle) {
   if (current_surface_ == surface_handle) {
     current_surface_ = 0;
     UpdateExternalTexture();
   }
   image_transport_clients_.erase(surface_handle);
 }
 
+void RenderWidgetHostViewAura::AcceleratedSurfaceRequestReleaseFront(
+    uint64 surface_handle,
+    int request_id,
+    int retry_count,
+    int32 route_id,
+    int gpu_host_id) {
+  // TODO(mmocny): Once we have implemented smooth tab switching on aura
+  // (crbug.com/126526) then this flag should switch to enabled by default, or
+  // be removed altogether.
+  if (!CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kEnableUIReleaseFrontSurface))
+    return;
+
+  // This request id becomes the only valid id.  We use this id to for request
+  // invalidation and to protect against visibility state ABA issues.
+  current_valid_release_front_request_id_ = request_id;
+
+  // This surface may have already been released if multiple suggestions were
+  // sent.  Always send a reply since previous response may have been discarded.
+  if (image_transport_clients_.find(surface_handle) ==
+      image_transport_clients_.end()) {
+    SendRequestReleaseFrontAckAfterThumbnailIfNecessary(request_id,
+                                                        retry_count,
+                                                        true,
+                                                        route_id,
+                                                        gpu_host_id);
+    return;
+  }
+  DCHECK(current_surface_ == surface_handle);
+
+  // Confirm that the surface is not in use, by making sure the tab is not
+  // visible (visibility can change since the time the request was sent out).
+  if (host_->IsVisible()) {
+    // Send an ACK informing the gpu that we are ignoring this request.
+    RenderWidgetHostImpl::AcknowledgeRequestReleaseFront(
+        request_id, retry_count, false, route_id, gpu_host_id);
+    return;
+  }
+
+  base::Callback<void(void)> send_ack_if_valid_callback =
+      base::Bind(&RenderWidgetHostViewAura::ReleaseFrontSurfaceIfStillValid,
+                 weak_factory_.GetWeakPtr(),
+                 surface_handle,
+                 request_id,
+                 retry_count,
+                 route_id,
+                 gpu_host_id);
+
+  ui::Compositor* compositor = GetCompositor();
+  // We may still be using the surface for the duration of a composite, so check
+  // that we aren't currently in the middle of one.
+  if (!compositor->CurrentlyCompositing()) {
+    send_ack_if_valid_callback.Run();
+    return;
+  }
+
+  // We are in the middle of a composite, so we must delay reply.
+  on_compositing_ended_callbacks_.push_back(send_ack_if_valid_callback);
+  if (!compositor->HasObserver(this))
+    compositor->AddObserver(this);
+}
+
+void RenderWidgetHostViewAura::InvalidatePendingRequestReleaseFrontRequest() {
+  current_valid_release_front_request_id_ = 0;
+}
+
+void RenderWidgetHostViewAura::ReleaseFrontSurfaceIfStillValid(
+    uint64 surface_handle,
+    int request_id,
+    int retry_count,
+    int32 route_id,
+    int gpu_host_id) {
+  // Check if this request_id is valid.  No need to send an ACK if not, since
+  // the newer, currently valid request will send one.
+  if (current_valid_release_front_request_id_ != request_id)
+    return;
+
+  DCHECK(!host_->IsVisible());
+  DCHECK(current_surface_ == surface_handle);
+
+  // Release our handle to the surface.
+  AcceleratedSurfaceRelease(surface_handle);
+  DCHECK(!current_surface_);
+
+  // Now reply to the gpu process, potentially delayed during thumbnailing.
+  SendRequestReleaseFrontAckAfterThumbnailIfNecessary(request_id,
+                                                      retry_count,
+                                                      true,
+                                                      route_id,
+                                                      gpu_host_id);
+}
+
+void RenderWidgetHostViewAura::
+    SendRequestReleaseFrontAckAfterThumbnailIfNecessary(
+        int request_id,
+        int retry_count,
+        bool was_released,
+        int32 route_id,
+        int gpu_host_id) {
+  base::Callback<void(void)> request_release_front_ack =
+      base::Bind(&RenderWidgetHostImpl::AcknowledgeRequestReleaseFront,
+                 request_id,
+                 retry_count,
+                 was_released,
+                 route_id,
+                 gpu_host_id);
+  if (is_thumbnailing_)
+    delayed_release_front_acks_.push_back(request_release_front_ack);
+  else
+    request_release_front_ack.Run();
+}
+
 void RenderWidgetHostViewAura::SetBackground(const SkBitmap& background) {
   content::RenderWidgetHostViewBase::SetBackground(background);
   host_->SetBackground(background);
   window_->layer()->SetFillsBoundsOpaquely(background.isOpaque());
 }
 
 void RenderWidgetHostViewAura::GetScreenInfo(WebKit::WebScreenInfo* results) {
   GetScreenInfoForWindow(results, window_);
 }
 
@@ skipping 510 matching lines @@
   RunCompositingCallbacks();
   compositor->RemoveObserver(this);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura, ImageTransportFactoryObserver implementation:
 
 void RenderWidgetHostViewAura::OnLostResources(ui::Compositor* compositor) {
   image_transport_clients_.clear();
   current_surface_ = 0;
+  route_id_ = 0;
+  gpu_host_id_ = 0;
+  current_valid_release_front_request_id_ = 0;
+  is_thumbnailing_ = 0;
+  delayed_release_front_acks_.clear();
   UpdateExternalTexture();
   locks_pending_draw_.clear();
 
   DCHECK(!shared_surface_handle_.is_null());
   ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
   factory->DestroySharedSurfaceHandle(shared_surface_handle_);
   shared_surface_handle_ = factory->CreateSharedSurfaceHandle(compositor);
   host_->CompositingSurfaceUpdated();
   host_->ScheduleComposite();
 }
@@ skipping 126 matching lines @@
 RenderWidgetHostView* RenderWidgetHostView::CreateViewForWidget(
     RenderWidgetHost* widget) {
   return new RenderWidgetHostViewAura(widget);
 }
 
 // static
 void content::RenderWidgetHostViewPort::GetDefaultScreenInfo(
     WebKit::WebScreenInfo* results) {
   GetScreenInfoForWindow(results, NULL);
 }