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 31 matching lines @@
 #include "cc/resources/prioritized_resource_manager.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 "gpu/GLES2/gl2extchromium.h"
 #include "ui/gfx/size_conversions.h"
 #include "ui/gfx/vector2d_conversions.h"
 
 namespace {
 
 void DidVisibilityChange(cc::LayerTreeHostImpl* id, bool visible) {
   if (visible) {
     TRACE_EVENT_ASYNC_BEGIN1("webkit",
                              "LayerTreeHostImpl::SetVisible",
                              id,
@@ skipping 495 matching lines @@
   bool root_surface_has_no_visible_damage =
       !root_surface->damage_tracker()->current_damage_rect().Intersects(
           root_surface->content_rect());
   bool root_surface_has_contributing_layers =
       !root_surface->layer_list().empty();
   if (root_surface_has_contributing_layers &&
       root_surface_has_no_visible_damage) {
     TRACE_EVENT0("cc",
                  "LayerTreeHostImpl::CalculateRenderPasses::EmptyDamageRect");
     frame->has_no_damage = true;
+
     // A copy request should cause damage, so we should not have any copy
     // requests in this case.
     DCHECK_EQ(0u, active_tree_->LayersWithCopyOutputRequest().size());
     return true;
   }
 
   TRACE_EVENT1("cc",
                "LayerTreeHostImpl::CalculateRenderPasses",
                "render_surface_layer_list.size()",
                static_cast<uint64>(frame->render_surface_layer_list->size()));
@@ skipping 1778 matching lines @@
   return layer ? layer->GetPicture() : skia::RefPtr<SkPicture>();
 }
 
 void LayerTreeHostImpl::SetDebugState(const LayerTreeDebugState& debug_state) {
   if (debug_state_.continuous_painting != debug_state.continuous_painting)
     paint_time_counter_->ClearHistory();
 
   debug_state_ = debug_state;
 }
 
+void LayerTreeHostImpl::CreateUIResource(UIResourceId uid,
+                                         scoped_refptr<UIResourceBitmap> bitmap,
+                                         bool async) {
+  ResourceProvider::ResourceId id =
+    resource_provider_->CreateGLTexture(bitmap->GetSize(),
+                                        GL_RGBA,
+                                        GL_TEXTURE_POOL_UNMANAGED_CHROMIUM,
+                                        ResourceProvider::TextureUsageAny);
+
+  ui_resource_map_[uid] = id;
+  gfx::Size bitmap_size = bitmap->GetSize();
+  resource_provider_->SetPixels(id,
+                                reinterpret_cast<uint8_t*>(bitmap->GetPixels()),
+                                gfx::Rect(1, 1, bitmap_size.width(),
+                                          bitmap_size.height()),
+                                gfx::Rect(1, 1, bitmap_size.width(),
+                                          bitmap_size.height()),
+                                gfx::Vector2d(0, 0));
+
+  client_->UIResourceCreatedOnImplThread(uid);
+}
+
+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 {
+  if (ui_resource_map_.find(uid) != ui_resource_map_.end()) {
+    return ui_resource_map_.find(uid)->second;
+  }
+  return 0;
+}
+
+
 }  // namespace cc