cc::OutputSurfaceClient::InitializeForGL

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 "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "cc/base/thread.h"
@@ skipping 32 matching lines @@
     : Proxy(impl_thread.Pass()),
       animate_requested_(false),
       commit_requested_(false),
       commit_request_sent_to_impl_thread_(false),
       created_offscreen_context_provider_(false),
       layer_tree_host_(layer_tree_host),
       started_(false),
       textures_acquired_(true),
       in_composite_and_readback_(false),
       manage_tiles_pending_(false),
+      initializing_new_output_surface__on_impl_thread_(false),
       weak_factory_on_impl_thread_(this),
       weak_factory_(this),
       begin_frame_sent_to_main_thread_completion_event_on_impl_thread_(NULL),
       readback_request_on_impl_thread_(NULL),
       commit_completion_event_on_impl_thread_(NULL),
       completion_event_for_commit_held_on_tree_activation_(NULL),
       texture_acquisition_completion_event_on_impl_thread_(NULL),
       next_frame_is_newly_committed_frame_on_impl_thread_(false),
       throttle_frame_production_(
           layer_tree_host->settings().throttle_frame_production),
@@ skipping 1091 matching lines @@
   TRACE_EVENT0("cc", "ThreadProxy::InitializeOutputSurfaceOnImplThread");
   DCHECK(IsImplThread());
   DCHECK(IsMainThreadBlocked());
   DCHECK(success);
   DCHECK(capabilities);
 
   layer_tree_host_->DeleteContentsTexturesOnImplThread(
       layer_tree_host_impl_->resource_provider());
 
   *success = layer_tree_host_impl_->InitializeRenderer(output_surface.Pass());
+  if (*success)
+    *capabilities = layer_tree_host_impl_->GetRendererCapabilities();
+
+  initializing_new_output_surface__on_impl_thread_ = true;
+  DidUpdateCapabilitiesOnImplThread(*success, offscreen_context_provider);
+  initializing_new_output_surface__on_impl_thread_ = false;
+
+  completion->Signal();
+}
+
+void ThreadProxy::DidUpdateCapabilitiesOnImplThread(

[danakj, 2013/05/24 19:02:30]

nit: DidInitializeRendererOnImplThread? This function does a bit more than deal
with caps (sets up the RP for the offscreen context provider for instance).

+    bool success,
+    scoped_refptr<ContextProvider> offscreen_context_provider) {
+  DCHECK(IsImplThread());
 
   if (offscreen_context_provider)
     offscreen_context_provider->BindToCurrentThread();
 
-  if (*success) {
-    *capabilities = layer_tree_host_impl_->GetRendererCapabilities();
+  if (success) {
     scheduler_on_impl_thread_->SetSwapBuffersCompleteSupported(
-        capabilities->using_swap_complete_callback);
+        layer_tree_host_impl_->GetRendererCapabilities()
+            .using_swap_complete_callback);
 
     OutputSurface* output_surface_ptr = layer_tree_host_impl_->output_surface();
     DCHECK(output_surface_ptr);
     int max_frames_pending =
         output_surface_ptr->capabilities().max_frames_pending;
     if (max_frames_pending <= 0)
       max_frames_pending = FrameRateController::DEFAULT_MAX_FRAMES_PENDING;
     if (output_surface_ptr->capabilities().has_parent_compositor)
       max_frames_pending = 1;
 
     scheduler_on_impl_thread_->SetMaxFramesPending(max_frames_pending);
 
     if (layer_tree_host_impl_->resource_provider())
-      layer_tree_host_impl_->resource_provider()->
-          set_offscreen_context_provider(offscreen_context_provider);
+      layer_tree_host_impl_->resource_provider()
+          ->set_offscreen_context_provider(offscreen_context_provider);
 
-    scheduler_on_impl_thread_->DidCreateAndInitializeOutputSurface();
+    if (initializing_new_output_surface__on_impl_thread_) {
+      scheduler_on_impl_thread_->DidCreateAndInitializeOutputSurface();
+    } else {
+      Proxy::MainThread()->PostTask(base::Bind(
+          &ThreadProxy::DidUpdateCapabilities, main_thread_weak_ptr_));
+    }
   } else if (offscreen_context_provider) {
     offscreen_context_provider->VerifyContexts();
   }
+}
 
-  completion->Signal();
+void ThreadProxy::DidUpdateCapabilities() {

[danakj, 2013/05/24 19:02:30]

This needs to take and do something with the caps, to have them show up changed
on the main thread. But this is a race for sure. We could be in the middle of
BeginFrame when this is posted, and then the impl thread has a new renderer with
new caps, but the frame is generated with the old caps.

A silver lining may be: http://crbug.com/234233 may help make the dependencies
on caps on the main thread more clear.. if there is only picture layers on the
main thread then, again, maybe we're okay I think as they aren't using settings
derived from caps. If there's a HUD layer, it uses the caps' max texture size.
If the GL mode has a smaller size than the software mode did (likely) and you're
on a big enough display, you get something bad until the next commit.

A race by design seems problematic to me :/ I'm not sure what the solution here
is though, other than allowing this code path to block the main thread somehow.
Or, block here until BeginFrame is done, then block future BeginFrame until this
initialization is done, or something. And maybe that lends itself to allowing
more code reuse for the non-synchronous case too?

Maybe you or James will have some better insight or decide this raciness isn't a
big deal.

+  DCHECK(IsMainThread());
+  if (layer_tree_host_) {
+    layer_tree_host_->DidUpdateCapabilities();
+  }
 }
 
 void ThreadProxy::FinishGLOnImplThread(CompletionEvent* completion) {
   TRACE_EVENT0("cc", "ThreadProxy::FinishGLOnImplThread");
   DCHECK(IsImplThread());
   if (layer_tree_host_impl_->resource_provider())
     layer_tree_host_impl_->resource_provider()->Finish();
   completion->Signal();
 }
 
@@ skipping 180 matching lines @@
       !layer_tree_host_impl_->pending_tree()) {
     TRACE_EVENT_INSTANT0("cc", "ReleaseCommitbyActivation",
                          TRACE_EVENT_SCOPE_THREAD);
     DCHECK(layer_tree_host_impl_->settings().impl_side_painting);
     completion_event_for_commit_held_on_tree_activation_->Signal();
     completion_event_for_commit_held_on_tree_activation_ = NULL;
   }
 }
 
 }  // namespace cc