Windows now uses the TLS API instead of __declspec(thread) for client side co...

gpu/pgl/pgl.cc

 // Copyright (c) 2010 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 <build/build_config.h>
+
 #include "gpu/command_buffer/client/gles2_cmd_helper.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "gpu/command_buffer/client/gles2_lib.h"
+#include "gpu/command_buffer/common/thread_local.h"
 #include "gpu/pgl/command_buffer_pepper.h"
 #include "gpu/pgl/pgl.h"
 
 namespace {
 const int32 kTransferBufferSize = 512 * 1024;
 
 class PGLContextImpl {
  public:
   PGLContextImpl(NPP npp,
               NPDevice* device,
@@ skipping 18 matching lines @@
 
   NPP npp_;
   NPDevice* device_;
   NPDeviceContext3D* device_context_;
   CommandBufferPepper* command_buffer_;
   gpu::gles2::GLES2CmdHelper* gles2_helper_;
   int32 transfer_buffer_id_;
   gpu::gles2::GLES2Implementation* gles2_implementation_;
 };
 
-THREAD_LOCAL PGLContextImpl* g_current_pgl_context;
+gpu::ThreadLocalKey g_pgl_context_key;
 
 PGLContextImpl::PGLContextImpl(NPP npp,
                                NPDevice* device,
                                NPDeviceContext3D* device_context)
     : npp_(npp),
       device_(device),
       device_context_(device_context),
       command_buffer_(NULL),
       gles2_helper_(NULL),
       transfer_buffer_id_(0),
@@ skipping 39 matching lines @@
   }
 
   delete gles2_helper_;
   gles2_helper_ = NULL;
 
   delete command_buffer_;
   command_buffer_ = NULL;
 }
 
 bool PGLContextImpl::MakeCurrent(PGLContextImpl* pgl_context) {
-  g_current_pgl_context = pgl_context;
+  if (!g_pgl_context_key)
+    return false;
+
+  gpu::ThreadLocalSetValue(g_pgl_context_key, pgl_context);
   if (pgl_context)
     gles2::SetGLContext(pgl_context->gles2_implementation_);
   else
     gles2::SetGLContext(NULL);
 
   return true;
 }
 
 bool PGLContextImpl::SwapBuffers() {
   gles2_implementation_->SwapBuffers();
   return true;
 }
 }  // namespace anonymous
 
 extern "C" {
 
+PGLBoolean pglInitialize() {
+  if (g_pgl_context_key)
+    return true;
+
+  gles2::Initialize();
+  g_pgl_context_key = gpu::ThreadLocalAlloc();
+  return true;
+}
+
+PGLBoolean pglTerminate() {
+  if (!g_pgl_context_key)
+    return true;
+
+  gpu::ThreadLocalFree(g_pgl_context_key);
+  gles2::Terminate();
+  return true;
+}
+
 PGLContext pglCreateContext(NPP npp,

[rvargas (doing something else), 2010/01/27 19:45:18]

Out of curiosity, what's the reason for having this code not following our
coding style?. I mean, everything else looks like our style, but this naming
style is definitely foreign.

[apatrick_chromium, 2010/01/27 19:55:10]

It's using this style:
http://www.khronos.org/registry/egl/api/EGL/egl.h

This is the Pepper equivalent of the standard EGL API. Every version of OpenGL
has some version of this API. Compare also to Apple's AGL and Microsoft's WGL,
which use a similar style.

                             NPDevice* device,
                             NPDeviceContext3D* device_context) {
+  if (!g_pgl_context_key)
+    return NULL;
+
   PGLContextImpl* pgl_context = new PGLContextImpl(
       npp, device, device_context);
   if (pgl_context->Initialize(kTransferBufferSize)) {
     return pgl_context;
   }
 
   delete pgl_context;
   return NULL;
 }
 
 PGLBoolean pglMakeCurrent(PGLContext pgl_context) {
   return PGLContextImpl::MakeCurrent(static_cast<PGLContextImpl*>(pgl_context));
 }
 
 PGLContext pglGetCurrentContext(void) {
-  return g_current_pgl_context;
+  if (!g_pgl_context_key)
+    return NULL;
+
+  return static_cast<PGLContext>(gpu::ThreadLocalGetValue(g_pgl_context_key));
 }
 
 PGLBoolean pglSwapBuffers(void) {
-  if (!g_current_pgl_context)
+  PGLContextImpl* context = static_cast<PGLContextImpl*>(
+      pglGetCurrentContext());
+  if (!context)
     return false;
 
-  return g_current_pgl_context->SwapBuffers();
+  return context->SwapBuffers();
 }
 
 PGLBoolean pglDestroyContext(PGLContext pgl_context) {
+  if (!g_pgl_context_key)
+    return NULL;
+
   if (!pgl_context)
     return false;
 
+  if (pgl_context == pglGetCurrentContext())
+    pglMakeCurrent(NULL);
+
   delete static_cast<PGLContextImpl*>(pgl_context);
   return true;
 }
 
 }  // extern "C"