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 11 matching lines @@
 #include "cc/debug/overdraw_metrics.h"
 #include "cc/debug/rendering_stats_instrumentation.h"
 #include "cc/input/top_controls_manager.h"
 #include "cc/layers/heads_up_display_layer.h"
 #include "cc/layers/heads_up_display_layer_impl.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_iterator.h"
 #include "cc/layers/render_surface.h"
 #include "cc/layers/scrollbar_layer.h"
 #include "cc/resources/prioritized_resource_manager.h"
+#include "cc/resources/ui_resource_client.h"
 #include "cc/trees/layer_tree_host_client.h"
 #include "cc/trees/layer_tree_host_common.h"
 #include "cc/trees/layer_tree_host_impl.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/occlusion_tracker.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "cc/trees/thread_proxy.h"
 #include "cc/trees/tree_synchronizer.h"
 #include "ui/gfx/size_conversions.h"
 
@@ skipping 10 matching lines @@
       using_egl_image(false),
       allow_partial_texture_updates(false),
       using_offscreen_context3d(false),
       max_texture_size(0),
       avoid_pow2_textures(false),
       using_map_image(false),
       using_shared_memory_resources(false) {}
 
 RendererCapabilities::~RendererCapabilities() {}
 
+UIResourceRequest::UIResourceRequest()
+    : type(UIResourceInvalidRequest), id(0), bitmap(NULL) {}
+
+UIResourceRequest::~UIResourceRequest() {}
+
 bool LayerTreeHost::AnyLayerTreeHostInstanceExists() {
   return s_num_layer_tree_instances > 0;
 }
 
 scoped_ptr<LayerTreeHost> LayerTreeHost::Create(
     LayerTreeHostClient* client,
     const LayerTreeSettings& settings,
     scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner) {
   scoped_ptr<LayerTreeHost> layer_tree_host(new LayerTreeHost(client,
                                                               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),
+    : next_ui_resource_id_(1),
+      animating_(false),
       needs_full_tree_sync_(true),
       needs_filter_context_(false),
       client_(client),
       source_frame_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;
 
+  DidLoseUIResources();
+
   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 607 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(UIResourceClient* client) {
+  DCHECK(client);
+
+  UIResourceRequest request;
+  bool resource_lost = false;
+  request.type = UIResourceCreate;
+  request.id = next_ui_resource_id_++;
+
+  DCHECK(ui_resource_client_map_.find(request.id) ==
+         ui_resource_client_map_.end());
+
+  request.bitmap = client->GetBitmap(request.id, resource_lost);
+  ui_resource_request_queue_.push_back(request);
+  ui_resource_client_map_[request.id] = client;
+  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()) {

[enne (OOO), 2013/07/31 22:02:40]

style nit: make this an early return rather than a large conditional block? (and
same below?)

[powei, 2013/08/01 00:05:10]

Done.

+    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->GetBitmap(uid, resource_lost);
+    DCHECK(request.bitmap.get());
+    ui_resource_request_queue_.push_back(request);
+  }
+}
+
+void LayerTreeHost::DidLoseUIResources() {
+  typedef base::hash_set<UIResourceId> UIResourceIdSet;
+  UIResourceIdSet request_set;

[aelias_OOO_until_Jul13, 2013/07/31 21:00:30]

Is this needed anymore?  For simplicity, can we just call UIResourceLost on all
resources in the map?

[powei, 2013/07/31 21:29:39]

If a user has created a resource, but the context was lost before the creation
can be carried out on the impl-side, should we honor the original request or
make a new resource-lost request?  I don't know the use-cases well-enough to say
one way or another.  What are your thoughts?

[aelias_OOO_until_Jul13, 2013/07/31 21:56:51]

It doesn't matter much as long as we don't crash, leak, or incorrectly delete a
resource.  I think we should optimize to make the code simpler.

[powei, 2013/08/01 00:05:10]

Done.

+
+  for (UIResourceRequestQueue::iterator iter =
+           ui_resource_request_queue_.begin();
+       iter != ui_resource_request_queue_.end();
+       ++iter) {
+    request_set.insert(iter->id);
+  }
+
+  // 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) {
+    // If the resource was to be created/deleted, then the original request will
+    // be honored instead of treating it as resource lost.
+    if (request_set.find(iter->first) == request_set.end())
+      UIResourceLost(iter->first);
+  }
+}
+
 }  // namespace cc