Upstream version 7.36.149.0

[platform/framework/web/crosswalk.git] / src / cc / output / delegating_renderer.cc

diff --git a/src/cc/output/delegating_renderer.cc b/src/cc/output/delegating_renderer.cc
index e2d3145..90ff409 100644 (file)
--- a/src/cc/output/delegating_renderer.cc
+++ b/src/cc/output/delegating_renderer.cc
@@ -35,11 +35,8 @@ scoped_ptr<DelegatingRenderer> DelegatingRenderer::Create(
     const LayerTreeSettings* settings,
     OutputSurface* output_surface,
     ResourceProvider* resource_provider) {
-  scoped_ptr<DelegatingRenderer> renderer(new DelegatingRenderer(
+  return make_scoped_ptr(new DelegatingRenderer(
       client, settings, output_surface, resource_provider));
-  if (!renderer->Initialize())
-    return scoped_ptr<DelegatingRenderer>();
-  return renderer.Pass();
 }
 
 DelegatingRenderer::DelegatingRenderer(RendererClient* client,
@@ -48,36 +45,28 @@ DelegatingRenderer::DelegatingRenderer(RendererClient* client,
                                        ResourceProvider* resource_provider)
     : Renderer(client, settings),
       output_surface_(output_surface),
-      resource_provider_(resource_provider),
-      visible_(true) {
+      resource_provider_(resource_provider) {
   DCHECK(resource_provider_);
-}
 
-bool DelegatingRenderer::Initialize() {
   capabilities_.using_partial_swap = false;
   capabilities_.max_texture_size = resource_provider_->max_texture_size();
   capabilities_.best_texture_format = resource_provider_->best_texture_format();
   capabilities_.allow_partial_texture_updates = false;
-  capabilities_.using_offscreen_context3d = false;
 
   if (!output_surface_->context_provider()) {
     capabilities_.using_shared_memory_resources = true;
-    capabilities_.using_map_image = settings_->use_map_image;
-    return true;
-  }
-
-  const ContextProvider::Capabilities& caps =
-      output_surface_->context_provider()->ContextCapabilities();
-
-  DCHECK(!caps.gpu.iosurface || caps.gpu.texture_rectangle);
+    capabilities_.using_map_image = true;
+  } else {
+    const ContextProvider::Capabilities& caps =
+        output_surface_->context_provider()->ContextCapabilities();
 
-  capabilities_.using_egl_image = caps.gpu.egl_image_external;
-  capabilities_.using_map_image =
-      settings_->use_map_image && caps.gpu.map_image;
+    DCHECK(!caps.gpu.iosurface || caps.gpu.texture_rectangle);
 
-  capabilities_.allow_rasterize_on_demand = false;
+    capabilities_.using_egl_image = caps.gpu.egl_image_external;
+    capabilities_.using_map_image = caps.gpu.map_image;
 
-  return true;
+    capabilities_.allow_rasterize_on_demand = false;
+  }
 }
 
 DelegatingRenderer::~DelegatingRenderer() {}
@@ -96,7 +85,6 @@ static ResourceProvider::ResourceId AppendToArray(
 }
 
 void DelegatingRenderer::DrawFrame(RenderPassList* render_passes_in_draw_order,
-                                   ContextProvider* offscreen_context_provider,
                                    float device_scale_factor,
                                    const gfx::Rect& device_viewport_rect,
                                    const gfx::Rect& device_clip_rect,
@@ -147,23 +135,21 @@ bool DelegatingRenderer::IsContextLost() {
   return context_provider->IsContextLost();
 }
 
-void DelegatingRenderer::SetVisible(bool visible) {
-  if (visible == visible_)
-    return;
-
-  visible_ = visible;
+void DelegatingRenderer::DidChangeVisibility() {
   ContextProvider* context_provider = output_surface_->context_provider();
-  if (!visible_) {
+  if (!visible()) {
     TRACE_EVENT0("cc", "DelegatingRenderer::SetVisible dropping resources");
     resource_provider_->ReleaseCachedData();
-    if (context_provider)
+    if (context_provider) {
+      context_provider->DeleteCachedResources();
       context_provider->ContextGL()->Flush();
+    }
   }
   // We loop visibility to the GPU process, since that's what manages memory.
   // That will allow it to feed us with memory allocations that we can act
   // upon.
   if (context_provider)
-    context_provider->ContextSupport()->SetSurfaceVisible(visible);
+    context_provider->ContextSupport()->SetSurfaceVisible(visible());
 }
 
 void DelegatingRenderer::SendManagedMemoryStats(size_t bytes_visible,