Upstream version 7.36.149.0

[platform/framework/web/crosswalk.git] / src / cc / trees / single_thread_proxy.cc

diff --git a/src/cc/trees/single_thread_proxy.cc b/src/cc/trees/single_thread_proxy.cc
index 5ccef20..a920f5a 100644 (file)
--- a/src/cc/trees/single_thread_proxy.cc
+++ b/src/cc/trees/single_thread_proxy.cc
@@ -32,7 +32,6 @@ SingleThreadProxy::SingleThreadProxy(LayerTreeHost* layer_tree_host,
     : Proxy(NULL),
       layer_tree_host_(layer_tree_host),
       client_(client),
-      created_offscreen_context_provider_(false),
       next_frame_is_newly_committed_frame_(false),
       inside_draw_(false) {
   TRACE_EVENT0("cc", "SingleThreadProxy::SingleThreadProxy");
@@ -117,52 +116,21 @@ void SingleThreadProxy::CreateAndInitializeOutputSurface() {
 
   scoped_ptr<OutputSurface> output_surface =
       layer_tree_host_->CreateOutputSurface();
-  if (!output_surface) {
-    OnOutputSurfaceInitializeAttempted(false);
-    return;
-  }
 
-  scoped_refptr<ContextProvider> offscreen_context_provider;
-  if (created_offscreen_context_provider_) {
-    offscreen_context_provider =
-        layer_tree_host_->client()->OffscreenContextProvider();
-    if (!offscreen_context_provider.get() ||
-        !offscreen_context_provider->BindToCurrentThread()) {
-      OnOutputSurfaceInitializeAttempted(false);
-      return;
-    }
-  }
+  renderer_capabilities_for_main_thread_ = RendererCapabilities();
 
-  {
+  bool success = !!output_surface;
+  if (success) {
     DebugScopedSetMainThreadBlocked main_thread_blocked(this);
     DebugScopedSetImplThread impl(this);
     layer_tree_host_->DeleteContentsTexturesOnImplThread(
         layer_tree_host_impl_->resource_provider());
+    success = layer_tree_host_impl_->InitializeRenderer(output_surface.Pass());
   }
 
-  bool initialized;
-  {
-    DebugScopedSetImplThread impl(this);
-
-    DCHECK(output_surface);
-    initialized = layer_tree_host_impl_->InitializeRenderer(
-        output_surface.Pass());
-    if (!initialized && offscreen_context_provider.get()) {
-      offscreen_context_provider->VerifyContexts();
-      offscreen_context_provider = NULL;
-    }
-
-    layer_tree_host_impl_->SetOffscreenContextProvider(
-        offscreen_context_provider);
-  }
-
-  OnOutputSurfaceInitializeAttempted(initialized);
-}
+  layer_tree_host_->OnCreateAndInitializeOutputSurfaceAttempted(success);
 
-void SingleThreadProxy::OnOutputSurfaceInitializeAttempted(bool success) {
-  LayerTreeHost::CreateResult result =
-      layer_tree_host_->OnCreateAndInitializeOutputSurfaceAttempted(success);
-  if (result == LayerTreeHost::CreateFailedButTryAgain) {
+  if (!success) {
     // Force another recreation attempt to happen by requesting another commit.
     SetNeedsCommit();
   }
@@ -299,6 +267,10 @@ void SingleThreadProxy::SetNeedsRedrawOnImplThread() {
   client_->ScheduleComposite();
 }
 
+void SingleThreadProxy::SetNeedsAnimateOnImplThread() {
+  SetNeedsRedrawOnImplThread();
+}
+
 void SingleThreadProxy::SetNeedsManageTilesOnImplThread() {
   // Thread-only/Impl-side-painting-only feature.
   NOTREACHED();
@@ -382,8 +354,8 @@ void SingleThreadProxy::DidSwapBuffersOnImplThread() {
   client_->DidPostSwapBuffers();
 }
 
-void SingleThreadProxy::OnSwapBuffersCompleteOnImplThread() {
-  TRACE_EVENT0("cc", "SingleThreadProxy::OnSwapBuffersCompleteOnImplThread");
+void SingleThreadProxy::DidSwapBuffersCompleteOnImplThread() {
+  TRACE_EVENT0("cc", "SingleThreadProxy::DidSwapBuffersCompleteOnImplThread");
   client_->DidCompleteSwapBuffers();
 }
 
@@ -469,25 +441,9 @@ bool SingleThreadProxy::CommitAndComposite(
 
   layer_tree_host_->WillCommit();
 
-  scoped_refptr<ContextProvider> offscreen_context_provider;
-  if (renderer_capabilities_for_main_thread_.using_offscreen_context3d &&
-      layer_tree_host_->needs_offscreen_context()) {
-    offscreen_context_provider =
-        layer_tree_host_->client()->OffscreenContextProvider();
-    if (offscreen_context_provider.get() &&
-        !offscreen_context_provider->BindToCurrentThread())
-      offscreen_context_provider = NULL;
-
-    if (offscreen_context_provider.get())
-      created_offscreen_context_provider_ = true;
-  }
-
   DoCommit(queue.Pass());
-  bool result = DoComposite(offscreen_context_provider,
-                            frame_begin_time,
-                            device_viewport_damage_rect,
-                            for_readback,
-                            frame);
+  bool result = DoComposite(
+      frame_begin_time, device_viewport_damage_rect, for_readback, frame);
   layer_tree_host_->DidBeginMainFrame();
   return result;
 }
@@ -505,7 +461,6 @@ void SingleThreadProxy::UpdateBackgroundAnimateTicking() {
 }
 
 bool SingleThreadProxy::DoComposite(
-    scoped_refptr<ContextProvider> offscreen_context_provider,
     base::TimeTicks frame_begin_time,
     const gfx::Rect& device_viewport_damage_rect,
     bool for_readback,
@@ -518,9 +473,6 @@ bool SingleThreadProxy::DoComposite(
     DebugScopedSetImplThread impl(this);
     base::AutoReset<bool> mark_inside(&inside_draw_, true);
 
-    layer_tree_host_impl_->SetOffscreenContextProvider(
-        offscreen_context_provider);
-
     bool can_do_readback = layer_tree_host_impl_->renderer()->CanReadPixels();
 
     // We guard PrepareToDraw() with CanDraw() because it always returns a valid
@@ -550,10 +502,6 @@ bool SingleThreadProxy::DoComposite(
   }
 
   if (lost_output_surface) {
-    ContextProvider* offscreen_contexts =
-        layer_tree_host_impl_->offscreen_context_provider();
-    if (offscreen_contexts)
-      offscreen_contexts->VerifyContexts();
     layer_tree_host_->DidLoseOutputSurface();
     return false;
   }