Use 3D graphics context shareResources flag to decide whether a context should share resources.

content/renderer/gpu/webgraphicscontext3d_command_buffer_impl.cc

 // Copyright (c) 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.
 
 #if defined(ENABLE_GPU)
 
 #include "content/renderer/gpu/webgraphicscontext3d_command_buffer_impl.h"
 
 #include "gpu/GLES2/gl2.h"
 #ifndef GL_GLEXT_PROTOTYPES
@@ skipping 15 matching lines @@
 #include "content/renderer/render_thread.h"
 #include "content/renderer/render_view.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "gpu/command_buffer/common/constants.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 #include "webkit/glue/gl_bindings_skia_cmd_buffer.h"
 
 static base::LazyInstance<std::set<WebGraphicsContext3DCommandBufferImpl*> >
-    g_all_contexts(base::LINKER_INITIALIZED);
+    g_all_shared_contexts(base::LINKER_INITIALIZED);
 
 WebGraphicsContext3DCommandBufferImpl::WebGraphicsContext3DCommandBufferImpl()
     : context_(NULL),
       gl_(NULL),
       web_view_(NULL),
 #if defined(OS_MACOSX)
       plugin_handle_(NULL),
 #endif  // defined(OS_MACOSX)
       context_lost_callback_(0),
       context_lost_reason_(GL_NO_ERROR),
       swapbuffers_complete_callback_(0),
       cached_width_(0),
       cached_height_(0),
       bound_fbo_(0) {
 }
 
 WebGraphicsContext3DCommandBufferImpl::
     ~WebGraphicsContext3DCommandBufferImpl() {
-  g_all_contexts.Pointer()->erase(this);
+  g_all_shared_contexts.Pointer()->erase(this);
   delete context_;
 }
 
 // This string should only be passed for WebGL contexts. Nothing ELSE!!!
 // Compositor contexts, Canvas2D contexts, Pepper Contexts, nor any other use of
 // a context should not pass this string.
 static const char* kWebGLPreferredGLExtensions =
     "GL_OES_packed_depth_stencil "
     "GL_OES_depth24 "
     "GL_CHROMIUM_webglsl";
@@ skipping 20 matching lines @@
   const int depth_size = attributes.depth ? 24 : 0;
   const int stencil_size = attributes.stencil ? 8 : 0;
   const int samples = attributes.antialias ? 4 : 0;
   const int sample_buffers = attributes.antialias ? 1 : 0;
   const int32 attribs[] = {
     RendererGLContext::ALPHA_SIZE, alpha_size,
     RendererGLContext::DEPTH_SIZE, depth_size,
     RendererGLContext::STENCIL_SIZE, stencil_size,
     RendererGLContext::SAMPLES, samples,
     RendererGLContext::SAMPLE_BUFFERS, sample_buffers,
+    RendererGLContext::SHARE_RESOURCES, attributes.shareResources ? 1 : 0,
+    RendererGLContext::BIND_GENERATES_RESOURCES, 0,
     RendererGLContext::NONE,
   };
 
   const char* preferred_extensions = attributes.noExtensions ?
       kWebGLPreferredGLExtensions : "*";
 
   const GPUInfo& gpu_info = host->gpu_info();
   UMA_HISTOGRAM_ENUMERATION(
       "GPU.WebGraphicsContext3D_Init_CanLoseContext",
       attributes.canRecoverFromContextLoss * 2 + gpu_info.can_lose_context,
       4);
   if (attributes.canRecoverFromContextLoss == false) {
     if (gpu_info.can_lose_context)
       return false;
   }
 
   GURL active_url;
   if (web_view && web_view->mainFrame())
     active_url = GURL(web_view->mainFrame()->document().url());
 
-  // HACK: Assume this is a WebGL context by looking for the noExtensions
-  // attribute. WebGL contexts must not go in the share group because they
-  // rely on destruction of the context to clean up owned resources. Putting
-  // them in a share group would prevent this from happening.
   RendererGLContext* share_group = NULL;
-  if (!attributes.noExtensions) {
-    share_group = g_all_contexts.Pointer()->empty() ?
-        NULL : (*g_all_contexts.Pointer()->begin())->context_;
+  if (attributes.shareResources) {
+    share_group = g_all_shared_contexts.Pointer()->empty() ?
+        NULL : (*g_all_shared_contexts.Pointer()->begin())->context_;
   }
 
   if (render_directly_to_web_view) {
     RenderView* renderview = RenderView::FromWebView(web_view);
     if (!renderview)
       return false;
 
     web_view_ = web_view;
     context_ = RendererGLContext::CreateViewContext(
         host,
         renderview->routing_id(),
-        !attributes.noExtensions,
         share_group,
         preferred_extensions,
         attribs,
         active_url);
     if (context_) {
       context_->SetSwapBuffersCallback(
           NewCallback(this,
               &WebGraphicsContext3DCommandBufferImpl::OnSwapBuffersComplete));
     }
   } else {
     context_ = RendererGLContext::CreateOffscreenContext(
         host,
         gfx::Size(1, 1),
-        !attributes.noExtensions,
         share_group,
         preferred_extensions,
         attribs,
         active_url);
     web_view_ = NULL;
   }
   if (!context_)
     return false;
 
   gl_ = context_->GetImplementation();
@@ skipping 17 matching lines @@
     getIntegerv(GL_DEPTH_BITS, &depth_bits);
     attributes_.depth = depth_bits > 0;
     GLint stencil_bits = 0;
     getIntegerv(GL_STENCIL_BITS, &stencil_bits);
     attributes_.stencil = stencil_bits > 0;
     GLint samples = 0;
     getIntegerv(GL_SAMPLES, &samples);
     attributes_.antialias = samples > 0;
   }
 
-  if (!attributes.noExtensions)
-    g_all_contexts.Pointer()->insert(this);
+  if (attributes.shareResources)
+    g_all_shared_contexts.Pointer()->insert(this);
 
   return true;
 }
 
 bool WebGraphicsContext3DCommandBufferImpl::makeContextCurrent() {
   return RendererGLContext::MakeCurrent(context_);
 }
 
 int WebGraphicsContext3DCommandBufferImpl::width() {
   return cached_width_;
@@ skipping 859 matching lines @@
     context_lost_callback_->onContextLost();
   }
 
   RenderView* renderview =
       web_view_ ? RenderView::FromWebView(web_view_) : NULL;
   if (renderview)
     renderview->OnViewContextSwapBuffersAborted();
 }
 
 #endif  // defined(ENABLE_GPU)