[cc] Evict UIResources when the renderer is not visible

cc/trees/layer_tree_host.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_host.h"
 
 #include <algorithm>
 #include <stack>
 
 #include "base/bind.h"
@@ skipping 44 matching lines @@
       using_offscreen_context3d(false),
       max_texture_size(0),
       avoid_pow2_textures(false),
       using_map_image(false),
       using_shared_memory_resources(false),
       using_discard_framebuffer(false) {}
 
 RendererCapabilities::~RendererCapabilities() {}
 
 UIResourceRequest::UIResourceRequest()
-    : type(UIResourceInvalidRequest), id(0), bitmap(NULL) {}
+    : type(UIResourceInvalidRequest),
+      id(0),
+      bitmap(NULL),
+      eviction_count_recreated(0) {}
 
 UIResourceRequest::~UIResourceRequest() {}
 
 bool LayerTreeHost::AnyLayerTreeHostInstanceExists() {
   return s_num_layer_tree_instances > 0;
 }
 
 scoped_ptr<LayerTreeHost> LayerTreeHost::Create(
     LayerTreeHostClient* client,
     const LayerTreeSettings& settings,
     scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner) {
   scoped_ptr<LayerTreeHost> layer_tree_host(new LayerTreeHost(client,
                                                               settings));
   if (!layer_tree_host->Initialize(impl_task_runner))
     return scoped_ptr<LayerTreeHost>();
   return layer_tree_host.Pass();
 }
 
 static int s_next_tree_id = 1;
 
 LayerTreeHost::LayerTreeHost(LayerTreeHostClient* client,
                              const LayerTreeSettings& settings)
     : next_ui_resource_id_(1),
+      ui_resource_eviction_count_recreated_(0),
       animating_(false),
       needs_full_tree_sync_(true),
       needs_filter_context_(false),
       client_(client),
       source_frame_number_(0),
       rendering_stats_instrumentation_(RenderingStatsInstrumentation::Create()),
       output_surface_can_be_initialized_(true),
       output_surface_lost_(true),
       num_failed_recreate_attempts_(0),
       settings_(settings),
@@ skipping 273 matching lines @@
     // the queue is processed in LayerTreeHostImpl::ActivatePendingTree.
     if (!settings_.impl_side_painting)
       sync_tree->ProcessUIResourceRequestQueue();
   }
   if (overhang_ui_resource_) {
     host_impl->SetOverhangUIResource(
         overhang_ui_resource_->id(),
         overhang_ui_resource_->GetSize());
   }
 
+  // If all UI resource evictions will not be recreated by this commit, then
+  // another commit is required.
+  if (ui_resource_eviction_count_recreated_ !=
+      host_impl->ui_resource_eviction_count()) {
+    host_impl->SetNeedsCommit();
+  }
+
   DCHECK(!sync_tree->ViewportSizeInvalid());
 
   if (new_impl_tree_has_no_evicted_resources) {
     if (sync_tree->ContentsTexturesPurged())
       sync_tree->ResetContentsTexturesPurged();
   }
 
   if (!settings_.impl_side_painting) {
     // If we're not in impl-side painting, the tree is immediately
     // considered active.
@@ skipping 45 matching lines @@
   return host_impl.Pass();
 }
 
 void LayerTreeHost::DidLoseOutputSurface() {
   TRACE_EVENT0("cc", "LayerTreeHost::DidLoseOutputSurface");
   DCHECK(proxy_->IsMainThread());
 
   if (output_surface_lost_)
     return;
 
-  bool resource_lost = true;
-  RecreateUIResources(resource_lost);
-
   num_failed_recreate_attempts_ = 0;
   output_surface_lost_ = true;
   SetNeedsCommit();
 }
 
 bool LayerTreeHost::CompositeAndReadback(void* pixels,
                                          gfx::Rect rect_in_device_viewport) {
   trigger_idle_updates_ = false;
   bool ret = proxy_->CompositeAndReadback(pixels, rect_in_device_viewport);
   trigger_idle_updates_ = true;
@@ skipping 709 matching lines @@
   if (iter == ui_resource_client_map_.end())
     return;
 
   UIResourceRequest request;
   request.type = UIResourceRequest::UIResourceDelete;
   request.id = uid;
   ui_resource_request_queue_.push_back(request);
   ui_resource_client_map_.erase(uid);
 }
 
-void LayerTreeHost::RecreateUIResources(bool resource_lost) {
+bool LayerTreeHost::SetUIResourceEvictionCount(
+    uint64 ui_resource_eviction_count) {
+  if (ui_resource_eviction_count_recreated_ == ui_resource_eviction_count)
+    return false;
+
   for (UIResourceClientMap::iterator iter = ui_resource_client_map_.begin();
        iter != ui_resource_client_map_.end();
        ++iter) {
     UIResourceId uid = iter->first;
     UIResourceRequest request;
     request.type = UIResourceRequest::UIResourceCreate;
     request.id = uid;
+    bool resource_lost = true;
     request.bitmap = iter->second->GetBitmap(uid, resource_lost);
     DCHECK(request.bitmap.get());
     ui_resource_request_queue_.push_back(request);
   }
+  UIResourceRequest request;
+  request.type = UIResourceRequest::UIResourceEvictionRecreated;
+  request.eviction_count_recreated = ui_resource_eviction_count;
+  ui_resource_request_queue_.push_back(request);
+  ui_resource_eviction_count_recreated_ = ui_resource_eviction_count;
+
+  return true;
 }
 
 }  // namespace cc