command_buffer: Add support for creating non-WebGL ES 3 contexts

gpu/command_buffer/service/gles2_cmd_decoder.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/command_buffer/service/gles2_cmd_decoder.h"
 
 #include <stdio.h>
 
 #include <algorithm>
 #include <cmath>
@@ skipping 823 matching lines @@
 
   bool EnsureGPUMemoryAvailable(size_t estimated_size) {
     MemoryTracker* tracker = memory_tracker();
     if (tracker) {
       return tracker->EnsureGPUMemoryAvailable(estimated_size);
     }
     return true;
   }
 
   bool IsWebGLContext() const {
-    return webgl_version_ == 1 || webgl_version_ == 2;
+    return context_type_ == CONTEXT_TYPE_WEBGL1 ||
+           context_type_ == CONTEXT_TYPE_WEBGL2;
   }
 
   bool IsOffscreenBufferMultisampled() const {
     return offscreen_target_samples_ > 1;
   }
 
   // Creates a Texture for the given texture.
   TextureRef* CreateTexture(
       GLuint client_id, GLuint service_id) {
     return texture_manager()->CreateTexture(client_id, service_id);
@@ skipping 1144 matching lines @@
 
   // Number of commands remaining to be processed in DoCommands().
   int commands_to_process_;
 
   bool has_robustness_extension_;
   error::ContextLostReason context_lost_reason_;
   bool context_was_lost_;
   bool reset_by_robustness_extension_;
   bool supports_post_sub_buffer_;
 
-  // Indicates whether this is a context for WebGL1, WebGL2, or others.
-  //   0: other types
-  //   1: WebGL 1
-  //   2: WebGL 2
-  unsigned webgl_version_;
+  ContextType context_type_;
 
   // These flags are used to override the state of the shared feature_info_
   // member.  Because the same FeatureInfo instance may be shared among many
   // contexts, the assumptions on the availablity of extensions in WebGL
   // contexts may be broken.  These flags override the shared state to preserve
   // WebGL semantics.
   bool derivatives_explicitly_enabled_;
   bool frag_depth_explicitly_enabled_;
   bool draw_buffers_explicitly_enabled_;
   bool shader_texture_lod_explicitly_enabled_;
@@ skipping 520 matching lines @@
       backbuffer_needs_clear_bits_(0),
       current_decoder_error_(error::kNoError),
       validators_(group_->feature_info()->validators()),
       feature_info_(group_->feature_info()),
       frame_number_(0),
       has_robustness_extension_(false),
       context_lost_reason_(error::kUnknown),
       context_was_lost_(false),
       reset_by_robustness_extension_(false),
       supports_post_sub_buffer_(false),
-      webgl_version_(0),
+      context_type_(CONTEXT_TYPE_OPENGLES2),
       derivatives_explicitly_enabled_(false),
       frag_depth_explicitly_enabled_(false),
       draw_buffers_explicitly_enabled_(false),
       shader_texture_lod_explicitly_enabled_(false),
       compile_shader_always_succeeds_(false),
       lose_context_when_out_of_memory_(false),
       service_logging_(base::CommandLine::InitializedForCurrentProcess()
                            ? base::CommandLine::ForCurrentProcess()->HasSwitch(
                                  switches::kEnableGPUServiceLoggingGPU)
                            : false),
@@ skipping 24 matching lines @@
     const DisallowedFeatures& disallowed_features,
     const std::vector<int32>& attribs) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::Initialize");
   DCHECK(context->IsCurrent(surface.get()));
   DCHECK(!context_.get());
   DCHECK(!offscreen || !offscreen_size.IsEmpty());
 
   ContextCreationAttribHelper attrib_parser;
   if (!attrib_parser.Parse(attribs))
     return false;
-  webgl_version_ = attrib_parser.webgl_version;
+
+  context_type_ = attrib_parser.context_type;
 
   surfaceless_ = surface->IsSurfaceless() && !offscreen;
 
   set_initialized();
   gpu_state_tracer_ = GPUStateTracer::Create(&state_);
 
   if (base::CommandLine::InitializedForCurrentProcess()) {
     if (base::CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kEnableGPUDebugging)) {
       set_debug(true);
@@ skipping 30 matching lines @@
   // If the failIfMajorPerformanceCaveat context creation attribute was true
   // and we are using a software renderer, fail.
   if (attrib_parser.fail_if_major_perf_caveat &&
       feature_info_->feature_flags().is_swiftshader) {
     group_ = NULL;  // Must not destroy ContextGroup if it is not initialized.
     Destroy(true);
     return false;
   }
 
   disallowed_features_ = disallowed_features;
-  if (webgl_version_ == 1) {
+  if (context_type_ == CONTEXT_TYPE_WEBGL1) {
     disallowed_features_.npot_support = true;
   }
 
-  if (!group_->Initialize(this,
-                          ContextGroup::GetContextType(webgl_version_),
-                          disallowed_features_)) {
+  if (!group_->Initialize(this, context_type_, disallowed_features_)) {
     group_ = NULL;  // Must not destroy ContextGroup if it is not initialized.
     Destroy(true);
     return false;
   }
   CHECK_GL_ERROR();
-
-  if (webgl_version_ == 2) {
+  if (context_type_ == CONTEXT_TYPE_WEBGL2 ||
+      context_type_ == CONTEXT_TYPE_OPENGLES3) {
     if (!feature_info_->IsES3Capable()) {
       LOG(ERROR) << "Underlying driver does not support ES3.";
       Destroy(true);
       return false;
     }
     feature_info_->EnableES3Validators();
     set_unsafe_es3_apis_enabled(true);
 
     frag_depth_explicitly_enabled_ = true;
     draw_buffers_explicitly_enabled_ = true;
@@ skipping 554 matching lines @@
         features().ext_draw_buffers ? 1 : 0;
     resources.EXT_frag_depth =
         features().ext_frag_depth ? 1 : 0;
     resources.EXT_shader_texture_lod =
         features().ext_shader_texture_lod ? 1 : 0;
     resources.NV_draw_buffers =
         features().nv_draw_buffers ? 1 : 0;
   }
 
   ShShaderSpec shader_spec;
-  if (IsWebGLContext()) {
-    shader_spec = webgl_version_ == 2 ? SH_WEBGL2_SPEC : SH_WEBGL_SPEC;
-  } else {
-    shader_spec = unsafe_es3_apis_enabled() ? SH_GLES3_SPEC : SH_GLES2_SPEC;
+  switch (context_type_) {
+    case CONTEXT_TYPE_WEBGL1:
+      shader_spec = SH_WEBGL_SPEC;
+      break;
+    case CONTEXT_TYPE_WEBGL2:
+      shader_spec = SH_WEBGL2_SPEC;
+      break;
+    case CONTEXT_TYPE_OPENGLES2:
+      shader_spec = SH_GLES2_SPEC;
+      break;
+    case CONTEXT_TYPE_OPENGLES3:
+      shader_spec = SH_GLES3_SPEC;
+      break;
+    default:
+      NOTREACHED();
+      shader_spec = SH_GLES2_SPEC;
+      break;
   }
 
   if ((shader_spec == SH_WEBGL_SPEC || shader_spec == SH_WEBGL2_SPEC) &&
       features().enable_shader_name_hashing)
     resources.HashFunction = &CityHash64;
   else
     resources.HashFunction = NULL;
 
   int driver_bug_workarounds = 0;
   if (workarounds().needs_glsl_built_in_function_emulation)
@@ skipping 11529 matching lines @@
   return error::kNoError;
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu