UI Resource Manager

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/json/json_writer.h"
@@ skipping 22 matching lines @@
 #include "cc/output/copy_output_request.h"
 #include "cc/output/delegating_renderer.h"
 #include "cc/output/gl_renderer.h"
 #include "cc/output/software_renderer.h"
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/shared_quad_state.h"
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/resources/memory_history.h"
 #include "cc/resources/picture_layer_tiling.h"
 #include "cc/resources/prioritized_resource_manager.h"
+#include "cc/resources/ui_resource_bitmap.h"
 #include "cc/scheduler/delay_based_time_source.h"
 #include "cc/scheduler/texture_uploader.h"
 #include "cc/trees/damage_tracker.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_host_common.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/quad_culler.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "cc/trees/tree_synchronizer.h"
 #include "ui/gfx/size_conversions.h"
@@ skipping 1397 matching lines @@
   if (pending_tree_->needs_full_tree_sync()) {
     active_tree_->SetRootLayer(
         TreeSynchronizer::SynchronizeTrees(pending_tree_->root_layer(),
                                            active_tree_->DetachLayerTree(),
                                            active_tree_.get()));
   }
   TreeSynchronizer::PushProperties(pending_tree_->root_layer(),
                                    active_tree_->root_layer());
   DCHECK(!recycle_tree_);
 
+  // Active tree should have no requests in its queue.
+  DCHECK_EQ(active_tree_->ui_resource_request_queue_size(), 0u);

[enne (OOO), 2013/08/01 00:26:56]

Ah, I meant to check this in LayerTreeImpl::PushPropertiesTo, as documentation
that this property doesn't need to be pushed, so that somebody else looking at
this later will know that it's expected.

[powei, 2013/08/01 03:27:03]

Done.

+  // Process any requests in the UI resource queue.  The request queue is given
+  // in LayerTreeHost::FinishCommitOnImplThread.  This must take place before
+  // the swap.
+  pending_tree_->ProcessUIResourceRequestQueue();
+  // No more requests left in the queue.
+  DCHECK_EQ(pending_tree_->ui_resource_request_queue_size(), 0u);
+
   pending_tree_->PushPropertiesTo(active_tree_.get());
 
   // Now that we've synced everything from the pending tree to the active
   // tree, rename the pending tree the recycle tree so we can reuse it on the
   // next sync.
   pending_tree_.swap(recycle_tree_);
 
   active_tree_->SetRootLayerScrollOffsetDelegate(
       root_layer_scroll_offset_delegate_);
   active_tree_->DidBecomeActive();
@@ skipping 47 matching lines @@
   return actual;
 }
 
 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();
 }
 
 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 905 matching lines @@
     const LayerTreeDebugState& new_debug_state) {
   if (LayerTreeDebugState::Equal(debug_state_, new_debug_state))
     return;
   if (debug_state_.continuous_painting != new_debug_state.continuous_painting)
     paint_time_counter_->ClearHistory();
 
   debug_state_ = new_debug_state;
   SetFullRootLayerDamage();
 }
 
+void LayerTreeHostImpl::CreateUIResource(
+    UIResourceId uid,
+    scoped_refptr<UIResourceBitmap> bitmap) {
+  DCHECK_GT(uid, 0);
+  DCHECK_EQ(bitmap->GetFormat(), UIResourceBitmap::RGBA8);
+
+  // Allow for multiple creation requests with the same UIResourceId.  The
+  // previous resource is simply deleted.
+  ResourceProvider::ResourceId id = ResourceIdForUIResource(uid);
+  if (id)
+    DeleteUIResource(uid);
+  id = resource_provider_->CreateResource(
+      bitmap->GetSize(), GL_RGBA, ResourceProvider::TextureUsageAny);
+
+  ui_resource_map_[uid] = id;
+  resource_provider_->SetPixels(id,
+                                reinterpret_cast<uint8_t*>(bitmap->GetPixels()),
+                                gfx::Rect(bitmap->GetSize()),
+                                gfx::Rect(bitmap->GetSize()),
+                                gfx::Vector2d(0, 0));
+}
+
+void LayerTreeHostImpl::DeleteUIResource(UIResourceId uid) {
+  ResourceProvider::ResourceId id = ResourceIdForUIResource(uid);
+  if (id) {
+    resource_provider_->DeleteResource(id);
+    ui_resource_map_.erase(uid);
+  }
+}
+
+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;
+}
+
 }  // namespace cc