Upstream version 10.39.225.0

[platform/framework/web/crosswalk.git] / src / cc / layers / heads_up_display_layer_impl.cc

diff --git a/src/cc/layers/heads_up_display_layer_impl.cc b/src/cc/layers/heads_up_display_layer_impl.cc
index 0ccd4ed..51c0ed2 100644 (file)
--- a/src/cc/layers/heads_up_display_layer_impl.cc
+++ b/src/cc/layers/heads_up_display_layer_impl.cc
@@ -13,6 +13,7 @@
 #include "cc/debug/debug_colors.h"
 #include "cc/debug/frame_rate_counter.h"
 #include "cc/debug/paint_time_counter.h"
+#include "cc/output/begin_frame_args.h"
 #include "cc/output/renderer.h"
 #include "cc/quads/texture_draw_quad.h"
 #include "cc/resources/memory_history.h"
@@ -80,28 +81,51 @@ scoped_ptr<LayerImpl> HeadsUpDisplayLayerImpl::CreateLayerImpl(
   return HeadsUpDisplayLayerImpl::Create(tree_impl, id()).PassAs<LayerImpl>();
 }
 
-bool HeadsUpDisplayLayerImpl::WillDraw(DrawMode draw_mode,
-                                       ResourceProvider* resource_provider) {
-  if (draw_mode == DRAW_MODE_RESOURCELESS_SOFTWARE)
-    return false;
+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;
+    }
+  }
 
-  if (!hud_resource_)
-    hud_resource_ = ScopedResource::Create(resource_provider);
+  scoped_ptr<ScopedResource> resource =
+      ScopedResource::Create(resource_provider);
+  resource->Allocate(
+      content_bounds(), ResourceProvider::TextureHintImmutable, RGBA_8888);
+  resources_.push_back(resource.Pass());
+}
 
-  // 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();
-  }
+class ResourceSizeIsEqualTo {
+ public:
+  explicit ResourceSizeIsEqualTo(const gfx::Size& size_)
+      : compare_size_(size_) {}
 
-  if (!hud_resource_->id()) {
-    hud_resource_->Allocate(content_bounds(),
-                            ResourceProvider::TextureUsageAny,
-                            RGBA_8888);
+  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;
+
+  ReleaseUnmatchedSizeResources(resource_provider);
+  AcquireResource(resource_provider);
   return LayerImpl::WillDraw(draw_mode, resource_provider);
 }
 
@@ -109,7 +133,7 @@ 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 =
@@ -130,7 +154,7 @@ void HeadsUpDisplayLayerImpl::AppendQuads(
                quad_rect,
                opaque_rect,
                visible_quad_rect,
-               hud_resource_->id(),
+               resources_.back()->id(),
                premultiplied_alpha,
                uv_top_left,
                uv_bottom_right,
@@ -142,7 +166,7 @@ void HeadsUpDisplayLayerImpl::AppendQuads(
 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;
@@ -179,20 +203,22 @@ void HeadsUpDisplayLayerImpl::UpdateHudTexture(
   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()->CurrentFrameTimeTicks();
+  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;