[cc] Evict UIResources when the renderer is not visible

cc/trees/layer_tree_impl.cc

 // Copyright 2011 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 "cc/trees/layer_tree_impl.h"
 
 #include "base/debug/trace_event.h"
 #include "cc/animation/keyframed_animation_curve.h"
 #include "cc/animation/scrollbar_animation_controller.h"
 #include "cc/debug/traced_value.h"
@@ skipping 15 matching lines @@
       currently_scrolling_layer_(NULL),
       root_layer_scroll_offset_delegate_(NULL),
       background_color_(0),
       has_transparent_background_(false),
       page_scale_factor_(1),
       page_scale_delta_(1),
       sent_page_scale_delta_(1),
       min_page_scale_factor_(0),
       max_page_scale_factor_(0),
       scrolling_layer_id_from_previous_tree_(0),
+      ui_resource_eviction_count_recreated_(0),
       contents_textures_purged_(false),
       viewport_size_invalid_(false),
       needs_update_draw_properties_(true),
       needs_full_tree_sync_(true) {
 }
 
 LayerTreeImpl::~LayerTreeImpl() {
   // Need to explicitly clear the tree prior to destroying this so that
   // the LayerTreeImpl pointer is still valid in the LayerImpl dtor.
   root_layer_.reset();
@@ skipping 73 matching lines @@
   // LayerTreeHost::finishCommitOnImplThread().
   target_tree->set_source_frame_number(source_frame_number());
   target_tree->set_background_color(background_color());
   target_tree->set_has_transparent_background(has_transparent_background());
 
   if (ContentsTexturesPurged())
     target_tree->SetContentsTexturesPurged();
   else
     target_tree->ResetContentsTexturesPurged();
 
+  target_tree->SetUIResourceEvictionCountRecreated(
+      ui_resource_eviction_count_recreated_);
+
   if (ViewportSizeInvalid())
     target_tree->SetViewportSizeInvalid();
   else
     target_tree->ResetViewportSizeInvalid();
 
   if (hud_layer())
     target_tree->set_hud_layer(static_cast<HeadsUpDisplayLayerImpl*>(
         LayerTreeHostCommon::FindLayerInSubtree(
             target_tree->root_layer(), hud_layer()->id())));
   else
@@ skipping 237 matching lines @@
 }
 
 void LayerTreeImpl::DidBecomeActive() {
   if (!root_layer())
     return;
 
   DidBecomeActiveRecursive(root_layer());
   FindRootScrollLayer();
 }
 
+void LayerTreeImpl::SetUIResourceEvictionCountRecreated(
+    uint64 ui_resource_eviction_count_recreated) {
+  if (ui_resource_eviction_count_recreated ==
+      ui_resource_eviction_count_recreated_)
+    return;
+
+  ui_resource_eviction_count_recreated_ = ui_resource_eviction_count_recreated;
+  layer_tree_host_impl_->OnCanDrawStateChangedForTree();
+}
+
+bool LayerTreeImpl::UIResourcesEvictedHaveNotBeenRecreated() const {
+  return layer_tree_host_impl_->ui_resource_eviction_count() !=
+      ui_resource_eviction_count_recreated_;
+}
+
 bool LayerTreeImpl::ContentsTexturesPurged() const {
   return contents_textures_purged_;
 }
 
 void LayerTreeImpl::SetContentsTexturesPurged() {
   if (contents_textures_purged_)
     return;
   contents_textures_purged_ = true;
   layer_tree_host_impl_->OnCanDrawStateChangedForTree();
 }
@@ skipping 221 matching lines @@
     UIResourceRequest req = ui_resource_request_queue_.front();
     ui_resource_request_queue_.pop_front();
 
     switch (req.type) {
       case UIResourceRequest::UIResourceCreate:
         layer_tree_host_impl_->CreateUIResource(req.id, req.bitmap);
         break;
       case UIResourceRequest::UIResourceDelete:
         layer_tree_host_impl_->DeleteUIResource(req.id);
         break;
+      case UIResourceRequest::UIResourceEvictionRecreated:
+        SetUIResourceEvictionCountRecreated(req.eviction_count_recreated);
+        break;
       case UIResourceRequest::UIResourceInvalidRequest:
         NOTREACHED();
         break;
     }
   }
 }
 
 void LayerTreeImpl::AddLayerWithCopyOutputRequest(LayerImpl* layer) {
   // Only the active tree needs to know about layers with copy requests, as
   // they are aborted if not serviced during draw.
@@ skipping 21 matching lines @@
 const std::vector<LayerImpl*> LayerTreeImpl::LayersWithCopyOutputRequest()
     const {
   // Only the active tree needs to know about layers with copy requests, as
   // they are aborted if not serviced during draw.
   DCHECK(IsActiveTree());
 
   return layers_with_copy_output_request_;
 }
 
 }  // namespace cc