Make async waiter explicit MojoGLES2CreateContext param

mojo/gles2/gles2_support_impl.cc

 // Copyright 2014 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 "mojo/gles2/gles2_support_impl.h"
 
-#include "base/lazy_instance.h"
+#include "base/threading/thread_local.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "mojo/gles2/gles2_context.h"
 #include "mojo/public/gles2/gles2_interface.h"
 #include "mojo/public/gles2/gles2_private.h"
 
 namespace mojo {
 namespace gles2 {
 
 namespace {
 
@@ skipping 11 matching lines @@
     return gpu_interface_->Function ARGUMENTS;                     \
   }
 #include "mojo/public/c/gles2/gles2_call_visitor_autogen.h"
 #undef VISIT_GL_CALL
 
  private:
   gpu::gles2::GLES2Interface* gpu_interface_;
   DISALLOW_COPY_AND_ASSIGN(GLES2ImplForCommandBuffer);
 };
 
-base::LazyInstance<GLES2ImplForCommandBuffer> g_gles2_interface =
-    LAZY_INSTANCE_INITIALIZER;
+base::ThreadLocalPointer<GLES2ImplForCommandBuffer> g_gles2_interface;

[jamesr, 2014/07/31 01:36:00]

this change isn't strictly speaking part of the same patch but it's pretty
closely related to using this from multiple threads. I can split it out if you'd
prefer

[piman, 2014/07/31 01:53:46]

base::LazyInstance<base::ThreadLocalPointer> to avoid adding a static
initializer?
(either way wrt this CL or another).

 
 }  // anonymous namespace
 
-GLES2SupportImpl::GLES2SupportImpl() : async_waiter_(NULL) {}
+GLES2SupportImpl::GLES2SupportImpl() {}
 GLES2SupportImpl::~GLES2SupportImpl() {}
 
 // static
 void GLES2SupportImpl::Init() { GLES2Support::Init(new GLES2SupportImpl()); }
 
-void GLES2SupportImpl::Initialize(const MojoAsyncWaiter* async_waiter) {
-  DCHECK(!async_waiter_);
-  DCHECK(async_waiter);
-  async_waiter_ = async_waiter;
-}
-
-void GLES2SupportImpl::Terminate() {
-  DCHECK(async_waiter_);
-  async_waiter_ = NULL;
-}
-
 MojoGLES2Context GLES2SupportImpl::CreateContext(
     MessagePipeHandle handle,
     MojoGLES2ContextLost lost_callback,
-    void* closure) {
+    void* closure,
+    const MojoAsyncWaiter* async_waiter) {
   ScopedMessagePipeHandle scoped_handle(handle);
-  scoped_ptr<GLES2Context> client(new GLES2Context(async_waiter_,
+  scoped_ptr<GLES2Context> client(new GLES2Context(async_waiter,
                                                    scoped_handle.Pass(),
                                                    lost_callback,
                                                    closure));
   if (!client->Initialize())
     client.reset();
   return client.release();
 }
 
 void GLES2SupportImpl::DestroyContext(MojoGLES2Context context) {
+  delete g_gles2_interface.Get();

[jamesr, 2014/07/31 01:36:00]

this is maybe not quite right - I'm assuming that a Destroy() call will always
be made from the thread the context is current on

[piman, 2014/07/31 01:53:46]

mmh, I don't think we should impose that restriction, I think it can make
porting code harder (code typically MakeCurrent(NULL, NULL) before destroying
the context, things like GLX have a refcount on the context that's held by the
current thread.)
Either way, we need to reset g_gles2_interface, we don't want to leave a stale
pointer here.

We could maybe have GLES2Context own (be?) the GLES2ImplForCommandBuffer?
I forgot how this interacts with erg's patch.

   delete static_cast<GLES2Context*>(context);
 }
 
 void GLES2SupportImpl::MakeCurrent(MojoGLES2Context context) {
   gpu::gles2::GLES2Interface* interface = NULL;
   if (context) {
     GLES2Context* client = static_cast<GLES2Context*>(context);
     interface = client->interface();
     DCHECK(interface);
   }
-  g_gles2_interface.Get().set_gpu_interface(interface);
+  if (!g_gles2_interface.Get())
+    g_gles2_interface.Set(new GLES2ImplForCommandBuffer);
+  g_gles2_interface.Get()->set_gpu_interface(interface);
 }
 
 void GLES2SupportImpl::SwapBuffers() {
-  g_gles2_interface.Get().gpu_interface()->SwapBuffers();
+  g_gles2_interface.Get()->gpu_interface()->SwapBuffers();
 }
 
 void* GLES2SupportImpl::GetGLES2Interface(MojoGLES2Context context) {
   return static_cast<GLES2Context*>(context)->interface();
 }
 
 void* GLES2SupportImpl::GetContextSupport(MojoGLES2Context context) {
   return static_cast<GLES2Context*>(context)->context_support();
 }
 
 GLES2Interface* GLES2SupportImpl::GetGLES2InterfaceForCurrentContext() {
-  return &g_gles2_interface.Get();
+  return g_gles2_interface.Get();
 }
 
 }  // namespace gles2
 }  // namespace mojo