Re-land: cc: Implement shared worker 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 192 matching lines @@
   TRACE_EVENT0("cc", "ThreadProxy::DidLoseOutputSurface");
   DCHECK(IsMainThread());
   layer_tree_host()->DidLoseOutputSurface();
 }
 
 void ThreadProxy::RequestNewOutputSurface() {
   DCHECK(IsMainThread());
   layer_tree_host()->RequestNewOutputSurface();
 }
 
-void ThreadProxy::SetOutputSurface(scoped_ptr<OutputSurface> output_surface) {
+void ThreadProxy::SetOutputSurface(OutputSurface* output_surface) {
   Proxy::ImplThreadTaskRunner()->PostTask(
-      FROM_HERE,
-      base::Bind(&ThreadProxy::InitializeOutputSurfaceOnImplThread,
-                 impl_thread_weak_ptr_, base::Passed(&output_surface)));
+      FROM_HERE, base::Bind(&ThreadProxy::InitializeOutputSurfaceOnImplThread,
+                            impl_thread_weak_ptr_, output_surface));
 }
 
-scoped_ptr<OutputSurface> ThreadProxy::ReleaseOutputSurface() {
+void ThreadProxy::ReleaseOutputSurface() {
   DCHECK(IsMainThread());
   DCHECK(layer_tree_host()->output_surface_lost());
 
   DebugScopedSetMainThreadBlocked main_thread_blocked(this);
   CompletionEvent completion;
-  scoped_ptr<OutputSurface> output_surface;
   Proxy::ImplThreadTaskRunner()->PostTask(
-      FROM_HERE,
-      base::Bind(&ThreadProxy::ReleaseOutputSurfaceOnImplThread,
-                 impl_thread_weak_ptr_, &completion, &output_surface));
+      FROM_HERE, base::Bind(&ThreadProxy::ReleaseOutputSurfaceOnImplThread,
+                            impl_thread_weak_ptr_, &completion));
   completion.Wait();
-  return output_surface;
 }
 
 void ThreadProxy::DidInitializeOutputSurface(
     bool success,
     const RendererCapabilities& capabilities) {
   TRACE_EVENT0("cc", "ThreadProxy::DidInitializeOutputSurface");
   DCHECK(IsMainThread());
 
   if (!success) {
     layer_tree_host()->DidFailToInitializeOutputSurface();
@@ skipping 791 matching lines @@
       this, scheduler_settings, impl().layer_tree_host_id,
       ImplThreadTaskRunner(), impl().external_begin_frame_source.get(),
       compositor_timing_history.Pass());
 
   impl().scheduler->SetVisible(impl().layer_tree_host_impl->visible());
   impl_thread_weak_ptr_ = impl().weak_factory.GetWeakPtr();
   completion->Signal();
 }
 
 void ThreadProxy::InitializeOutputSurfaceOnImplThread(
-    scoped_ptr<OutputSurface> output_surface) {
+    OutputSurface* output_surface) {
   TRACE_EVENT0("cc", "ThreadProxy::InitializeOutputSurfaceOnImplThread");
   DCHECK(IsImplThread());
 
   LayerTreeHostImpl* host_impl = impl().layer_tree_host_impl.get();
-  bool success = host_impl->InitializeRenderer(output_surface.Pass());
+  bool success = host_impl->InitializeRenderer(output_surface);
   RendererCapabilities capabilities;
   if (success) {
     capabilities =
         host_impl->GetRendererCapabilities().MainThreadCapabilities();
   }
 
   Proxy::MainThreadTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&ThreadProxy::DidInitializeOutputSurface,
                  main_thread_weak_ptr_,
                  success,
                  capabilities));
 
   if (success)
     impl().scheduler->DidCreateAndInitializeOutputSurface();
 }
 
 void ThreadProxy::ReleaseOutputSurfaceOnImplThread(
-    CompletionEvent* completion,
-    scoped_ptr<OutputSurface>* output_surface) {
+    CompletionEvent* completion) {
   DCHECK(IsImplThread());
 
   // Unlike DidLoseOutputSurfaceOnImplThread, we don't need to call
   // LayerTreeHost::DidLoseOutputSurface since it already knows.
   impl().scheduler->DidLoseOutputSurface();
-  *output_surface = impl().layer_tree_host_impl->ReleaseOutputSurface();
+  impl().layer_tree_host_impl->ReleaseOutputSurface();
   completion->Signal();
 }
 
 void ThreadProxy::FinishGLOnImplThread(CompletionEvent* completion) {
   TRACE_EVENT0("cc", "ThreadProxy::FinishGLOnImplThread");
   DCHECK(IsImplThread());
   if (impl().layer_tree_host_impl->output_surface()) {
     ContextProvider* context_provider =
         impl().layer_tree_host_impl->output_surface()->context_provider();
     if (context_provider)
@@ skipping 162 matching lines @@
 
 void ThreadProxy::PostFrameTimingEvents(
     scoped_ptr<FrameTimingTracker::CompositeTimingSet> composite_events,
     scoped_ptr<FrameTimingTracker::MainFrameTimingSet> main_frame_events) {
   DCHECK(IsMainThread());
   layer_tree_host()->RecordFrameTimingEvents(composite_events.Pass(),
                                              main_frame_events.Pass());
 }
 
 }  // namespace cc