Remove offscreen compositor contexts.

cc/trees/thread_proxy.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/thread_proxy.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/auto_reset.h"
@@ skipping 74 matching lines @@
   DCHECK(IsMainThread());
   DCHECK(this->layer_tree_host());
 }
 
 ThreadProxy::MainThreadOnly::MainThreadOnly(ThreadProxy* proxy,
                                             int layer_tree_host_id)
     : layer_tree_host_id(layer_tree_host_id),
       animate_requested(false),
       commit_requested(false),
       commit_request_sent_to_impl_thread(false),
-      created_offscreen_context_provider(false),
       started(false),
       in_composite_and_readback(false),
       manage_tiles_pending(false),
       can_cancel_commit(true),
       defer_commits(false),
       weak_factory(proxy) {}
 
 ThreadProxy::MainThreadOnly::~MainThreadOnly() {}
 
 ThreadProxy::MainThreadOrBlockedMainThread::MainThreadOrBlockedMainThread(
@@ skipping 181 matching lines @@
   scoped_ptr<OutputSurface> output_surface =
       layer_tree_host()->CreateOutputSurface();
 
   RendererCapabilities capabilities;
   bool success = !!output_surface;
   if (!success) {
     OnOutputSurfaceInitializeAttempted(false, capabilities);
     return;
   }
 
-  scoped_refptr<ContextProvider> offscreen_context_provider;
-  if (main().created_offscreen_context_provider) {
-    offscreen_context_provider =
-        layer_tree_host()->client()->OffscreenContextProvider();
-    success = !!offscreen_context_provider.get();
-    if (!success) {
-      OnOutputSurfaceInitializeAttempted(false, capabilities);
-      return;
-    }
-  }
-
   success = false;
   {
     // Make a blocking call to InitializeOutputSurfaceOnImplThread. The results
     // of that call are pushed into the success and capabilities local
     // variables.
     CompletionEvent completion;
     DebugScopedSetMainThreadBlocked main_thread_blocked(this);
 
     Proxy::ImplThreadTaskRunner()->PostTask(
         FROM_HERE,
         base::Bind(&ThreadProxy::InitializeOutputSurfaceOnImplThread,
                    impl_thread_weak_ptr_,
                    &completion,
                    base::Passed(&output_surface),
-                   offscreen_context_provider,
                    &success,
                    &capabilities));
     completion.Wait();
   }
 
   OnOutputSurfaceInitializeAttempted(success, capabilities);
 }
 
 void ThreadProxy::SetRendererCapabilitiesMainThreadCopy(
     const RendererCapabilities& capabilities) {
@@ skipping 87 matching lines @@
   TRACE_EVENT0("cc", "ThreadProxy::DidLoseOutputSurfaceOnImplThread");
   DCHECK(IsImplThread());
   CheckOutputSurfaceStatusOnImplThread();
 }
 
 void ThreadProxy::CheckOutputSurfaceStatusOnImplThread() {
   TRACE_EVENT0("cc", "ThreadProxy::CheckOutputSurfaceStatusOnImplThread");
   DCHECK(IsImplThread());
   if (!impl().layer_tree_host_impl->IsContextLost())
     return;
-  if (ContextProvider* offscreen_contexts =
-          impl().layer_tree_host_impl->offscreen_context_provider())
-    offscreen_contexts->VerifyContexts();
   impl().scheduler->DidLoseOutputSurface();
 }
 
 void ThreadProxy::SetMaxSwapsPendingOnImplThread(int max) {
   impl().scheduler->SetMaxSwapsPending(max);
 }
 
 void ThreadProxy::DidSwapBuffersOnImplThread() {
   impl().scheduler->DidSwapBuffers();
 }
@@ skipping 499 matching lines @@
                    did_handle));
 
     // Although the commit is internally aborted, this is because it has been
     // detected to be a no-op.  From the perspective of an embedder, this commit
     // went through, and input should no longer be throttled, etc.
     layer_tree_host()->CommitComplete();
     layer_tree_host()->DidBeginMainFrame();
     return;
   }
 
-  scoped_refptr<ContextProvider> offscreen_context_provider;
-  if (main().renderer_capabilities_main_thread_copy.using_offscreen_context3d &&
-      layer_tree_host()->needs_offscreen_context()) {
-    offscreen_context_provider =
-        layer_tree_host()->client()->OffscreenContextProvider();
-    if (offscreen_context_provider.get())
-      main().created_offscreen_context_provider = true;
-  }
-
   // Notify the impl thread that the main thread is ready to commit. This will
   // begin the commit process, which is blocking from the main thread's
   // point of view, but asynchronously performed on the impl thread,
   // coordinated by the Scheduler.
   {
     TRACE_EVENT0("cc", "ThreadProxy::BeginMainFrame::commit");
 
     DebugScopedSetMainThreadBlocked main_thread_blocked(this);
 
     // This CapturePostTasks should be destroyed before CommitComplete() is
     // called since that goes out to the embedder, and we want the embedder
     // to receive its callbacks before that.
     BlockingTaskRunner::CapturePostTasks blocked;
 
     CompletionEvent completion;
     Proxy::ImplThreadTaskRunner()->PostTask(
         FROM_HERE,
         base::Bind(&ThreadProxy::StartCommitOnImplThread,
                    impl_thread_weak_ptr_,
                    &completion,
-                   queue.release(),
-                   offscreen_context_provider));
+                   queue.release()));
     completion.Wait();
 
     RenderingStatsInstrumentation* stats_instrumentation =
         layer_tree_host()->rendering_stats_instrumentation();
     BenchmarkInstrumentation::IssueMainThreadRenderingStatsEvent(
         stats_instrumentation->main_thread_rendering_stats());
     stats_instrumentation->AccumulateAndClearMainThreadStats();
   }
 
   layer_tree_host()->CommitComplete();
   layer_tree_host()->DidBeginMainFrame();
 }
 
