cc: Update Main RendererCapabilities on DeferredInitialize

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 129 matching lines @@
         layer_tree_host_impl_->resource_provider());
   }
 
   bool initialized;
   {
     DebugScopedSetImplThread impl(this);
 
     DCHECK(output_surface);
     initialized = layer_tree_host_impl_->InitializeRenderer(
         output_surface.Pass());
-    if (initialized) {
-      renderer_capabilities_for_main_thread_ =
-          layer_tree_host_impl_->GetRendererCapabilities()
-              .MainThreadCapabilities();
-    } else if (offscreen_context_provider.get()) {
+    if (!initialized && offscreen_context_provider.get()) {
       offscreen_context_provider->VerifyContexts();
       offscreen_context_provider = NULL;
     }
 
     layer_tree_host_impl_->SetOffscreenContextProvider(
         offscreen_context_provider);
   }
 
   OnOutputSurfaceInitializeAttempted(initialized);
 }
 
 void SingleThreadProxy::OnOutputSurfaceInitializeAttempted(bool success) {

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

The "main vs impl" side stuff in here is kinda messed up. It should match the
thread proxy a bit more. I think you were right about the 
UpdateRendererCapabilitiesOnImplThread() method in your original question about
NOTREACHED(). This method is on the main thread side so it won't call an
OnImplThread method directly.

Two ways to solve this:

1) Pass the caps in to this method here, collecting them in the scoped impl code
above (line ~155). Call the LTH directly from this method instead of calling
UpdateRCapsOnImplThread().

or

2) DebugScopedImpl yourself here to call UpdateRCapsOnImplThread(). Then inside
that method DebugScopedMain yourself back to the main side to call into the LTH.


1 seems a bit simpler if you don't care about supporting the
UpdateRCapsOnImplThread() method here, which I think you don't. So maybe just a
NOTREACHED in there is best afterall.

[boliu, 2014/02/14 22:03:08]

1) it is. Done

   LayerTreeHost::CreateResult result =
       layer_tree_host_->OnCreateAndInitializeOutputSurfaceAttempted(success);
+  if (success) {

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

nit: no {}

[boliu, 2014/02/14 22:03:08]

Done.

+    UpdateRendererCapabilitiesOnImplThread();
+  }
+
   if (result == LayerTreeHost::CreateFailedButTryAgain) {
     // Force another recreation attempt to happen by requesting another commit.
     SetNeedsCommit();
   }
 }
 
 const RendererCapabilities& SingleThreadProxy::GetRendererCapabilities() const {
   DCHECK(Proxy::IsMainThread());
   DCHECK(!layer_tree_host_->output_surface_lost());
   return renderer_capabilities_for_main_thread_;
@@ skipping 184 matching lines @@
     return;
 
   layer_tree_host_impl_->SendManagedMemoryStats(
       contents_texture_manager->MemoryVisibleBytes(),
       contents_texture_manager->MemoryVisibleAndNearbyBytes(),
       contents_texture_manager->MemoryUseBytes());
 }
 
 bool SingleThreadProxy::IsInsideDraw() { return inside_draw_; }
 
+void SingleThreadProxy::UpdateRendererCapabilitiesOnImplThread() {
+  renderer_capabilities_for_main_thread_ =
+      layer_tree_host_impl_->GetRendererCapabilities().MainThreadCapabilities();
+  layer_tree_host_->RendererCapabilitiesChanged();
+}
+
 void SingleThreadProxy::DidLoseOutputSurfaceOnImplThread() {
   TRACE_EVENT0("cc", "SingleThreadProxy::DidLoseOutputSurfaceOnImplThread");
   // Cause a commit so we can notice the lost context.
   SetNeedsCommitOnImplThread();
   client_->DidAbortSwapBuffers();
 }
 
 void SingleThreadProxy::DidSwapBuffersOnImplThread() {
   client_->DidPostSwapBuffers();
 }
@@ skipping 181 matching lines @@
 void SingleThreadProxy::DidSwapFrame() {
   if (next_frame_is_newly_committed_frame_) {
     next_frame_is_newly_committed_frame_ = false;
     layer_tree_host_->DidCommitAndDrawFrame();
   }
 }
 
 bool SingleThreadProxy::CommitPendingForTesting() { return false; }
 
 }  // namespace cc