cc: Stop blocking the main thread in CreateAndInitializeOutputSurface.

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 180 matching lines @@
 void ThreadProxy::UpdateBackgroundAnimateTicking() {
   bool should_background_tick =
       !impl().scheduler->WillDrawIfNeeded() &&
       impl().layer_tree_host_impl->active_tree()->root_layer();
   impl().layer_tree_host_impl->UpdateBackgroundAnimateTicking(
       should_background_tick);
   if (should_background_tick)
     impl().animations_frozen_until_next_draw = false;
 }
 
-void ThreadProxy::DoCreateAndInitializeOutputSurface() {
+void ThreadProxy::DidLoseOutputSurface() {
+  TRACE_EVENT0("cc", "ThreadProxy::DidLoseOutputSurface");
+  DCHECK(IsMainThread());
+  layer_tree_host()->DidLoseOutputSurface();
+
+  {
+    DebugScopedSetMainThreadBlocked main_thread_blocked(this);
+
+    // Return lost resources to their owners immediately.
+    BlockingTaskRunner::CapturePostTasks blocked;
+
+    CompletionEvent completion;
+    Proxy::ImplThreadTaskRunner()->PostTask(
+        FROM_HERE,
+        base::Bind(&ThreadProxy::DeleteContentsTexturesOnImplThread,
+                   impl_thread_weak_ptr_,
+                   &completion));
+    completion.Wait();
+  }
+}
+
+void ThreadProxy::CreateAndInitializeOutputSurface() {
   TRACE_EVENT0("cc", "ThreadProxy::DoCreateAndInitializeOutputSurface");
   DCHECK(IsMainThread());
 
   scoped_ptr<OutputSurface> output_surface =
       layer_tree_host()->CreateOutputSurface();
 
-  RendererCapabilities capabilities;
-  bool success = !!output_surface;
-  if (success) {
-    // 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);
-
+  if (output_surface) {
     Proxy::ImplThreadTaskRunner()->PostTask(
         FROM_HERE,
         base::Bind(&ThreadProxy::InitializeOutputSurfaceOnImplThread,
                    impl_thread_weak_ptr_,
-                   &completion,
-                   base::Passed(&output_surface),
-                   &success,
-                   &capabilities));
-    completion.Wait();
+                   base::Passed(&output_surface)));
+    return;
   }
+
+  DidInitializeOutputSurface(false, RendererCapabilities());
+}
+
+void ThreadProxy::DidInitializeOutputSurface(
+    bool success,
+    const RendererCapabilities& capabilities) {
+  TRACE_EVENT0("cc", "ThreadProxy::DidInitializeOutputSurface");
+  DCHECK(IsMainThread());
   main().renderer_capabilities_main_thread_copy = capabilities;
   layer_tree_host()->OnCreateAndInitializeOutputSurfaceAttempted(success);
 
-  if (success) {
-    main().output_surface_creation_callback.Cancel();
-  } else if (!main().output_surface_creation_callback.IsCancelled()) {
+  if (!success) {
     Proxy::MainThreadTaskRunner()->PostTask(
-        FROM_HERE, main().output_surface_creation_callback.callback());
+        FROM_HERE,
+        base::Bind(&ThreadProxy::CreateAndInitializeOutputSurface,
+                   main_thread_weak_ptr_));
   }
 }
 
 void ThreadProxy::SetRendererCapabilitiesMainThreadCopy(
     const RendererCapabilities& capabilities) {
   main().renderer_capabilities_main_thread_copy = capabilities;
 }
 
 void ThreadProxy::SendCommitRequestToImplThreadIfNeeded() {
   DCHECK(IsMainThread());
@@ skipping 60 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;
+  Proxy::MainThreadTaskRunner()->PostTask(
+      FROM_HERE,
+      base::Bind(&ThreadProxy::DidLoseOutputSurface, main_thread_weak_ptr_));
   impl().scheduler->DidLoseOutputSurface();
 }
 
 void ThreadProxy::CommitVSyncParameters(base::TimeTicks timebase,
                                         base::TimeDelta interval) {
   impl().scheduler->CommitVSyncParameters(timebase, interval);
 }
 
 void ThreadProxy::SetEstimatedParentDrawTime(base::TimeDelta draw_time) {
   impl().scheduler->SetEstimatedParentDrawTime(draw_time);
@@ skipping 395 matching lines @@
     TRACE_EVENT_INSTANT0(
         "cc", "EarlyOut_DeferCommits", TRACE_EVENT_SCOPE_THREAD);
     return;
   }
 
   // If the commit finishes, LayerTreeHost will transfer its swap promises to
   // LayerTreeImpl. The destructor of SwapPromiseChecker checks LayerTressHost's
   // swap promises.
   SwapPromiseChecker swap_promise_checker(layer_tree_host());
 
