UI Resource Manager

cc/trees/layer_tree_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_impl.h"
 
 #include "base/debug/trace_event.h"
 #include "cc/animation/keyframed_animation_curve.h"
 #include "cc/animation/scrollbar_animation_controller.h"
 #include "cc/debug/traced_value.h"
@@ skipping 273 matching lines @@
       IsActiveTree() &&
       RootScrollLayer()) {
     UpdateSolidColorScrollbars();
   }
 
   needs_update_draw_properties_ = false;
   render_surface_layer_list_.clear();
 
   // For max_texture_size.
   if (!layer_tree_host_impl_->renderer())
-      return;
+    return;
 
   if (!root_layer())
     return;
 
   {
     TRACE_EVENT2("cc",
                  "LayerTreeImpl::UpdateDrawProperties",
                  "IsActive",
                  IsActiveTree(),
                  "SourceFrameNumber",
@@ skipping 226 matching lines @@
       continue;
     render_surface_layer_list->Append(TracedValue::CreateIDRef(*it).release());
   }
 
   state->Set("render_surface_layer_list",
              render_surface_layer_list.release());
   return state.PassAs<base::Value>();
 }
 
 void LayerTreeImpl::SetRootLayerScrollOffsetDelegate(
-      LayerScrollOffsetDelegate* root_layer_scroll_offset_delegate) {
+    LayerScrollOffsetDelegate* root_layer_scroll_offset_delegate) {
   root_layer_scroll_offset_delegate_ = root_layer_scroll_offset_delegate;
   if (root_scroll_layer_) {
     root_scroll_layer_->SetScrollOffsetDelegate(
         root_layer_scroll_offset_delegate_);
   }
 }
 
 void LayerTreeImpl::UpdateRootScrollLayerSizeDelta() {
   LayerImpl* root_scroll = RootScrollLayer();
   LayerImpl* root_container = RootContainerLayer();
@@ skipping 22 matching lines @@
 }
 
 void LayerTreeImpl::ClearLatencyInfo() {
   latency_info_.Clear();
 }
 
 void LayerTreeImpl::WillModifyTilePriorities() {
   layer_tree_host_impl_->SetNeedsManageTiles();
 }
 
+void LayerTreeImpl::set_ui_resource_request_queue(
+    const UIResourceRequestQueue& queue) {
+  ui_resource_request_queue_ = queue;
+}
+
+ResourceProvider::ResourceId LayerTreeImpl::ResourceIdForUIResource(
+    UIResourceId uid) const {
+  return layer_tree_host_impl_->ResourceIdForUIResource(uid);
+}
+
+void LayerTreeImpl::ProcessUIResourceRequestQueue() {
+  while (ui_resource_request_queue_.size() > 0) {
+    UIResourceRequest req = ui_resource_request_queue_.front();
+    ui_resource_request_queue_.pop_front();
+
+    switch (req.type) {
+      case UIResourceCreate:
+        layer_tree_host_impl_->CreateUIResource(req.id, req.bitmap);
+        break;
+      case UIResourceDelete:
+        layer_tree_host_impl_->DeleteUIResource(req.id);
+        break;
+      default:
+        NOTREACHED();
+        break;
+    }
+  }
+}
+
 void LayerTreeImpl::AddLayerWithCopyOutputRequest(LayerImpl* layer) {
   // Only the active tree needs to know about layers with copy requests, as
   // they are aborted if not serviced during draw.
   DCHECK(IsActiveTree());
 
   DCHECK(std::find(layers_with_copy_output_request_.begin(),
                    layers_with_copy_output_request_.end(),
                    layer) == layers_with_copy_output_request_.end());
   layers_with_copy_output_request_.push_back(layer);
 }
@@ skipping 14 matching lines @@
 const std::vector<LayerImpl*> LayerTreeImpl::LayersWithCopyOutputRequest()
     const {
   // Only the active tree needs to know about layers with copy requests, as
   // they are aborted if not serviced during draw.
   DCHECK(IsActiveTree());
 
   return layers_with_copy_output_request_;
 }
 
 }  // namespace cc