-void ThreadProxy::StartCommitOnImplThread(
-    CompletionEvent* completion,
-    ResourceUpdateQueue* raw_queue,
-    scoped_refptr<ContextProvider> offscreen_context_provider) {
+void ThreadProxy::StartCommitOnImplThread(CompletionEvent* completion,
+                                          ResourceUpdateQueue* raw_queue) {
   TRACE_EVENT0("cc", "ThreadProxy::StartCommitOnImplThread");
   DCHECK(!impl().commit_completion_event);
   DCHECK(IsImplThread() && IsMainThreadBlocked());
   DCHECK(impl().scheduler);
   DCHECK(impl().scheduler->CommitPending());
 
   if (!impl().layer_tree_host_impl) {
     TRACE_EVENT_INSTANT0(
         "cc", "EarlyOut_NoLayerTree", TRACE_EVENT_SCOPE_THREAD);
     completion->Signal();
     return;
   }
 
   // Ideally, we should inform to impl thread when BeginMainFrame is started.
   // But, we can avoid a PostTask in here.
   impl().scheduler->NotifyBeginMainFrameStarted();
 
   scoped_ptr<ResourceUpdateQueue> queue(raw_queue);
 
-  if (offscreen_context_provider.get())
-    offscreen_context_provider->BindToCurrentThread();
-  impl().layer_tree_host_impl->SetOffscreenContextProvider(
-      offscreen_context_provider);
-
   if (impl().contents_texture_manager) {
     DCHECK_EQ(impl().contents_texture_manager,
               blocked_main().contents_texture_manager());
   } else {
     // Cache this pointer that was created on the main thread side to avoid a
     // data race between creating it and using it on the compositor thread.
     impl().contents_texture_manager = blocked_main().contents_texture_manager();
   }
 
   if (impl().contents_texture_manager) {
@@ skipping 411 matching lines @@
                                        ImplThreadTaskRunner());
   impl().scheduler->SetVisible(impl().layer_tree_host_impl->visible());
 
   impl_thread_weak_ptr_ = impl().weak_factory.GetWeakPtr();
   completion->Signal();
 }
 
 void ThreadProxy::InitializeOutputSurfaceOnImplThread(
     CompletionEvent* completion,
     scoped_ptr<OutputSurface> output_surface,
-    scoped_refptr<ContextProvider> offscreen_context_provider,
     bool* success,
     RendererCapabilities* capabilities) {
   TRACE_EVENT0("cc", "ThreadProxy::InitializeOutputSurfaceOnImplThread");
   DCHECK(IsImplThread());
   DCHECK(IsMainThreadBlocked());
   DCHECK(success);
   DCHECK(capabilities);
 
   layer_tree_host()->DeleteContentsTexturesOnImplThread(
       impl().layer_tree_host_impl->resource_provider());
 
   *success =
       impl().layer_tree_host_impl->InitializeRenderer(output_surface.Pass());
 
   if (*success) {
     *capabilities = impl()
                         .layer_tree_host_impl->GetRendererCapabilities()
                         .MainThreadCapabilities();
     impl().scheduler->DidCreateAndInitializeOutputSurface();
-  } else if (offscreen_context_provider.get()) {
-    if (offscreen_context_provider->BindToCurrentThread())
-      offscreen_context_provider->VerifyContexts();
-    offscreen_context_provider = NULL;
   }
 
-  impl().layer_tree_host_impl->SetOffscreenContextProvider(
-      offscreen_context_provider);
-
   completion->Signal();
 }
 
 void ThreadProxy::FinishGLOnImplThread(CompletionEvent* completion) {
   TRACE_EVENT0("cc", "ThreadProxy::FinishGLOnImplThread");
   DCHECK(IsImplThread());
   if (impl().layer_tree_host_impl->resource_provider())
     impl().layer_tree_host_impl->resource_provider()->Finish();
   completion->Signal();
 }
@@ skipping 202 matching lines @@
 
   impl().timing_history.DidActivatePendingTree();
 }
 
 void ThreadProxy::DidManageTiles() {
   DCHECK(IsImplThread());
   impl().scheduler->DidManageTiles();
 }
 
 }  // namespace cc