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

content/renderer/gpu/renderer_gl_context.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.
 
 #include "content/renderer/gpu/renderer_gl_context.h"
 
 #include "base/debug/trace_event.h"
 #include "base/lazy_instance.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 64 matching lines @@
 
 }  // namespace anonymous
 
 RendererGLContext::~RendererGLContext() {
   Destroy();
 }
 
 RendererGLContext* RendererGLContext::CreateViewContext(
     GpuChannelHost* channel,
     int render_view_id,
-    bool share_resources,
     RendererGLContext* share_group,
     const char* allowed_extensions,
     const int32* attrib_list,
     const GURL& active_url) {
 #if defined(ENABLE_GPU)
   scoped_ptr<RendererGLContext> context(new RendererGLContext(channel));
   if (!context->Initialize(
       true,
       render_view_id,
       gfx::Size(),
-      share_resources,
-      false,
       share_group,
       allowed_extensions,
       attrib_list,
       active_url))
     return NULL;
 
   return context.release();
 #else
   return NULL;
 #endif
 }
 
 #if defined(OS_MACOSX)
 void RendererGLContext::ResizeOnscreen(const gfx::Size& size) {
   DCHECK(size.width() > 0 && size.height() > 0);
   size_ = size;
   command_buffer_->SetWindowSize(size);
 }
 #endif
 
 RendererGLContext* RendererGLContext::CreateOffscreenContext(
     GpuChannelHost* channel,
     const gfx::Size& size,
-    bool share_resources,
     RendererGLContext* share_group,
     const char* allowed_extensions,
     const int32* attrib_list,
     const GURL& active_url) {
 #if defined(ENABLE_GPU)
   scoped_ptr<RendererGLContext> context(new RendererGLContext(channel));
   if (!context->Initialize(
       false,
       0,
       size,
-      share_resources,
-      false,
       share_group,
       allowed_extensions,
       attrib_list,
       active_url))
     return NULL;
 
   return context.release();
 #else
   return NULL;
 #endif
@@ skipping 156 matching lines @@
       transfer_buffer_id_(-1),
       gles2_implementation_(NULL),
       last_error_(SUCCESS),
       frame_number_(0) {
   DCHECK(channel);
 }
 
 bool RendererGLContext::Initialize(bool onscreen,
                                    int render_view_id,
                                    const gfx::Size& size,
-                                   bool share_resources,
-                                   bool bind_generates_resource,
                                    RendererGLContext* share_group,
                                    const char* allowed_extensions,
                                    const int32* attrib_list,
                                    const GURL& active_url) {
   DCHECK(size.width() >= 0 && size.height() >= 0);
   TRACE_EVENT2("gpu", "RendererGLContext::Initialize",
                    "on_screen", onscreen, "num_pixels", size.GetArea());
 
   if (channel_->state() != GpuChannelHost::kConnected)
     return false;
 
   // Ensure the gles2 library is initialized first in a thread safe way.
   g_gles2_initializer.Get();
 
+  bool share_resources = true;
+  bool bind_generates_resources = true;

[piman, 2011/08/26 23:18:57]

The default was false before (see callers). Is it the right thing to do to
change it to true ?
Then again, the fact that it was false seems wrong for Pepper3D (if my
understanding is correct, i.e. true is the spec behavior), so maybe true is
better anyway.
In any case, is the change deliberate ?

[apatrick_chromium, 2011/08/26 23:40:01]

I was deliberate. I want the default semantics to be the same as GLES2.

   std::vector<int32> attribs;
   while (attrib_list) {

[apatrick_chromium, 2011/08/26 19:21:13]

If attrib_list is null then it want get beyond the while condition.

     int32 attrib = *attrib_list++;
     switch (attrib) {
       // Known attributes
       case ALPHA_SIZE:
       case BLUE_SIZE:
       case GREEN_SIZE:
       case RED_SIZE:
       case DEPTH_SIZE:
       case STENCIL_SIZE:
       case SAMPLES:
       case SAMPLE_BUFFERS:
         attribs.push_back(attrib);
         attribs.push_back(*attrib_list++);

[jbates, 2011/08/26 19:04:35]

I know this was already here, but should this check for null *attrib_list before
incrementing in case the caller provided bad arguments?

         break;
+      case SHARE_RESOURCES:
+        share_resources = !!(*attrib_list++);

[jbates, 2011/08/26 19:04:35]

(same here)

+        break;
+      case BIND_GENERATES_RESOURCES:
+        bind_generates_resources = !!(*attrib_list++);

[jbates, 2011/08/26 19:04:35]

(same here)

+        break;
       case NONE:
         attribs.push_back(attrib);
         attrib_list = NULL;
         break;
       default:
         last_error_ = BAD_ATTRIBUTE;
         attribs.push_back(NONE);
         attrib_list = NULL;
         break;
     }
@@ skipping 65 matching lines @@
     return false;
   }
 
   // Create the object exposing the OpenGL API.
   gles2_implementation_ = new gpu::gles2::GLES2Implementation(
       gles2_helper_,
       transfer_buffer.size,
       transfer_buffer.ptr,
       transfer_buffer_id_,
       share_resources,
-      bind_generates_resource);
+      bind_generates_resources);
 
   size_ = size;
 
   return true;
 }
 
 void RendererGLContext::Destroy() {
   TRACE_EVENT0("gpu", "RendererGLContext::Destroy");
   SetParent(NULL);
 
@@ skipping 33 matching lines @@
 void RendererGLContext::OnContextLost() {
   if (context_lost_callback_.get()) {
     RendererGLContext::ContextLostReason reason = kUnknown;
     if (command_buffer_) {
       reason = ConvertReason(
           command_buffer_->GetLastState().context_lost_reason);
     }
     context_lost_callback_->Run(reason);
   }
 }