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 1146 matching lines @@
   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());
 
+  DidTryInitializeRendererOnImplThread(*success, offscreen_context_provider);
+
+  if (*success)
+    *capabilities = layer_tree_host_impl_->GetRendererCapabilities();
+
+  completion->Signal();
+}
+
+void ThreadProxy::DidTryInitializeRendererOnImplThread(
+    bool success,
+    scoped_refptr<ContextProvider> offscreen_context_provider) {
+  DCHECK(IsImplThread());
+
   if (offscreen_context_provider.get())
     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();

[danakj, 2013/06/06 14:49:31]

This stuff is meant to happen when the output surface changes, but it did not
change here. Should these stay in the InitializeOutputSurfaceOnImplThread()
method?

[boliu, 2013/06/06 17:39:25]

Also expanding the question to SetSwapBuffersCompleteSupported above, even
though that could actually change with a new renderer.

I'm on the fence for this one.

On one hand, caps can change and there is no way to plumb the new values to main
thread in time, so there is a weak and brittle contract with webview that these
caps cannot change. (This is even happens to be true for
using_swap_complete_callback since the in-process context does not support it)
In this case, we should move these back into InitializeOutputSurfaceOnImplThread
and actually DCHECK here that nothing has changed.

On the other hand, there is this overall effort (feeling?) that for impl-side
painting, nothing on main thread should need to know about caps. Nulling
PrioritizedResourceManager was one step towards that but it's not complete. In
this case, it's fine to change these in case something does change.

Practically, it really doesn't matter for webview at this point as we just want
to get hardware up without having apply a bunch of uncommitted patches. Maybe
we'll tweak things like max_frames_pending later when we are ready to do perf
optimizations.

So...maybe just keep these here for "not diverging from init path"? Thoughts?

[danakj, 2013/06/06 17:53:39]

I really like the idea of DCHECK () << "You cant do this and this is why". With
a TODO to re-examine this when "settings.impl_side_painting" is on everywhere.
(Use the setting name exactly so we find it with grep when we go to delete this
setting one day).

     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);
 
     scheduler_on_impl_thread_->DidCreateAndInitializeOutputSurface();

[danakj, 2013/06/06 14:49:31]

This is going to call frame_rate_controller_->DidAbortAllPendingFrames() as
well. Is that okay?

[boliu, 2013/06/06 17:39:25]

Moved this back to InitializeOutputSurfaceOnImplThread.

   } else if (offscreen_context_provider.get()) {
     offscreen_context_provider->VerifyContexts();
   }
-
-  completion->Signal();
 }
 
 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