cc: Resource list for headup display

cc/layers/heads_up_display_layer_impl.cc

 // Copyright 2012 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/layers/heads_up_display_layer_impl.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/debug/trace_event.h"
@@ skipping 63 matching lines @@
       paint_time_graph_(16.0, 48.0),
       fade_step_(0) {}
 
 HeadsUpDisplayLayerImpl::~HeadsUpDisplayLayerImpl() {}
 
 scoped_ptr<LayerImpl> HeadsUpDisplayLayerImpl::CreateLayerImpl(
     LayerTreeImpl* tree_impl) {
   return HeadsUpDisplayLayerImpl::Create(tree_impl, id()).PassAs<LayerImpl>();
 }
 
+void HeadsUpDisplayLayerImpl::AcquireResource(
+    ResourceProvider* resource_provider) {
+  for (ScopedPtrVector<ScopedResource>::iterator it = resources_.begin();
+       it != resources_.end();
+       ++it) {
+    if (!resource_provider->InUseByConsumer((*it)->id())) {
+      resources_.swap(it, resources_.end() - 1);
+      return;
+    }
+  }
+
+  scoped_ptr<ScopedResource> resource =
+      ScopedResource::Create(resource_provider);
+  resource->Allocate(
+      content_bounds(), ResourceProvider::TextureHintImmutable, RGBA_8888);
+  resources_.push_back(resource.Pass());
+}
+
+class ResourceSizeIsEqualTo {
+ public:
+  explicit ResourceSizeIsEqualTo(const gfx::Size& size_)
+      : compare_size_(size_) {}
+
+  bool operator()(const ScopedResource* resource) {
+    return resource->size() == compare_size_;
+  }
+
+ private:
+  const gfx::Size compare_size_;
+};
+
+void HeadsUpDisplayLayerImpl::ReleaseUnmatchedSizeResources(
+    ResourceProvider* resource_provider) {
+  ScopedPtrVector<ScopedResource>::iterator it_erase =
+      resources_.partition(ResourceSizeIsEqualTo(content_bounds()));
+  resources_.erase(it_erase, resources_.end());
+}
+
 bool HeadsUpDisplayLayerImpl::WillDraw(DrawMode draw_mode,
                                        ResourceProvider* resource_provider) {
   if (draw_mode == DRAW_MODE_RESOURCELESS_SOFTWARE)
     return false;
 
-  if (!hud_resource_)
-    hud_resource_ = ScopedResource::Create(resource_provider);
-
-  // TODO(danakj): The HUD could swap between two textures instead of creating a
-  // texture every frame in ubercompositor.
-  if (hud_resource_->size() != content_bounds() ||
-      (hud_resource_->id() &&
-       resource_provider->InUseByConsumer(hud_resource_->id()))) {
-    hud_resource_->Free();
-  }
-
-  if (!hud_resource_->id()) {
-    hud_resource_->Allocate(
-        content_bounds(), ResourceProvider::TextureHintImmutable, RGBA_8888);
-  }
-
+  ReleaseUnmatchedSizeResources(resource_provider);
+  AcquireResource(resource_provider);
   return LayerImpl::WillDraw(draw_mode, resource_provider);
 }
 
 void HeadsUpDisplayLayerImpl::AppendQuads(
     RenderPass* render_pass,
     const OcclusionTracker<LayerImpl>& occlusion_tracker,
     AppendQuadsData* append_quads_data) {
-  if (!hud_resource_->id())
+  if (!resources_.back()->id())
     return;
 
   SharedQuadState* shared_quad_state =
       render_pass->CreateAndAppendSharedQuadState();
   PopulateSharedQuadState(shared_quad_state);
 
   gfx::Rect quad_rect(content_bounds());
   gfx::Rect opaque_rect(contents_opaque() ? quad_rect : gfx::Rect());
   gfx::Rect visible_quad_rect(quad_rect);
   bool premultiplied_alpha = true;
   gfx::PointF uv_top_left(0.f, 0.f);
   gfx::PointF uv_bottom_right(1.f, 1.f);
   const float vertex_opacity[] = { 1.f, 1.f, 1.f, 1.f };
   bool flipped = false;
   TextureDrawQuad* quad =
       render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
   quad->SetNew(shared_quad_state,
                quad_rect,
                opaque_rect,
                visible_quad_rect,
-               hud_resource_->id(),
+               resources_.back()->id(),
                premultiplied_alpha,
                uv_top_left,
                uv_bottom_right,
                SK_ColorTRANSPARENT,
                vertex_opacity,
                flipped);
 }
 
 void HeadsUpDisplayLayerImpl::UpdateHudTexture(
     DrawMode draw_mode,
     ResourceProvider* resource_provider) {
-  if (draw_mode == DRAW_MODE_RESOURCELESS_SOFTWARE || !hud_resource_->id())
+  if (draw_mode == DRAW_MODE_RESOURCELESS_SOFTWARE || !resources_.back()->id())
     return;
 
   SkISize canvas_size;
   if (hud_canvas_)
     canvas_size = hud_canvas_->getDeviceSize();
   else
     canvas_size.set(0, 0);
 
   if (canvas_size.width() != content_bounds().width() ||
       canvas_size.height() != content_bounds().height() || !hud_canvas_) {
@@ skipping 16 matching lines @@
     hud_canvas_->restore();
   }
 
   TRACE_EVENT0("cc", "UploadHudTexture");
   SkImageInfo info;
   size_t row_bytes = 0;
   const void* pixels = hud_canvas_->peekPixels(&info, &row_bytes);
   DCHECK(pixels);
   gfx::Rect content_rect(content_bounds());
   DCHECK(info.colorType() == kN32_SkColorType);
-  resource_provider->SetPixels(hud_resource_->id(),
+  resource_provider->SetPixels(resources_.back()->id(),
                                static_cast<const uint8_t*>(pixels),
                                content_rect,
                                content_rect,
                                gfx::Vector2d());
 }
 
-void HeadsUpDisplayLayerImpl::ReleaseResources() { hud_resource_.reset(); }
+void HeadsUpDisplayLayerImpl::ReleaseResources() {
+  resources_.clear();
+}
 
 void HeadsUpDisplayLayerImpl::UpdateHudContents() {
   const LayerTreeDebugState& debug_state = layer_tree_impl()->debug_state();
 
   // Don't update numbers every frame so text is readable.
   base::TimeTicks now = layer_tree_impl()->CurrentBeginFrameArgs().frame_time;
   if (base::TimeDelta(now - time_of_last_graph_update_).InSecondsF() > 0.25f) {
     time_of_last_graph_update_ = now;
 
     if (debug_state.show_fps_counter) {
@@ skipping 562 matching lines @@
   return "cc::HeadsUpDisplayLayerImpl";
 }
 
 void HeadsUpDisplayLayerImpl::AsValueInto(
     base::debug::TracedValue* dict) const {
   LayerImpl::AsValueInto(dict);
   dict->SetString("layer_name", "Heads Up Display Layer");
 }
 
 }  // namespace cc