Aura/ÜC: Drop frames on background tabs

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/basictypes.h"
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
@@ skipping 531 matching lines @@
   }
  private:
   RenderWidgetHostViewAura* view_;
   aura::Window* top_level_;
 
   DISALLOW_COPY_AND_ASSIGN(TransientWindowObserver);
 };
 
 #endif
 
+RenderWidgetHostViewAura::DelegatedFrameEvictionObserver::
+    DelegatedFrameEvictionObserver(RenderWidgetHostViewAura* view)
+    : view_(view), has_frame_(false) {}
+
+RenderWidgetHostViewAura::DelegatedFrameEvictionObserver::
+    ~DelegatedFrameEvictionObserver() {
+  DiscardedFrame();
+}
+
+void RenderWidgetHostViewAura::DelegatedFrameEvictionObserver::SwappedFrame(
+    bool visible) {
+  has_frame_ = true;
+  RendererFrameManager::GetInstance()->AddFrame(this, visible);
+}
+
+void
+RenderWidgetHostViewAura::DelegatedFrameEvictionObserver::DiscardedFrame() {
+  RendererFrameManager::GetInstance()->RemoveFrame(this);
+  has_frame_ = false;
+}
+
+void RenderWidgetHostViewAura::DelegatedFrameEvictionObserver::SetVisible(
+    bool visible) {
+  if (has_frame_)
+    RendererFrameManager::GetInstance()->SetFrameVisibility(this, visible);
+}
+
+void
+RenderWidgetHostViewAura::DelegatedFrameEvictionObserver::EvictCurrentFrame() {
+  view_->EvictDelegatedFrame();
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura, public:
 
 RenderWidgetHostViewAura::RenderWidgetHostViewAura(RenderWidgetHost* host)
     : host_(RenderWidgetHostImpl::From(host)),
       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),
       text_input_mode_(ui::TEXT_INPUT_MODE_DEFAULT),
       can_compose_inline_(true),
       has_composition_text_(false),
       last_output_surface_id_(0),
       pending_delegated_ack_count_(0),
       skipped_frames_(false),
       last_swapped_surface_scale_factor_(1.f),
       paint_canvas_(NULL),
       synthetic_move_sent_(false),
       accelerated_compositing_state_changed_(false),
       can_lock_compositor_(YES),
       cursor_visibility_state_in_renderer_(UNKNOWN),
       paint_observer_(NULL),
       touch_editing_client_(NULL),
