[cc] Evict UIResources when the renderer is not visible

cc/trees/layer_tree_host_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_host_impl.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/containers/hash_tables.h"
@@ skipping 293 matching lines @@
         "cc", "LayerTreeHostImpl::CanDraw viewport size recently changed",
         TRACE_EVENT_SCOPE_THREAD);
     return false;
   }
   if (active_tree_->ContentsTexturesPurged()) {
     TRACE_EVENT_INSTANT0(
         "cc", "LayerTreeHostImpl::CanDraw contents textures purged",
         TRACE_EVENT_SCOPE_THREAD);
     return false;
   }
+  if (EvictedUIResourcesExist()) {
+    TRACE_EVENT_INSTANT0(
+        "cc", "LayerTreeHostImpl::CanDraw UI resources evicted not recreated",
+        TRACE_EVENT_SCOPE_THREAD);
+    return false;
+  }
   return true;
 }
 
 void LayerTreeHostImpl::Animate(base::TimeTicks monotonic_time,
                                 base::Time wall_clock_time) {
   if (input_handler_client_)
     input_handler_client_->Animate(monotonic_time);
   AnimatePageScale(monotonic_time);
   AnimateLayers(monotonic_time, wall_clock_time);
   AnimateScrollbars(monotonic_time);
@@ skipping 1227 matching lines @@
 
 void LayerTreeHostImpl::SetVisible(bool visible) {
   DCHECK(proxy_->IsImplThread());
 
   if (visible_ == visible)
     return;
   visible_ = visible;
   DidVisibilityChange(this, visible_);
   EnforceManagedMemoryPolicy(ActualManagedMemoryPolicy());
 
+  if (!visible_)
+    EvictAllUIResources();
+
   // Evict tiles immediately if invisible since this tab may never get another
   // draw or timer tick.
   if (!visible_)
     ManageTiles();
 
   if (!renderer_)
     return;
 
   renderer_->SetVisible(visible);
 }
@@ skipping 20 matching lines @@
 }
 
 void LayerTreeHostImpl::ReleaseTreeResources() {
   if (active_tree_->root_layer())
     SendReleaseResourcesRecursive(active_tree_->root_layer());
   if (pending_tree_ && pending_tree_->root_layer())
     SendReleaseResourcesRecursive(pending_tree_->root_layer());
   if (recycle_tree_ && recycle_tree_->root_layer())
     SendReleaseResourcesRecursive(recycle_tree_->root_layer());
 
-  DeleteAllUIResources();
+  EvictAllUIResources();
 }
 
 void LayerTreeHostImpl::CreateAndSetRenderer(
     OutputSurface* output_surface,
     ResourceProvider* resource_provider,
     bool skip_gl_renderer) {
   DCHECK(!renderer_);
   if (output_surface->capabilities().delegated_rendering) {
     renderer_ =
         DelegatingRenderer::Create(this, output_surface, resource_provider);
@@ skipping 1009 matching lines @@
       resource_provider_->best_texture_format(),
       wrap_mode,
       ResourceProvider::TextureUsageAny);
 
   ui_resource_map_[uid] = id;
   resource_provider_->SetPixels(id,
                                 reinterpret_cast<uint8_t*>(bitmap->GetPixels()),
                                 gfx::Rect(bitmap->GetSize()),
                                 gfx::Rect(bitmap->GetSize()),
                                 gfx::Vector2d(0, 0));
+  MarkUIResourceNotEvicted(uid);
 }
 
 void LayerTreeHostImpl::DeleteUIResource(UIResourceId uid) {
   ResourceProvider::ResourceId id = ResourceIdForUIResource(uid);
   if (id) {
     resource_provider_->DeleteResource(id);
     ui_resource_map_.erase(uid);
   }
+  MarkUIResourceNotEvicted(uid);
 }
 
-void LayerTreeHostImpl::DeleteAllUIResources() {
+void LayerTreeHostImpl::EvictAllUIResources() {
+  if (ui_resource_map_.empty())
+    return;
+
   for (UIResourceMap::const_iterator iter = ui_resource_map_.begin();
       iter != ui_resource_map_.end();
       ++iter) {
+    evicted_ui_resources_.insert(iter->first);
     resource_provider_->DeleteResource(iter->second);
   }
   ui_resource_map_.clear();
+
+  client_->SetNeedsCommitOnImplThread();
+  client_->OnCanDrawStateChanged(CanDraw());
+  client_->RenewTreePriority();
 }
 
 ResourceProvider::ResourceId LayerTreeHostImpl::ResourceIdForUIResource(
     UIResourceId uid) const {
   UIResourceMap::const_iterator iter = ui_resource_map_.find(uid);
   if (iter != ui_resource_map_.end())
     return iter->second;
   return 0;
 }
 
+bool LayerTreeHostImpl::EvictedUIResourcesExist() const {
+  return !evicted_ui_resources_.empty();
+}
+
+void LayerTreeHostImpl::MarkUIResourceNotEvicted(UIResourceId uid) {
+  std::set<UIResourceId>::iterator found_in_evicted =
+      evicted_ui_resources_.find(uid);
+  if (found_in_evicted == evicted_ui_resources_.end())
+    return;
+  evicted_ui_resources_.erase(found_in_evicted);
+  if (evicted_ui_resources_.empty())
+    client_->OnCanDrawStateChanged(CanDraw());
+}
+
 }  // namespace cc