UI resource are evicted when LTH is set to 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 249 matching lines @@
   }
 
   client_->SendManagedMemoryStats();
 }
 
 bool LayerTreeHostImpl::CanDraw() const {
   // Note: If you are changing this function or any other function that might
   // affect the result of CanDraw, make sure to call
   // client_->OnCanDrawStateChanged in the proper places and update the
   // NotifyIfCanDrawChanged test.
 

[ccameron, 2013/08/26 23:54:32]

You probably need to make sure that this returns false after the UI resources
have been evicted.

   if (!renderer_) {
     TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::CanDraw no renderer",
                          TRACE_EVENT_SCOPE_THREAD);
     return false;
   }
 
   // Must have an OutputSurface if |renderer_| is not NULL.
   DCHECK(output_surface_);
 
   // TODO(boliu): Make draws without root_layer work and move this below
@@ skipping 1248 matching lines @@
 
 void LayerTreeHostImpl::SetVisible(bool visible) {
   DCHECK(proxy_->IsImplThread());
 
   if (visible_ == visible)
     return;
   visible_ = visible;
   DidVisibilityChange(this, visible_);
   EnforceManagedMemoryPolicy(ActualManagedMemoryPolicy());
 
-  // Evict tiles immediately if invisible since this tab may never get another
-  // draw or timer tick.
-  if (!visible_)
+  if (!visible_) {
+    // Evict tiles immediately if invisible since this tab may never get another
+    // draw or timer tick.
     ManageTiles();
 
+    // Evict UI resources
+    ReleaseUIResources();
+  }
+
   if (!renderer_)
     return;
 
   renderer_->SetVisible(visible);
 }
 
 ManagedMemoryPolicy LayerTreeHostImpl::ActualManagedMemoryPolicy() const {
   ManagedMemoryPolicy actual = cached_managed_memory_policy_;
   if (debug_state_.rasterize_only_visible_content) {
     actual.priority_cutoff_when_not_visible =
@@ skipping 15 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());
 
-  // Remove all existing maps from UIResourceId to ResourceId.
-  ui_resource_map_.clear();
+  ReleaseUIResources();
 }
 
 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 950 matching lines @@
 }
 
 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;
 }
 
+void LayerTreeHostImpl::ReleaseUIResources() {
+  for (UIResourceMap::const_iterator iter = ui_resource_map_.begin();
+      iter != ui_resource_map_.end();
+      ++iter) {
+    resource_provider_->DeleteResource(iter->second);
+  }
+  ui_resource_map_.clear();
+}
+
 }  // namespace cc