+      delegated_frame_eviction_observer_(this),
       weak_ptr_factory_(this) {
   host_->SetView(this);
   window_observer_.reset(new WindowObserver(this));
   aura::client::SetTooltipText(window_, &tooltip_);
   aura::client::SetActivationDelegate(window_, this);
   aura::client::SetActivationChangeObserver(window_, this);
   aura::client::SetFocusChangeObserver(window_, this);
   gfx::Screen::GetScreenFor(window_)->AddObserver(this);
 #if defined(OS_WIN)
   transient_observer_.reset(new TransientWindowObserver(this));
@@ skipping 78 matching lines @@
 RenderWidgetHost* RenderWidgetHostViewAura::GetRenderWidgetHost() const {
   return host_;
 }
 
 void RenderWidgetHostViewAura::WasShown() {
   DCHECK(host_);
   if (!host_->is_hidden())
     return;
   host_->WasShown();
   software_frame_manager_->SetVisibility(true);
+  delegated_frame_eviction_observer_.SetVisible(true);
 
   aura::Window* root = window_->GetRootWindow();
   if (root) {
     aura::client::CursorClient* cursor_client =
         aura::client::GetCursorClient(root);
     if (cursor_client)
       NotifyRendererOfCursorVisibilityState(cursor_client->IsCursorVisible());
   }
 
   if (!current_surface_.get() && host_->is_accelerated_compositing_active() &&
       !released_front_lock_.get()) {
     ui::Compositor* compositor = GetCompositor();
     if (compositor)
       released_front_lock_ = compositor->GetCompositorLock();
   }
 
 #if defined(OS_WIN)
   LPARAM lparam = reinterpret_cast<LPARAM>(this);
   EnumChildWindows(ui::GetHiddenWindow(), ShowWindowsCallback, lparam);
   transient_observer_->SendPluginCutoutRects();
 #endif
 }
 
 void RenderWidgetHostViewAura::WasHidden() {
   if (!host_ || host_->is_hidden())
     return;
   host_->WasHidden();
   software_frame_manager_->SetVisibility(false);
+  delegated_frame_eviction_observer_.SetVisible(false);
   released_front_lock_ = NULL;
 
 #if defined(OS_WIN)
   aura::WindowEventDispatcher* dispatcher = window_->GetDispatcher();
   if (dispatcher) {
     HWND parent = dispatcher->GetAcceleratedWidget();
     LPARAM lparam = reinterpret_cast<LPARAM>(this);
 
     EnumChildWindows(parent, HideWindowsCallback, lparam);
   }
@@ skipping 722 matching lines @@
   if (output_surface_id != last_output_surface_id_) {
     // Resource ids are scoped by the output surface.
     // If the originating output surface doesn't match the last one, it
     // indicates the renderer's output surface may have been recreated, in which
     // case we should recreate the DelegatedRendererLayer, to avoid matching
     // resources from the old one with resources from the new one which would
     // have the same id. Changing the layer to showing painted content destroys
     // the DelegatedRendererLayer.
     window_->layer()->SetShowPaintedContent();
     frame_provider_ = NULL;
+    delegated_frame_eviction_observer_.DiscardedFrame();
 
     // Drop the cc::DelegatedFrameResourceCollection so that we will not return
     // any resources from the old output surface with the new output surface id.
     if (resource_collection_.get()) {
       resource_collection_->SetClient(NULL);
 
       if (resource_collection_->LoseAllResources())
         SendReturnedDelegatedResources(last_output_surface_id_);
 
       resource_collection_ = NULL;
     }
     last_output_surface_id_ = output_surface_id;
   }
   if (frame_size.IsEmpty()) {
     DCHECK_EQ(0u, frame_data->resource_list.size());
     window_->layer()->SetShowPaintedContent();

[danakj, 2013/10/28 21:39:21]

Should this just call EvictDelegatedFrame() rather than duplicating it? Or do
you see value in that?

[piman, 2013/10/28 22:08:38]

Done, and above as well.

     frame_provider_ = NULL;
+    delegated_frame_eviction_observer_.DiscardedFrame();
   } else {
     if (!resource_collection_) {
       resource_collection_ = new cc::DelegatedFrameResourceCollection;
       resource_collection_->SetClient(this);
     }
     if (!frame_provider_.get() || frame_size != frame_provider_->frame_size()) {
       frame_provider_ = new cc::DelegatedFrameProvider(
           resource_collection_.get(), frame_data.Pass());
       window_->layer()->SetShowDelegatedContent(frame_provider_.get(),
                                                 frame_size_in_dip);
@@ skipping 15 matching lines @@
   if (!compositor) {
     SendDelegatedFrameAck(output_surface_id);
   } else {
     compositor->SetLatencyInfo(latency_info);
     AddOnCommitCallbackAndDisableLocks(
         base::Bind(&RenderWidgetHostViewAura::SendDelegatedFrameAck,
                    AsWeakPtr(),
                    output_surface_id));
   }
   DidReceiveFrameFromRenderer();
+  if (frame_provider_.get())
+    delegated_frame_eviction_observer_.SwappedFrame(!host_->is_hidden());
+  // Note: the frame may have been evicted immediately.
 }
 
 void RenderWidgetHostViewAura::SendDelegatedFrameAck(uint32 output_surface_id) {
   cc::CompositorFrameAck ack;
   if (resource_collection_)
     resource_collection_->TakeUnusedResourcesForChildCompositor(&ack.resources);
   RenderWidgetHostImpl::SendSwapCompositorFrameAck(host_->GetRoutingID(),
                                                    output_surface_id,
                                                    host_->GetProcess()->GetID(),
                                                    ack);
@@ skipping 14 matching lines @@
   if (resource_collection_)
     resource_collection_->TakeUnusedResourcesForChildCompositor(&ack.resources);
   DCHECK(!ack.resources.empty());
   RenderWidgetHostImpl::SendReclaimCompositorResources(
       host_->GetRoutingID(),
       output_surface_id,
       host_->GetProcess()->GetID(),
       ack);
 }
 
+void RenderWidgetHostViewAura::EvictDelegatedFrame() {
+  DCHECK(frame_provider_.get());
+  window_->layer()->SetShowPaintedContent();
+  frame_provider_ = NULL;
+  delegated_frame_eviction_observer_.DiscardedFrame();
+}
+
 void RenderWidgetHostViewAura::SwapSoftwareFrame(
     uint32 output_surface_id,
     scoped_ptr<cc::SoftwareFrameData> frame_data,
     float frame_device_scale_factor,
     const ui::LatencyInfo& latency_info) {
   const gfx::Size& frame_size = frame_data->size;
   const gfx::Rect& damage_rect = frame_data->damage_rect;
   gfx::Size frame_size_in_dip =
       ConvertSizeToDIP(frame_device_scale_factor, frame_size);
   if (ShouldSkipFrame(frame_size_in_dip)) {
@@ skipping 238 matching lines @@
 }
 
 void RenderWidgetHostViewAura::AcceleratedSurfaceRelease() {
   // This really tells us to release the frontbuffer.
   if (current_surface_.get()) {
     ui::Compositor* compositor = GetCompositor();
     if (compositor) {
       // We need to wait for a commit to clear to guarantee that all we
       // will not issue any more GL referencing the previous surface.
       AddOnCommitCallbackAndDisableLocks(
-          base::Bind(&RenderWidgetHostViewAura::
-                     SetSurfaceNotInUseByCompositor,
+          base::Bind(&RenderWidgetHostViewAura::SetSurfaceNotInUseByCompositor,
                      AsWeakPtr(),
                      current_surface_));  // Hold a ref so the texture will not
                                           // get deleted until after commit.
     }
     current_surface_ = NULL;
     UpdateExternalTexture();
   }
 }
 
 bool RenderWidgetHostViewAura::HasAcceleratedSurface(
@@ skipping 1602 matching lines @@
     RenderWidgetHost* widget) {
   return new RenderWidgetHostViewAura(widget);
 }
 
 // static
 void RenderWidgetHostViewPort::GetDefaultScreenInfo(WebScreenInfo* results) {
   GetScreenInfoForWindow(results, NULL);
 }
 
 }  // namespace content