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 254 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",
                  source_frame_number_);
     LayerTreeHostCommon::CalculateDrawProperties(
         root_layer(),
         layer_tree_host_impl_->DeviceViewport().size(),
         layer_tree_host_impl_->DeviceTransform(),
         device_scale_factor(),
         total_page_scale_factor(),
         root_scroll_layer_ ? root_scroll_layer_->parent() : NULL,
         MaxTextureSize(),
         settings().can_use_lcd_text,
         settings().layer_transforms_should_scale_layer_contents,
         &render_surface_layer_list_);
   }
 
   DCHECK(!needs_update_draw_properties_) <<
-      "CalcDrawProperties should not set_needs_update_draw_properties()";
+      "CalcdrawProperties should not set_needs_update_draw_properties()";
 }
 
 const LayerImplList& LayerTreeImpl::RenderSurfaceLayerList() const {
   // If this assert triggers, then the list is dirty.
   DCHECK(!needs_update_draw_properties_);
   return render_surface_layer_list_;
 }
 
 gfx::Size LayerTreeImpl::ScrollableSize() const {
   if (!root_scroll_layer_ || root_scroll_layer_->children().empty())
@@ skipping 198 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;
+    }
+  }
+}
+
 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());
 
   if (std::find(layers_with_copy_output_request_.begin(),
                 layers_with_copy_output_request_.end(),
                 layer) != layers_with_copy_output_request_.end())
     return;
   layers_with_copy_output_request_.push_back(layer);
@@ skipping 16 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