cc: Remove the capability to give up and leave compositing mode.

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 270 matching lines @@
 
 void ThreadProxy::DoCreateAndInitializeOutputSurface() {
   TRACE_EVENT0("cc", "ThreadProxy::DoCreateAndInitializeOutputSurface");
   DCHECK(IsMainThread());
 
   scoped_ptr<OutputSurface> output_surface =
       layer_tree_host()->CreateOutputSurface();
 
   RendererCapabilities capabilities;
   bool success = !!output_surface;
-  if (!success) {
-    OnOutputSurfaceInitializeAttempted(false, capabilities);
-    return;
-  }
-
-  success = false;
-  {
+  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);
 
     Proxy::ImplThreadTaskRunner()->PostTask(
         FROM_HERE,
         base::Bind(&ThreadProxy::InitializeOutputSurfaceOnImplThread,
                    impl_thread_weak_ptr_,
                    &completion,
                    base::Passed(&output_surface),
                    &success,
                    &capabilities));
     completion.Wait();
   }
+  main().renderer_capabilities_main_thread_copy = capabilities;
+  layer_tree_host()->OnCreateAndInitializeOutputSurfaceAttempted(success);
 
-  OnOutputSurfaceInitializeAttempted(success, capabilities);
+  if (success) {
+    main().output_surface_creation_callback.Cancel();
+  } else if (!main().output_surface_creation_callback.IsCancelled()) {
+    Proxy::MainThreadTaskRunner()->PostTask(
+        FROM_HERE, main().output_surface_creation_callback.callback());
+  }
 }
 
 void ThreadProxy::SetRendererCapabilitiesMainThreadCopy(
     const RendererCapabilities& capabilities) {
   main().renderer_capabilities_main_thread_copy = capabilities;
 }
 
-void ThreadProxy::OnOutputSurfaceInitializeAttempted(
-    bool success,
-    const RendererCapabilities& capabilities) {
-  DCHECK(IsMainThread());
-  DCHECK(layer_tree_host());
-
-  if (success) {
-    main().renderer_capabilities_main_thread_copy = capabilities;
-  }
-
-  LayerTreeHost::CreateResult result =
-      layer_tree_host()->OnCreateAndInitializeOutputSurfaceAttempted(success);
-  if (result == LayerTreeHost::CreateFailedButTryAgain) {
-    if (!main().output_surface_creation_callback.callback().is_null()) {
-      Proxy::MainThreadTaskRunner()->PostTask(
-          FROM_HERE, main().output_surface_creation_callback.callback());
-    }
-  } else {
-    main().output_surface_creation_callback.Cancel();
-  }
-}
-
 void ThreadProxy::SendCommitRequestToImplThreadIfNeeded() {
   DCHECK(IsMainThread());
   if (main().commit_request_sent_to_impl_thread)
     return;
   main().commit_request_sent_to_impl_thread = true;
   Proxy::ImplThreadTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&ThreadProxy::SetNeedsCommitOnImplThread,
                  impl_thread_weak_ptr_));
 }
@@ skipping 1300 matching lines @@
 
   impl().timing_history.DidActivatePendingTree();
 }
 
 void ThreadProxy::DidManageTiles() {
   DCHECK(IsImplThread());
   impl().scheduler->DidManageTiles();
 }
 
 }  // namespace cc