-  // Do not notify the impl thread of commit requests that occur during
-  // the apply/animate/layout part of the BeginMainFrameAndCommit process since
-  // those commit requests will get painted immediately. Once we have done
-  // the paint, main().commit_requested will be set to false to allow new commit
-  // requests to be scheduled.
-  main().commit_requested = true;
-  main().commit_request_sent_to_impl_thread = true;
-
-  // On the other hand, the AnimationRequested flag needs to be cleared
-  // here so that any animation requests generated by the apply or animate
-  // callbacks will trigger another frame.
+  main().commit_requested = false;
+  main().commit_request_sent_to_impl_thread = false;
   main().animate_requested = false;
 
   if (!layer_tree_host()->visible()) {
-    main().commit_requested = false;
-    main().commit_request_sent_to_impl_thread = false;
-
     TRACE_EVENT_INSTANT0("cc", "EarlyOut_NotVisible", TRACE_EVENT_SCOPE_THREAD);
     bool did_handle = false;
     Proxy::ImplThreadTaskRunner()->PostTask(
         FROM_HERE,
         base::Bind(&ThreadProxy::BeginMainFrameAbortedOnImplThread,
                    impl_thread_weak_ptr_,
                    did_handle));
     return;
   }
 
+  if (layer_tree_host()->output_surface_lost()) {
+    TRACE_EVENT_INSTANT0(
+        "cc", "EarlyOut_OutputSurfaceLost", TRACE_EVENT_SCOPE_THREAD);
+    bool did_handle = false;
+    Proxy::ImplThreadTaskRunner()->PostTask(
+        FROM_HERE,
+        base::Bind(&ThreadProxy::BeginMainFrameAbortedOnImplThread,
+                   impl_thread_weak_ptr_,
+                   did_handle));
+    return;
+  }
+
+  // Do not notify the impl thread of commit requests that occur during
+  // the apply/animate/layout part of the BeginMainFrameAndCommit process since
+  // those commit requests will get painted immediately. Once we have done
+  // the paint, main().commit_requested will be set to false to allow new commit
+  // requests to be scheduled.
+  // On the other hand, the animate_requested flag should remain cleared
+  // here so that any animation requests generated by the apply or animate
+  // callbacks will trigger another frame.
+  main().commit_requested = true;
+  main().commit_request_sent_to_impl_thread = true;
+
   layer_tree_host()->ApplyScrollAndScale(*begin_main_frame_state->scroll_info);
 
   layer_tree_host()->WillBeginMainFrame();
 
   layer_tree_host()->UpdateClientAnimations(
       begin_main_frame_state->monotonic_frame_begin_time);
   layer_tree_host()->AnimateLayers(
       begin_main_frame_state->monotonic_frame_begin_time);
   blocked_main().last_monotonic_frame_begin_time =
       begin_main_frame_state->monotonic_frame_begin_time;
@@ skipping 421 matching lines @@
   DCHECK(IsMainThread());
   layer_tree_host()->DidCompleteSwapBuffers();
 }
 
 void ThreadProxy::SetAnimationEvents(scoped_ptr<AnimationEventsVector> events) {
   TRACE_EVENT0("cc", "ThreadProxy::SetAnimationEvents");
   DCHECK(IsMainThread());
   layer_tree_host()->SetAnimationEvents(events.Pass());
 }
 
