Add option to use GLContextVirtual in WGC3DIPCBI

webkit/gpu/webgraphicscontext3d_in_process_command_buffer_impl.cc

 // Copyright (c) 2012 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 "webkit/gpu/webgraphicscontext3d_in_process_command_buffer_impl.h"
 
 #include <GLES2/gl2.h>
 #ifndef GL_GLEXT_PROTOTYPES
 #define GL_GLEXT_PROTOTYPES 1
 #endif
@@ skipping 13 matching lines @@
 #include "base/memory/singleton.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/synchronization/lock.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "gpu/command_buffer/client/gles2_lib.h"
 #include "gpu/command_buffer/client/transfer_buffer.h"
 #include "gpu/command_buffer/common/constants.h"
 #include "gpu/command_buffer/service/command_buffer_service.h"
 #include "gpu/command_buffer/service/context_group.h"
+#include "gpu/command_buffer/service/gl_context_virtual.h"
+#include "gpu/command_buffer/service/gpu_scheduler.h"
 #include "gpu/command_buffer/service/transfer_buffer_manager.h"
-#include "gpu/command_buffer/service/gpu_scheduler.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_share_group.h"
 #include "ui/gl/gl_surface.h"
 #include "webkit/gpu/gl_bindings_skia_cmd_buffer.h"
 
 using gpu::Buffer;
 using gpu::CommandBuffer;
 using gpu::CommandBufferService;
 using gpu::gles2::GLES2CmdHelper;
 using gpu::gles2::GLES2Implementation;
@@ skipping 188 matching lines @@
 // thread. In layout tests, any thread could call this function. GLES2Decoder,
 // and in particular the GL implementations behind it, are not generally
 // threadsafe, so we guard entry points with a mutex.
 static base::LazyInstance<base::Lock> g_decoder_lock =
     LAZY_INSTANCE_INITIALIZER;
 
 static base::LazyInstance<
     std::set<GLInProcessContext*> >
         g_all_shared_contexts = LAZY_INSTANCE_INITIALIZER;
 
+static bool g_use_virtualized_gl_context = false;
+
 namespace {
 
 // Also calls DetachFromThread on all GLES2Decoders before the lock is released
 // to maintain the invariant that all decoders are unbounded while the lock is
 // not held. This is to workaround DumpRenderTree uses WGC3DIPCBI with shared
 // resources on different threads.
 class AutoLockAndDecoderDetachThread {
  public:
   AutoLockAndDecoderDetachThread(base::Lock& lock,
                                  const std::set<GLInProcessContext*>& contexts);
@@ skipping 217 matching lines @@
       surface_ = gfx::GLSurface::CreateOffscreenGLSurface(false, size);
     else
       surface_ = gfx::GLSurface::CreateViewGLSurface(false, window);
 
     if (!surface_.get()) {
       LOG(ERROR) << "Could not create GLSurface.";
       Destroy();
       return false;
     }
 
-    context_ = gfx::GLContext::CreateGLContext(share_group.get(),
-                                               surface_.get(),
-                                               gpu_preference);
+    if (g_use_virtualized_gl_context) {
+      context_ = share_group->GetSharedContext();
+      if (!context_) {
+        context_ = gfx::GLContext::CreateGLContext(share_group.get(),
+                                                   surface_.get(),
+                                                   gpu_preference);
+        share_group->SetSharedContext(context_);
+      }
+
+      context_ = new ::gpu::GLContextVirtual(share_group.get(),
+                                             context_,
+                                             decoder_->AsWeakPtr());
+      if (context_->Initialize(surface_, gpu_preference)) {
+        VLOG(1) << "Created virtual GL context.";
+      } else {
+        context_ = NULL;
+      }
+    } else {
+      context_ = gfx::GLContext::CreateGLContext(share_group.get(),
+                                                 surface_.get(),
+                                                 gpu_preference);
+    }
+
     if (!context_.get()) {
       LOG(ERROR) << "Could not create GLContext.";
       Destroy();
       return false;
     }
 
     if (!context_->MakeCurrent(surface_.get())) {
       LOG(ERROR) << "Could not make context current.";
       Destroy();
       return false;
@@ skipping 82 matching lines @@
   }
 
   g_all_shared_contexts.Pointer()->erase(this);
 }
 
 void GLInProcessContext::OnContextLost() {
   if (!context_lost_callback_.is_null())
     context_lost_callback_.Run();
 }
 
+// static
+void
+WebGraphicsContext3DInProcessCommandBufferImpl::EnableVirtualizedContext() {
+#if !defined(NDEBUG)
+  {
+    AutoLockAndDecoderDetachThread lock(g_decoder_lock.Get(),
+                                        g_all_shared_contexts.Get());
+    DCHECK(g_all_shared_contexts.Get().empty());
+  }
+#endif  // !defined(NDEBUG)
+  g_use_virtualized_gl_context = true;
+}
 
 // static
 WebGraphicsContext3DInProcessCommandBufferImpl*
 WebGraphicsContext3DInProcessCommandBufferImpl::CreateViewContext(
     const WebKit::WebGraphicsContext3D::Attributes& attributes,
     gfx::AcceleratedWidget window) {
   return new WebGraphicsContext3DInProcessCommandBufferImpl(
       attributes, false, window);
 }
 
@@ skipping 1166 matching lines @@
 
 DELEGATE_TO_GL_9(asyncTexSubImage2DCHROMIUM, AsyncTexSubImage2DCHROMIUM,
     WGC3Denum, WGC3Dint, WGC3Dint, WGC3Dint, WGC3Dsizei, WGC3Dsizei,
     WGC3Denum, WGC3Denum, const void*)
 
 DELEGATE_TO_GL_1(waitAsyncTexImage2DCHROMIUM, WaitAsyncTexImage2DCHROMIUM,
     WGC3Denum)
 
 }  // namespace gpu
 }  // namespace webkit