UI Resource Manager

cc/trees/layer_tree_host.cc

Index: cc/trees/layer_tree_host.cc
===================================================================
--- cc/trees/layer_tree_host.cc	(revision 213304)
+++ cc/trees/layer_tree_host.cc	(working copy)
@@ -78,7 +78,8 @@
 
 LayerTreeHost::LayerTreeHost(LayerTreeHostClient* client,
                              const LayerTreeSettings& settings)
-    : animating_(false),
+    : ui_resource_id_(1),
+      animating_(false),
       needs_full_tree_sync_(true),
       needs_filter_context_(false),
       client_(client),
@@ -354,6 +355,15 @@
     pending_page_scale_animation_.reset();
   }
 
+  if (!ui_resource_request_queue_.empty()) {
+    sync_tree->set_ui_resource_request_queue(ui_resource_request_queue_);
+    ui_resource_request_queue_.clear();
+    // Process any ui resource requests in the queue.  For impl-side-painting,
+    // the queue is processed in LayerTreeHostImpl::ActivatePendingTree.
+    if (!settings_.impl_side_painting)
+      sync_tree->ProcessUIResourceRequestQueue();
+  }
+
   DCHECK(!sync_tree->ViewportSizeInvalid());
 
   if (new_impl_tree_has_no_evicted_resources) {
@@ -419,6 +429,17 @@
   if (output_surface_lost_)
     return;
 
+  // Remove all pending UI resource requests because there might be deletion

[aelias_OOO_until_Jul13, 2013/07/24 02:57:46]

We need to honor both creation and deletion requests.  Creation requests
represent new resources that are probably going to be used soon.  Deletion
requests mean it's no longer safe to call the creation callback.

Please fix this and add some unit tests making sure LayerTreeHost does the right
thing when there are already pending requests during context loss.

[powei, 2013/07/25 20:48:45]

Done.  And added tests in layer_tree_host_unittest_context.cc

+  // requests, which can no longer be honored (or already gone anyways).
+  ui_resource_request_queue_.clear();
+
+  // 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);
+  }
+
   num_failed_recreate_attempts_ = 0;
   output_surface_lost_ = true;
   SetNeedsCommit();
@@ -1024,7 +1045,7 @@
 }
 
 void LayerTreeHost::SetDeviceScaleFactor(float device_scale_factor) {
-  if (device_scale_factor ==  device_scale_factor_)
+  if (device_scale_factor == device_scale_factor_)
     return;
   device_scale_factor_ = device_scale_factor;
 
@@ -1080,4 +1101,44 @@
   }
 }
 
+UIResourceId LayerTreeHost::CreateUIResource(
+    const UIResourceCallback& bitmap_cb) {
+  UIResourceRequest request;
+  bool resource_lost = false;
+  request.type = UIResourceCreate;
+  request.id = ui_resource_id_++;
+
+  DCHECK(ui_resource_client_map_.find(request.id) ==
+         ui_resource_client_map_.end());
+
+  request.bitmap = bitmap_cb.Run(resource_lost);
+  ui_resource_request_queue_.push_back(request);
+  ui_resource_client_map_[request.id] = bitmap_cb;
+  return request.id;
+}
+
+// Deletes a UI resource.  May safely be called more than once.
+void LayerTreeHost::DeleteUIResource(UIResourceId uid) {
+  UIResourceClientMap::iterator iter = ui_resource_client_map_.find(uid);
+  if (iter != ui_resource_client_map_.end()) {
+    UIResourceRequest request;
+    request.type = 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()) {
+    UIResourceRequest request;
+    bool resource_lost = true;
+    request.type = UIResourceCreate;
+    request.id = uid;
+    request.bitmap = iter->second.Run(resource_lost);
+    ui_resource_request_queue_.push_back(request);
+  }
+}
+
 }  // namespace cc