UI resource are evicted when LTH is set to 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 417 matching lines @@
   return host_impl.Pass();
 }
 
 void LayerTreeHost::DidLoseOutputSurface() {
   TRACE_EVENT0("cc", "LayerTreeHost::DidLoseOutputSurface");
   DCHECK(proxy_->IsMainThread());
 
   if (output_surface_lost_)
     return;
 
-  DidLoseUIResources();
+  bool resource_lost = true;

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

I haven't seen this way for naming a parameter before -- someone closer to cc/
should comment on if this is okay. Might want to use an enum.

[danakj, 2013/08/27 00:30:03]

This is generally how we pass bool literals, ie we don't pass "true/false"
directly to a function without a name unless it's super obvious what it means.
An enum could work too, but maybe overkill IMO.

+  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);
@@ skipping 170 matching lines @@
   page_scale_factor_ = page_scale_factor;
   min_page_scale_factor_ = min_page_scale_factor;
   max_page_scale_factor_ = max_page_scale_factor;
   SetNeedsCommit();
 }
 
 void LayerTreeHost::SetVisible(bool visible) {
   if (visible_ == visible)
     return;
   visible_ = visible;
-  if (!visible)
+  if (!visible) {
     ReduceMemoryUsage();
+  } else {
+    // Recreate the UI resources since they were evicted when SetVisible(false).
+    bool resource_lost = false;
+    RecreateUIResources(resource_lost);
+  }
   proxy_->SetVisible(visible);
 }
 
 void LayerTreeHost::SetLatencyInfo(const ui::LatencyInfo& latency_info) {
   latency_info_.MergeWith(latency_info);
 }
 
 void LayerTreeHost::StartPageScaleAnimation(gfx::Vector2d target_offset,
                                             bool use_anchor,
                                             float scale,
@@ skipping 507 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::UIResourceLost(UIResourceId uid) {
-  UIResourceClientMap::iterator iter = ui_resource_client_map_.find(uid);
-  if (iter == ui_resource_client_map_.end())
-    return;
-
-  UIResourceRequest request;
-  bool resource_lost = true;
-  request.type = UIResourceRequest::UIResourceCreate;
-  request.id = uid;
-  request.bitmap = iter->second->GetBitmap(uid, resource_lost);
-  DCHECK(request.bitmap.get());
-  ui_resource_request_queue_.push_back(request);
-}
-
-void LayerTreeHost::DidLoseUIResources() {
+void LayerTreeHost::RecreateUIResources(bool resource_lost) {
   // When output surface is lost, we need to recreate the resource.
   for (UIResourceClientMap::iterator iter = ui_resource_client_map_.begin();
        iter != ui_resource_client_map_.end();
        ++iter) {
-    UIResourceLost(iter->first);
+    UIResourceId uid = iter->first;
+    UIResourceRequest request;
+    request.type = UIResourceRequest::UIResourceCreate;
+    request.id = uid;
+    request.bitmap = iter->second->GetBitmap(uid, resource_lost);
+    DCHECK(request.bitmap.get());
+    ui_resource_request_queue_.push_back(request);
   }
 }
 
 }  // namespace cc