Make cc output surface creation async

cc/trees/single_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/single_thread_proxy.h"
 
 #include "base/auto_reset.h"
 #include "base/debug/trace_event.h"
 #include "cc/debug/benchmark_instrumentation.h"
 #include "cc/output/context_provider.h"
@@ skipping 83 matching lines @@
 void SingleThreadProxy::SetVisible(bool visible) {
   TRACE_EVENT0("cc", "SingleThreadProxy::SetVisible");
   DebugScopedSetImplThread impl(this);
   layer_tree_host_impl_->SetVisible(visible);
   if (scheduler_on_impl_thread_)
     scheduler_on_impl_thread_->SetVisible(layer_tree_host_impl_->visible());
   // Changing visibility could change ShouldComposite().
   UpdateBackgroundAnimateTicking();
 }
 
-void SingleThreadProxy::CreateAndInitializeOutputSurface() {
-  TRACE_EVENT0(
-      "cc", "SingleThreadProxy::CreateAndInitializeOutputSurface");
+void SingleThreadProxy::RequestNewOutputSurface() {
   DCHECK(Proxy::IsMainThread());
   DCHECK(layer_tree_host_->output_surface_lost());
+  layer_tree_host_->RequestNewOutputSurface();
+}
 
-  scoped_ptr<OutputSurface> output_surface =
-      layer_tree_host_->CreateOutputSurface();
-
+void SingleThreadProxy::SetOutputSurface(
+    scoped_ptr<OutputSurface> output_surface) {
+  DCHECK(Proxy::IsMainThread());
+  DCHECK(layer_tree_host_->output_surface_lost());
   renderer_capabilities_for_main_thread_ = RendererCapabilities();
 
   bool success = !!output_surface;
   if (success) {

[danakj, 2014/06/20 23:36:34]

Do we want the embedder to be able to call back with NULL?

[enne (OOO), 2014/06/23 16:57:39]

I think the ultimate answer is no, but I don't know that I want to change that
in this patch too, since it'll require a little more refactoring.

     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());
   }
 
   layer_tree_host_->OnCreateAndInitializeOutputSurfaceAttempted(success);
 
   if (success) {
     if (scheduler_on_impl_thread_)
       scheduler_on_impl_thread_->DidCreateAndInitializeOutputSurface();
   } else if (Proxy::MainThreadTaskRunner()) {
     Proxy::MainThreadTaskRunner()->PostTask(
         FROM_HERE,
-        base::Bind(&SingleThreadProxy::CreateAndInitializeOutputSurface,
+        base::Bind(&SingleThreadProxy::RequestNewOutputSurface,
                    weak_factory_.GetWeakPtr()));
   }
 }
 
 const RendererCapabilities& SingleThreadProxy::GetRendererCapabilities() const {
   DCHECK(Proxy::IsMainThread());
   DCHECK(!layer_tree_host_->output_surface_lost());
   return renderer_capabilities_for_main_thread_;
 }
 
@@ skipping 474 matching lines @@
 void SingleThreadProxy::ScheduledActionBeginOutputSurfaceCreation() {
   DebugScopedSetMainThread main(this);
   DCHECK(scheduler_on_impl_thread_);
   // If possible, create the output surface in a post task.  Synchronously
   // creating the output surface makes tests more awkward since this differs
   // from the ThreadProxy behavior.  However, sometimes there is no
   // task runner.
   if (Proxy::MainThreadTaskRunner()) {
     Proxy::MainThreadTaskRunner()->PostTask(
         FROM_HERE,
-        base::Bind(&SingleThreadProxy::CreateAndInitializeOutputSurface,
+        base::Bind(&SingleThreadProxy::RequestNewOutputSurface,
                    weak_factory_.GetWeakPtr()));
   } else {
-    CreateAndInitializeOutputSurface();
+    RequestNewOutputSurface();
   }
 }
 
 void SingleThreadProxy::ScheduledActionManageTiles() {
   // Impl-side painting only.
   NOTREACHED();
 }
 
 void SingleThreadProxy::DidAnticipatedDrawTimeChange(base::TimeTicks time) {
 }
 
 base::TimeDelta SingleThreadProxy::DrawDurationEstimate() {
   return timing_history_.DrawDurationEstimate();
 }
 
 base::TimeDelta SingleThreadProxy::BeginMainFrameToCommitDurationEstimate() {
   return timing_history_.BeginMainFrameToCommitDurationEstimate();
 }
 
 base::TimeDelta SingleThreadProxy::CommitToActivateDurationEstimate() {
   return timing_history_.CommitToActivateDurationEstimate();
 }
 
 void SingleThreadProxy::DidBeginImplFrameDeadline() {
   layer_tree_host_impl_->ResetCurrentFrameTimeForNextFrame();
 }
 
 }  // namespace cc