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

ui/gl/gl_context_egl.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 "ui/gl/gl_context_egl.h"
 
 #include <memory>
 
 #include "base/command_line.h"
 #include "base/logging.h"
@@ skipping 14 matching lines @@
 #ifndef EGL_CHROMIUM_create_context_bind_generates_resource
 #define EGL_CHROMIUM_create_context_bind_generates_resource 1
 #define EGL_CONTEXT_BIND_GENERATES_RESOURCE_CHROMIUM 0x3AAD
 #endif /* EGL_CHROMIUM_create_context_bind_generates_resource */
 
 #ifndef EGL_ANGLE_create_context_webgl_compatibility
 #define EGL_ANGLE_create_context_webgl_compatibility 1
 #define EGL_CONTEXT_WEBGL_COMPATIBILITY_ANGLE 0x3AAC
 #endif /* EGL_ANGLE_create_context_webgl_compatibility */
 
+#ifndef EGL_ANGLE_display_texture_share_group
+#define EGL_ANGLE_display_texture_share_group 1
+#define EGL_DISPLAY_TEXTURE_SHARE_GROUP_ANGLE 0x3AAF
+#endif /* EGL_ANGLE_display_texture_share_group */
+
 using ui::GetLastEGLErrorString;
 
 namespace gl {
 
 GLContextEGL::GLContextEGL(GLShareGroup* share_group)
     : GLContextReal(share_group),
       context_(nullptr),
       display_(nullptr),
       config_(nullptr),
       unbind_fbo_on_makecurrent_(false),
       swap_interval_(1) {
 }
 
 bool GLContextEGL::Initialize(GLSurface* compatible_surface,
                               const GLContextAttribs& attribs) {
   DCHECK(compatible_surface);
   DCHECK(!context_);
 
   display_ = compatible_surface->GetDisplay();
   config_ = compatible_surface->GetConfig();
 
   EGLint config_renderable_type = 0;
   if (!eglGetConfigAttrib(display_, config_, EGL_RENDERABLE_TYPE,
                           &config_renderable_type)) {
     LOG(ERROR) << "eglGetConfigAttrib failed with error "
                << GetLastEGLErrorString();
     return false;
   }
 
-  EGLint context_client_version = 2;
-  if ((config_renderable_type & EGL_OPENGL_ES3_BIT) != 0 &&
-      !base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kDisableES3GLContext)) {
-    context_client_version = 3;
+  EGLint context_client_major_version = attribs.client_major_es_version;
+  EGLint context_client_minor_version = attribs.client_minor_es_version;
+
+  // If the requested context is ES3 but the config cannot support ES3, request
+  // ES2 instead.
+  if ((config_renderable_type & EGL_OPENGL_ES3_BIT) == 0 &&
+      context_client_major_version >= 3) {
+    context_client_major_version = 2;
+    context_client_minor_version = 0;

[Zhenyao Mo, 2017/02/16 22:43:11]

Should we fail here and let the caller decides what they want to do? They have
the option of going for ES2 or something else.

[Geoff Lang, 2017/02/21 20:35:32]

Yea, I think it would make sense to first ask to see if it's possible to create
a context version instead of creating a lower version and then destroying it
after when it doesn't meet the requirements.  Going to save that for another CL
though since I don't want to change the behaviour here.

   }
 
   std::vector<EGLint> context_attributes;
-  context_attributes.push_back(EGL_CONTEXT_CLIENT_VERSION);
-  context_attributes.push_back(context_client_version);
+
+  // EGL_KHR_create_context allows requesting both a major and minor context
+  // version
+  if (GLSurfaceEGL::HasEGLExtension("EGL_KHR_create_context")) {
+    context_attributes.push_back(EGL_CONTEXT_MAJOR_VERSION);
+    context_attributes.push_back(context_client_major_version);
+
+    context_attributes.push_back(EGL_CONTEXT_MINOR_VERSION);
+    context_attributes.push_back(context_client_minor_version);
+  } else {
+    context_attributes.push_back(EGL_CONTEXT_CLIENT_VERSION);
+    context_attributes.push_back(context_client_major_version);
+
+    // Can only request 2.0 or 3.0 contexts without the EGL_KHR_create_context
+    // extension, DCHECK to make sure we update the code to support devices
+    // without this extension
+    DCHECK(context_client_minor_version == 0);
+  }
 
   if (GLSurfaceEGL::IsCreateContextRobustnessSupported()) {
     DVLOG(1) << "EGL_EXT_create_context_robustness supported.";
     context_attributes.push_back(
         EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT);
     context_attributes.push_back(EGL_LOSE_CONTEXT_ON_RESET_EXT);
   } else {
     // At some point we should require the presence of the robustness
     // extension and remove this code path.
     DVLOG(1) << "EGL_EXT_create_context_robustness NOT supported.";
@@ skipping 14 matching lines @@
   }
 
   if (GLSurfaceEGL::IsCreateContextWebGLCompatabilitySupported()) {
     context_attributes.push_back(EGL_CONTEXT_WEBGL_COMPATIBILITY_ANGLE);
     context_attributes.push_back(
         attribs.webgl_compatibility_context ? EGL_TRUE : EGL_FALSE);
   } else {
     DCHECK(!attribs.webgl_compatibility_context);
   }
 
+  if (GLSurfaceEGL::HasEGLExtension("EGL_ANGLE_display_texture_share_group")) {
+    context_attributes.push_back(EGL_DISPLAY_TEXTURE_SHARE_GROUP_ANGLE);
+    context_attributes.push_back(
+        attribs.global_texture_share_group ? EGL_TRUE : EGL_FALSE);
+  } else {
+    DCHECK(!attribs.global_texture_share_group);
+  }
+
   // Append final EGL_NONE to signal the context attributes are finished
   context_attributes.push_back(EGL_NONE);
   context_attributes.push_back(EGL_NONE);
 
   context_ = eglCreateContext(
       display_, config_, share_group() ? share_group()->GetHandle() : nullptr,
       context_attributes.data());
 
   if (!context_) {
     LOG(ERROR) << "eglCreateContext failed with error "
@@ skipping 126 matching lines @@
 
 bool GLContextEGL::WasAllocatedUsingRobustnessExtension() {
   return GLSurfaceEGL::IsCreateContextRobustnessSupported();
 }
 
 GLContextEGL::~GLContextEGL() {
   Destroy();
 }
 
 }  // namespace gl