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 320 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(
         "cc", "EarlyOut_NoLayerTree", TRACE_EVENT_SCOPE_THREAD);
     completion->Signal();
     return;
   }
 

[danakj, 2014/02/14 19:38:50]

I think if we're going to abort the commit we need to do it before we start
setting state on the impl side. Otherwise we aborting half way thru a commit and
we are going to put ourselves into some very weird situations. Doing it after
we've done anything in this method sounds scary to me. WDYT?

[boliu, 2014/02/14 19:48:53]

Unfortunately putting the check here is not going to work :(

Commit is not synchronous on impl thread, so if RendererCap changes in the
middle of a commit (ie after StartCommitOnImplThread but before
ScheduledActionCommit), then the commit will incorrectly go through.

I don't really have a solution other than being really careful with the state
here.

[danakj, 2014/02/14 19:53:25]

Is there still a good reason to be not synchronous with impl side painting? We
dont have to upload textures here anymore since we do that in the pending tree.
So maybe we could change this?
I think I'd prefer we commit stuff that doesn't match the renderer and degrade
that gracefully (max texture too large? can't draw it sorry) than commit half of
the data and leave the impl side in a weird state. WDYT?

[boliu, 2014/02/14 20:06:14]

I was wondering about that. So we can skip this whole ResourceUpdateController
thing for impl-side painting? Then I can try make that change and see if
anything breaks.
Actually I don't know anything that will break in practice. Webview did launch
with never updating the renderer caps from SoftwareRenderer, but then again, we
didn't have accelerated canvas.

Let me try removing ResourceUpdateController for impl-side painting first. If
that blows up in my face, then I can cross my fingers and hope webview will be
ok with bad render caps for one commit, and change the cancel commit to set
commit instead.

   if (offscreen_context_provider.get())
     offscreen_context_provider->BindToCurrentThread();
   impl().layer_tree_host_impl->SetOffscreenContextProvider(
       offscreen_context_provider);
 
   if (impl().contents_texture_manager) {
     DCHECK_EQ(impl().contents_texture_manager,
               blocked_main().contents_texture_manager());
   } else {
     // Cache this pointer that was created on the main thread side to avoid a
     // data race between creating it and using it on the compositor thread.
     impl().contents_texture_manager = blocked_main().contents_texture_manager();
   }
 
   if (impl().contents_texture_manager) {
     if (impl().contents_texture_manager->LinkedEvictedBackingsExist()) {
       // Clear any uploads we were making to textures linked to evicted
       // 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 =

[enne (OOO), 2014/02/14 20:21:48]

I don't quite follow what sorts of caps aren't supported by the commit, or what
problems come from the main thread preparing a frame using the wrong set of
caps.  What problems occur when you don't abort the commit?  In general, I agree
with danakj that it'd be better to just fail gracefully if that's possible.

If there are problems, what happens if the caps change between commit and
activation? Isn't the successfully committed pending tree also equally wrong?

[boliu, 2014/02/14 20:45:42]

I thought it might be a problem. But I don't know any in practice.
Both pending and active trees are on impl side, and we already clean them up
synchronously. All this dance is just to cover the edge case that a commit is
already pending when render caps change.

+      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 316 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