Don't use a global share group for the passthrough command buffer contexts.

gpu/ipc/service/gpu_command_buffer_stub.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 "gpu/ipc/service/gpu_command_buffer_stub.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 512 matching lines @@
 
   bool have_context = false;
   if (decoder_ && decoder_->GetGLContext()) {
     // Try to make the context current regardless of whether it was lost, so we
     // don't leak resources.
     have_context = decoder_->GetGLContext()->MakeCurrent(surface_.get());
   }
   for (auto& observer : destruction_observers_)
     observer.OnWillDestroyStub();
 
+  share_group_ = nullptr;
+
   // Remove this after crbug.com/248395 is sorted out.
   // Destroy the surface before the context, some surface destructors make GL
   // calls.
   surface_ = nullptr;
 
   if (decoder_) {
     decoder_->Destroy(have_context);
     decoder_.reset();
   }
 
@@ skipping 87 matching lines @@
   } else {
     surface_ = ImageTransportSurface::CreateNativeSurface(
         AsWeakPtr(), surface_handle_, surface_format);
     if (!surface_ || !surface_->Initialize(surface_format)) {
       surface_ = nullptr;
       DLOG(ERROR) << "Failed to create surface.";
       return false;
     }
   }
 
+  if (context_group_->gpu_preferences().use_passthrough_cmd_decoder) {
+    // When using the passthrough command decoder, only share with other
+    // contexts in the explicitly requested share group
+    if (share_command_buffer_stub) {
+      share_group_ = share_command_buffer_stub->share_group_;
+    } else {
+      share_group_ = new gl::GLShareGroup();
+    }
+  } else {
+    // When using the validating command decoder, always use the global share
+    // group
+    share_group_ = channel_->share_group();
+  }
+
   scoped_refptr<gl::GLContext> context;
-  gl::GLShareGroup* gl_share_group = channel_->share_group();
-  if (use_virtualized_gl_context_ && gl_share_group) {
-    context = gl_share_group->GetSharedContext(surface_.get());
+  if (use_virtualized_gl_context_ && share_group_) {
+    context = share_group_->GetSharedContext(surface_.get());
     if (!context.get()) {
       context = gl::init::CreateGLContext(
-          gl_share_group, surface_.get(),
+          share_group_.get(), surface_.get(),
           GenerateGLContextAttribs(init_params.attribs,
                                    context_group_->gpu_preferences()));
       if (!context.get()) {
         DLOG(ERROR) << "Failed to create shared context for virtualization.";
         return false;
       }
-      // Ensure that context creation did not lose track of the intended
-      // gl_share_group.
-      DCHECK(context->share_group() == gl_share_group);
-      gl_share_group->SetSharedContext(surface_.get(), context.get());
+      // Ensure that context creation did not lose track of the intended share
+      // group.
+      DCHECK(context->share_group() == share_group_.get());
+      share_group_->SetSharedContext(surface_.get(), context.get());
     }
     // This should be either:
     // (1) a non-virtual GL context, or
     // (2) a mock/stub context.
     DCHECK(context->GetHandle() ||
            gl::GetGLImplementation() == gl::kGLImplementationMockGL ||
            gl::GetGLImplementation() == gl::kGLImplementationStubGL);
-    context = new GLContextVirtual(
-        gl_share_group, context.get(), decoder_->AsWeakPtr());
+    context = new GLContextVirtual(share_group_.get(), context.get(),
+                                   decoder_->AsWeakPtr());
     if (!context->Initialize(
             surface_.get(),
             GenerateGLContextAttribs(init_params.attribs,
                                      context_group_->gpu_preferences()))) {
       // The real context created above for the default offscreen surface
       // might not be compatible with this surface.
       context = NULL;
       DLOG(ERROR) << "Failed to initialize virtual GL context.";
       return false;
     }
   }
   if (!context.get()) {
     context = gl::init::CreateGLContext(
-        gl_share_group, surface_.get(),
+        share_group_.get(), surface_.get(),
         GenerateGLContextAttribs(init_params.attribs,
                                  context_group_->gpu_preferences()));
   }
   if (!context.get()) {
     DLOG(ERROR) << "Failed to create context.";
     return false;
   }
 
   if (!context->MakeCurrent(surface_.get())) {
     LOG(ERROR) << "Failed to make context current.";
@@ skipping 516 matching lines @@
       command_buffer_->GetLastState().error == error::kLostContext)
     return;
 
   command_buffer_->SetContextLostReason(error::kUnknown);
   if (decoder_)
     decoder_->MarkContextLost(error::kUnknown);
   command_buffer_->SetParseError(error::kLostContext);
 }
 
 }  // namespace gpu