-void ThreadProxy::CreateAndInitializeOutputSurface() {
-  TRACE_EVENT0("cc", "ThreadProxy::CreateAndInitializeOutputSurface");
-  DCHECK(IsMainThread());
-
-  // Check that output surface has not been recreated by CompositeAndReadback
-  // after this task is posted but before it is run.
-  bool has_initialized_output_surface = true;
-  {
-    CompletionEvent completion;
-    Proxy::ImplThreadTaskRunner()->PostTask(
-        FROM_HERE,
-        base::Bind(&ThreadProxy::HasInitializedOutputSurfaceOnImplThread,
-                   impl_thread_weak_ptr_,
-                   &completion,
-                   &has_initialized_output_surface));
-    completion.Wait();
-  }
-  if (has_initialized_output_surface)
-    return;
-
-  layer_tree_host()->DidLoseOutputSurface();
-  main().output_surface_creation_callback.Reset(
-      base::Bind(&ThreadProxy::DoCreateAndInitializeOutputSurface,
-                 base::Unretained(this)));
-  main().output_surface_creation_callback.callback().Run();
-}
-
-void ThreadProxy::HasInitializedOutputSurfaceOnImplThread(
-    CompletionEvent* completion,
-    bool* has_initialized_output_surface) {
-  DCHECK(IsImplThread());
-  *has_initialized_output_surface =
-      impl().scheduler->HasInitializedOutputSurface();
-  completion->Signal();
-}
-
 void ThreadProxy::InitializeImplOnImplThread(CompletionEvent* completion) {
   TRACE_EVENT0("cc", "ThreadProxy::InitializeImplOnImplThread");
   DCHECK(IsImplThread());
   impl().layer_tree_host_impl =
       layer_tree_host()->CreateLayerTreeHostImpl(this);
   const LayerTreeSettings& settings = layer_tree_host()->settings();
   SchedulerSettings scheduler_settings;
   scheduler_settings.begin_frame_scheduling_enabled =
       settings.begin_frame_scheduling_enabled;
   scheduler_settings.main_frame_before_draw_enabled =
@@ skipping 12 matching lines @@
   impl().scheduler = Scheduler::Create(this,
                                        scheduler_settings,
                                        impl().layer_tree_host_id,
                                        ImplThreadTaskRunner());
   impl().scheduler->SetVisible(impl().layer_tree_host_impl->visible());
 
   impl_thread_weak_ptr_ = impl().weak_factory.GetWeakPtr();
   completion->Signal();
 }
 
+void ThreadProxy::DeleteContentsTexturesOnImplThread(
+    CompletionEvent* completion) {
+  TRACE_EVENT0("cc", "ThreadProxy::DeleteContentsTexturesOnImplThread");
+  DCHECK(IsImplThread());
+  DCHECK(IsMainThreadBlocked());
+  layer_tree_host()->DeleteContentsTexturesOnImplThread(
+      impl().layer_tree_host_impl->resource_provider());
+  completion->Signal();
+}
+
 void ThreadProxy::InitializeOutputSurfaceOnImplThread(
-    CompletionEvent* completion,
-    scoped_ptr<OutputSurface> output_surface,
-    bool* success,
-    RendererCapabilities* capabilities) {
+    scoped_ptr<OutputSurface> output_surface) {
   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();
+  LayerTreeHostImpl* host_impl = impl().layer_tree_host_impl.get();
+  bool success = host_impl->InitializeRenderer(output_surface.Pass());
+  RendererCapabilities capabilities;
+  if (success) {
+    capabilities =
+        host_impl->GetRendererCapabilities().MainThreadCapabilities();
   }
 
-  completion->Signal();
+  Proxy::MainThreadTaskRunner()->PostTask(
+      FROM_HERE,
+      base::Bind(&ThreadProxy::DidInitializeOutputSurface,
+                 main_thread_weak_ptr_,
+                 success,
+                 capabilities));
+
+  if (success)
+    impl().scheduler->DidCreateAndInitializeOutputSurface();
 }
 
 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();
 }
 
 void ThreadProxy::LayerTreeHostClosedOnImplThread(CompletionEvent* completion) {
   TRACE_EVENT0("cc", "ThreadProxy::LayerTreeHostClosedOnImplThread");
   DCHECK(IsImplThread());
+  DCHECK(IsMainThreadBlocked());
   layer_tree_host()->DeleteContentsTexturesOnImplThread(
       impl().layer_tree_host_impl->resource_provider());
   impl().current_resource_update_controller.reset();
   impl().layer_tree_host_impl->SetNeedsBeginFrame(false);
   impl().scheduler.reset();
   impl().layer_tree_host_impl.reset();
   impl().weak_factory.InvalidateWeakPtrs();
   impl().contents_texture_manager = NULL;
   completion->Signal();
 }
@@ skipping 152 matching lines @@
 
   impl().timing_history.DidActivatePendingTree();
 }
 
 void ThreadProxy::DidManageTiles() {
   DCHECK(IsImplThread());
   impl().scheduler->DidManageTiles();
 }
 
 }  // namespace cc