UI Resource Manager

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 60 matching lines @@
                                                               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)
-    : animating_(false),
+    : ui_resource_id_(1),
+      animating_(false),
       needs_full_tree_sync_(true),
       needs_filter_context_(false),
       client_(client),
       commit_number_(0),
       rendering_stats_instrumentation_(RenderingStatsInstrumentation::Create()),
       output_surface_can_be_initialized_(true),
       output_surface_lost_(true),
       num_failed_recreate_attempts_(0),
       settings_(settings),
       debug_state_(settings.initial_debug_state),
@@ skipping 255 matching lines @@
   if (pending_page_scale_animation_) {
     host_impl->StartPageScaleAnimation(
         pending_page_scale_animation_->target_offset,
         pending_page_scale_animation_->use_anchor,
         pending_page_scale_animation_->scale,
         base::TimeTicks::Now(),
         pending_page_scale_animation_->duration);
     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) {
     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;
 
+  // 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();
 }
 
 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 585 matching lines @@
 
 bool LayerTreeHost::RequestPartialTextureUpdate() {
   if (partial_texture_update_requests_ >= settings_.max_partial_texture_updates)
     return false;
 
   partial_texture_update_requests_++;
   return true;
 }
 
 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;
 
   SetNeedsCommit();
 }
 
 void LayerTreeHost::UpdateTopControlsState(TopControlsState constraints,
                                            TopControlsState current,
                                            bool animate) {
   if (!settings_.calculate_top_controls_position)
@@ skipping 35 matching lines @@
       animation_registrar_->active_animation_controllers();
   for (AnimationRegistrar::AnimationControllerMap::iterator iter = copy.begin();
        iter != copy.end();
        ++iter) {
     (*iter).second->Animate(monotonic_time);
     bool start_ready_animations = true;
     (*iter).second->UpdateState(start_ready_animations, NULL);
   }
 }
 
+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