cc: Update Main RendererCapabilities on DeferredInitialize

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 317 matching lines @@
                    base::Passed(&output_surface),
                    offscreen_context_provider,
                    &success,
                    &capabilities));
     completion.Wait();
   }
 
   OnOutputSurfaceInitializeAttempted(success, capabilities);
 }
 
+void ThreadProxy::SetRendererCapabilitiesMainThreadCopy(
+    const RendererCapabilities& capabilities) {
+  DCHECK(IsMainThread());
+  main().renderer_capabilities_main_thread_copy = capabilities;
+  layer_tree_host()->RendererCapabilitiesChanged();
+}
+
 void ThreadProxy::OnOutputSurfaceInitializeAttempted(
     bool success,
     const RendererCapabilities& capabilities) {
   DCHECK(IsMainThread());
   DCHECK(layer_tree_host());
 
+  LayerTreeHost::CreateResult result =
+      layer_tree_host()->OnCreateAndInitializeOutputSurfaceAttempted(success);
   if (success) {
-    main().renderer_capabilities_main_thread_copy = capabilities;
+    SetRendererCapabilitiesMainThreadCopy(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();
   }
 }
 
@@ skipping 41 matching lines @@
   main().can_cancel_commit = false;
 
   if (main().commit_requested)
     return;
   TRACE_EVENT0("cc", "ThreadProxy::SetNeedsCommit");
   main().commit_requested = true;
 
   SendCommitRequestToImplThreadIfNeeded();
 }
 
+void ThreadProxy::UpdateRendererCapabilitiesOnImplThread() {
+  DCHECK(IsImplThread());
+  // PrioritizedResourceManager is not cleared, so this won't yet work with
+  // ContentLayer or ImageLayer, which are only used when impl_side_painting is
+  // off.
+  DCHECK(impl().layer_tree_host_impl->settings().impl_side_painting);
+
+  Proxy::MainThreadTaskRunner()->PostTask(
+      FROM_HERE,
+      base::Bind(&ThreadProxy::SetRendererCapabilitiesMainThreadCopy,
+                 main_thread_weak_ptr_,
+                 impl()
+                     .layer_tree_host_impl->GetRendererCapabilities()
+                     .MainThreadCapabilities()));
+}
+
 void ThreadProxy::DidLoseOutputSurfaceOnImplThread() {
   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())
@@ skipping 531 matching lines @@
     // 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));
+                   offscreen_context_provider,
+                   main().renderer_capabilities_main_thread_copy));
     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) {
+    scoped_refptr<ContextProvider> offscreen_context_provider,
+    const RendererCapabilities& main_frame_renderer_caps) {
   scoped_ptr<ResourceUpdateQueue> queue(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(
@@ skipping 22 matching lines @@
       // resources
       queue->ClearUploadsToEvictedResources();
       // Some textures in the layer tree are invalid. Kick off another commit
       // to fill them again.
       SetNeedsCommitOnImplThread();
     }
 
     impl().contents_texture_manager->PushTexturePrioritiesToBackings();
   }
 
+  impl().renderer_capabilities_for_commit = main_frame_renderer_caps;
   impl().commit_completion_event = completion;
   impl().current_resource_update_controller = ResourceUpdateController::Create(
       this,
       Proxy::ImplThreadTaskRunner(),
       queue.Pass(),
       impl().layer_tree_host_impl->resource_provider());
   impl().current_resource_update_controller->PerformMoreUpdates(
       impl().scheduler->AnticipatedDrawTime());
 }
 
@@ skipping 342 matching lines @@
     delta = base::TimeDelta();
   Proxy::ImplThreadTaskRunner()->PostDelayedTask(FROM_HERE, closure, delta);
 }
 
 void ThreadProxy::DidBeginImplFrameDeadline() {
   impl().layer_tree_host_impl->ResetCurrentFrameTimeForNextFrame();
 }
 
 void ThreadProxy::ReadyToFinalizeTextureUpdates() {
   DCHECK(IsImplThread());
-  impl().scheduler->FinishCommit();
+
+  const RendererCapabilitiesImpl& impl_caps =
+      impl().layer_tree_host_impl->GetRendererCapabilities();
+  if (impl_caps.MainThreadCapabilities() ==
+      impl().renderer_capabilities_for_commit) {
+    impl().scheduler->FinishCommit();
+  } else {
+    TRACE_EVENT_INSTANT0(
+        "cc", "EarlyOut_StaleRendererCaps", TRACE_EVENT_SCOPE_THREAD);
+    if (impl().commit_completion_event) {
+      impl().commit_completion_event->Signal();
+      impl().commit_completion_event = NULL;
+      bool did_handle = true;
+      BeginMainFrameAbortedOnImplThread(did_handle);
+    }
+  }
 }
 
 void ThreadProxy::DidCommitAndDrawFrame() {
   DCHECK(IsMainThread());
   if (!layer_tree_host())
     return;
   layer_tree_host()->DidCommitAndDrawFrame();
 }
 
 void ThreadProxy::DidCompleteSwapBuffers() {
@@ skipping 317 matching lines @@
   impl().commit_to_activate_duration_history.InsertSample(
       base::TimeTicks::HighResNow() - impl().commit_complete_time);
 }
 
 void ThreadProxy::DidManageTiles() {
   DCHECK(IsImplThread());
   impl().scheduler->DidManageTiles();
 }
 
 }  // namespace cc