Use GLVersionInfo instead of gl::GetGLImplementation() to decide GL paths

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 <limits.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
@@ skipping 92 matching lines @@
                                      0.0f, 1.0f, 0.0f, 0.0f,
                                      0.0f, 0.0f, 1.0f, 0.0f,
                                      0.0f, 0.0f, 0.0f, 1.0f};
 
 bool PrecisionMeetsSpecForHighpFloat(GLint rangeMin,
                                             GLint rangeMax,
                                             GLint precision) {
   return (rangeMin >= 62) && (rangeMax >= 62) && (precision >= 16);
 }
 
-void GetShaderPrecisionFormatImpl(GLenum shader_type,
-                                         GLenum precision_type,
-                                         GLint* range, GLint* precision) {
+void GetShaderPrecisionFormatImpl(const gl::GLVersionInfo& gl_version_info,
+                                  GLenum shader_type,
+                                  GLenum precision_type,
+                                  GLint* range,
+                                  GLint* precision) {
   switch (precision_type) {
     case GL_LOW_INT:
     case GL_MEDIUM_INT:
     case GL_HIGH_INT:
       // These values are for a 32-bit twos-complement integer format.
       range[0] = 31;
       range[1] = 30;
       *precision = 0;
       break;
     case GL_LOW_FLOAT:
     case GL_MEDIUM_FLOAT:
     case GL_HIGH_FLOAT:
       // These values are for an IEEE single-precision floating-point format.
       range[0] = 127;
       range[1] = 127;
       *precision = 23;
       break;
     default:
       NOTREACHED();
       break;
   }
 
-  if (gl::GetGLImplementation() == gl::kGLImplementationEGLGLES2 &&
-      gl::g_driver_gl.fn.glGetShaderPrecisionFormatFn) {
+  if (gl_version_info.is_es) {
     // This function is sometimes defined even though it's really just
     // a stub, so we need to set range and precision as if it weren't
     // defined before calling it.
     // On Mac OS with some GPUs, calling this generates a
     // GL_INVALID_OPERATION error. Avoid calling it on non-GLES2
     // platforms.
     glGetShaderPrecisionFormat(shader_type, precision_type,
                                range, precision);
 
     // TODO(brianderson): Make the following official workarounds.
@@ skipping 441 matching lines @@
   void Destroy(bool have_context) override;
   void SetSurface(const scoped_refptr<gl::GLSurface>& surface) override;
   void ReleaseSurface() override;
   void TakeFrontBuffer(const Mailbox& mailbox) override;
   void ReturnFrontBuffer(const Mailbox& mailbox, bool is_lost) override;
   bool ResizeOffscreenFrameBuffer(const gfx::Size& size) override;
   bool MakeCurrent() override;
   GLES2Util* GetGLES2Util() override { return &util_; }
   gl::GLContext* GetGLContext() override { return context_.get(); }
   ContextGroup* GetContextGroup() override { return group_.get(); }
+  const FeatureInfo* GetFeatureInfo() const override {
+    return feature_info_.get();
+  }
   Capabilities GetCapabilities() override;
   void RestoreState(const ContextState* prev_state) override;
 
   void RestoreActiveTexture() const override { state_.RestoreActiveTexture(); }
   void RestoreAllTextureUnitBindings(
       const ContextState* prev_state) const override {
     state_.RestoreAllTextureUnitBindings(prev_state);
   }
   void RestoreActiveTextureUnitBinding(unsigned int target) const override {
     state_.RestoreActiveTextureUnitBinding(target);
@@ skipping 207 matching lines @@
   ImageManager* image_manager() { return image_manager_.get(); }
 
   VertexArrayManager* vertex_array_manager() {
     return vertex_array_manager_.get();
   }
 
   MemoryTracker* memory_tracker() {
     return group_->memory_tracker();
   }
 
+  const gl::GLVersionInfo& gl_version_info() {
+    return feature_info_->gl_version_info();
+  }
+
   bool EnsureGPUMemoryAvailable(size_t estimated_size) {
     MemoryTracker* tracker = memory_tracker();
     if (tracker) {
       return tracker->EnsureGPUMemoryAvailable(estimated_size);
     }
     return true;
   }
 
   bool IsOffscreenBufferMultisampled() const {
     return offscreen_target_samples_ > 1;
@@ skipping 2191 matching lines @@
           break;
       }
     }
 
     if (!supported) {
       Destroy(true);
       return false;
     }
   }
 
-  bool needs_emulation = feature_info_->gl_version_info().IsLowerThanGL(4, 2);
+  bool needs_emulation = gl_version_info().IsLowerThanGL(4, 2);
   transform_feedback_manager_.reset(new TransformFeedbackManager(
       group_->max_transform_feedback_separate_attribs(), needs_emulation));
 
   if (feature_info_->context_type() == CONTEXT_TYPE_WEBGL2 ||
       feature_info_->context_type() == CONTEXT_TYPE_OPENGLES3) {
     if (!feature_info_->IsES3Capable()) {
       LOG(ERROR) << "Underlying driver does not support ES3.";
       Destroy(true);
       return false;
     }
@@ skipping 35 matching lines @@
   // vertex_attrib_manager is set to default_vertex_attrib_manager by this call
   DoBindVertexArrayOES(0);
 
   query_manager_.reset(new QueryManager(this, feature_info_.get()));
 
   image_manager_.reset(new ImageManager);
 
   util_.set_num_compressed_texture_formats(
       validators_->compressed_texture_format.GetValues().size());
 
-  if (!feature_info_->gl_version_info().BehavesLikeGLES()) {
+  if (!gl_version_info().BehavesLikeGLES()) {
     // We have to enable vertex array 0 on GL with compatibility profile or it
     // won't render. Note that ES or GL with core profile does not have this
     // issue.
     glEnableVertexAttribArray(0);
   }
   glGenBuffersARB(1, &attrib_0_buffer_id_);
   glBindBuffer(GL_ARRAY_BUFFER, attrib_0_buffer_id_);
   glVertexAttribPointer(0, 1, GL_FLOAT, GL_FALSE, 0, NULL);
   glBindBuffer(GL_ARRAY_BUFFER, 0);
   glGenBuffersARB(1, &fixed_attrib_buffer_id_);
@@ skipping 47 matching lines @@
       // glGetIntegerv() throws a GL error, it leaves its argument unchanged.
       GLint max_sample_count = 1;
       glGetIntegerv(GL_MAX_SAMPLES_EXT, &max_sample_count);
       offscreen_target_samples_ = std::min(attrib_helper.samples,
                                            max_sample_count);
     } else {
       offscreen_target_samples_ = 1;
     }
     offscreen_target_buffer_preserved_ = attrib_helper.buffer_preserved;
 
-    if (gl::GetGLImplementation() == gl::kGLImplementationEGLGLES2) {
-      const bool rgb8_supported =
-          context_->HasExtension("GL_OES_rgb8_rgba8");
+    if (gl_version_info().is_es) {
+      const bool rgb8_supported = context_->HasExtension("GL_OES_rgb8_rgba8");
       // The only available default render buffer formats in GLES2 have very
       // little precision.  Don't enable multisampling unless 8-bit render
       // buffer formats are available--instead fall back to 8-bit textures.
       if (rgb8_supported && offscreen_target_samples_ > 1) {
         offscreen_target_color_format_ =
             offscreen_buffer_texture_needs_alpha ? GL_RGBA8 : GL_RGB8;
       } else {
         offscreen_target_samples_ = 1;
         offscreen_target_color_format_ =
             offscreen_buffer_texture_needs_alpha ||
@@ skipping 126 matching lines @@
     // we ask for. In other words, if we ask for RGB and we get RGBA then we'll
     // make it appear RGB. If on the other hand we ask for RGBA nd get RGB we
     // can't do anything about that.
 
     if (!surfaceless_) {
       GLint depth_bits = 0;
       GLint stencil_bits = 0;
 
       bool default_fb = (GetBackbufferServiceId() == 0);
 
-      if (feature_info_->gl_version_info().is_desktop_core_profile) {
+      if (gl_version_info().is_desktop_core_profile) {
         glGetFramebufferAttachmentParameterivEXT(
             GL_FRAMEBUFFER,
             default_fb ? GL_BACK_LEFT : GL_COLOR_ATTACHMENT0,
             GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE, &alpha_bits);
         glGetFramebufferAttachmentParameterivEXT(
             GL_FRAMEBUFFER,
             default_fb ? GL_DEPTH : GL_DEPTH_ATTACHMENT,
             GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE, &depth_bits);
         glGetFramebufferAttachmentParameterivEXT(
             GL_FRAMEBUFFER,
@@ skipping 18 matching lines @@
     state_.viewport_width = surface->GetSize().width();
     state_.viewport_height = surface->GetSize().height();
   }
 
   // OpenGL ES 2.0 implicitly enables the desktop GL capability
   // VERTEX_PROGRAM_POINT_SIZE and doesn't expose this enum. This fact
   // isn't well documented; it was discovered in the Khronos OpenGL ES
   // mailing list archives. It also implicitly enables the desktop GL
   // capability GL_POINT_SPRITE to provide access to the gl_PointCoord
   // variable in fragment shaders.
-  if (!feature_info_->gl_version_info().BehavesLikeGLES()) {
+  if (!gl_version_info().BehavesLikeGLES()) {
     glEnable(GL_VERTEX_PROGRAM_POINT_SIZE);
     glEnable(GL_POINT_SPRITE);
-  } else if (feature_info_->gl_version_info().is_desktop_core_profile) {
+  } else if (gl_version_info().is_desktop_core_profile) {
     // The desktop core profile changed how program point size mode is
     // enabled.
     glEnable(GL_PROGRAM_POINT_SIZE);
   }
 
   // ES3 requires seamless cubemap. ES2 does not.
   // However, when ES2 is implemented on top of DX11, seamless cubemap is
   // always enabled and there is no way to disable it.
   // Therefore, it seems OK to also always enable it on top of Desktop GL for
   // both ES2 and ES3 contexts.
   if (!feature_info_->workarounds().disable_texture_cube_map_seamless &&
-      feature_info_->gl_version_info().IsAtLeastGL(3, 2)) {
+      gl_version_info().IsAtLeastGL(3, 2)) {
     glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS);
   }
 
   has_robustness_extension_ =
       context->HasExtension("GL_ARB_robustness") ||
       context->HasExtension("GL_KHR_robustness") ||
       context->HasExtension("GL_EXT_robustness");
 
   if (!InitializeShaderTranslator()) {
     return false;
@@ skipping 70 matching lines @@
     if (LOCAL_PEEK_GL_ERROR("glClearWorkaroundInit") != GL_NO_ERROR)
       return false;
   }
 
   return true;
 }
 
 Capabilities GLES2DecoderImpl::GetCapabilities() {
   DCHECK(initialized());
   Capabilities caps;
-  caps.VisitPrecisions([](GLenum shader, GLenum type,
-                          Capabilities::ShaderPrecision* shader_precision) {
+  const gl::GLVersionInfo& version_info = gl_version_info();
+  caps.VisitPrecisions([&version_info](
+      GLenum shader, GLenum type,
+      Capabilities::ShaderPrecision* shader_precision) {
     GLint range[2] = {0, 0};
     GLint precision = 0;
-    GetShaderPrecisionFormatImpl(shader, type, range, &precision);
+    GetShaderPrecisionFormatImpl(version_info, shader, type, range,
+                                 &precision);
     shader_precision->min_range = range[0];
     shader_precision->max_range = range[1];
     shader_precision->precision = precision;
   });
   DoGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS,
                 &caps.max_combined_texture_image_units);
   DoGetIntegerv(GL_MAX_CUBE_MAP_TEXTURE_SIZE, &caps.max_cube_map_texture_size);
   DoGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_VECTORS,
                 &caps.max_fragment_uniform_vectors);
   DoGetIntegerv(GL_MAX_RENDERBUFFER_SIZE, &caps.max_renderbuffer_size);
@@ skipping 173 matching lines @@
     resources.MaxVertexOutputVectors =
         group_->max_vertex_output_components() / 4;
     resources.MaxFragmentInputVectors =
         group_->max_fragment_input_components() / 4;
     resources.MaxProgramTexelOffset = group_->max_program_texel_offset();
     resources.MinProgramTexelOffset = group_->min_program_texel_offset();
   }
 
   GLint range[2] = { 0, 0 };
   GLint precision = 0;
-  GetShaderPrecisionFormatImpl(GL_FRAGMENT_SHADER, GL_HIGH_FLOAT,
-                               range, &precision);
+  GetShaderPrecisionFormatImpl(gl_version_info(), GL_FRAGMENT_SHADER,
+                               GL_HIGH_FLOAT, range, &precision);
   resources.FragmentPrecisionHigh =
       PrecisionMeetsSpecForHighpFloat(range[0], range[1], precision);
 
   ShShaderSpec shader_spec;
   switch (context_type) {
     case CONTEXT_TYPE_WEBGL1:
       shader_spec = SH_WEBGL_SPEC;
       resources.OES_standard_derivatives = derivatives_explicitly_enabled_;
       resources.EXT_frag_depth = frag_depth_explicitly_enabled_;
       resources.EXT_draw_buffers = draw_buffers_explicitly_enabled_;
@@ skipping 64 matching lines @@
     driver_bug_workarounds |= SH_SCALARIZE_VEC_AND_MAT_CONSTRUCTOR_ARGS;
   if (workarounds().regenerate_struct_names)
     driver_bug_workarounds |= SH_REGENERATE_STRUCT_NAMES;
   if (workarounds().remove_pow_with_constant_exponent)
     driver_bug_workarounds |= SH_REMOVE_POW_WITH_CONSTANT_EXPONENT;
 
   resources.WEBGL_debug_shader_precision =
       group_->gpu_preferences().emulate_shader_precision;
 
   ShShaderOutput shader_output_language =
-      ShaderTranslator::GetShaderOutputLanguageForContext(
-          feature_info_->gl_version_info());
+      ShaderTranslator::GetShaderOutputLanguageForContext(gl_version_info());
 
   vertex_translator_ = shader_translator_cache()->GetTranslator(
       GL_VERTEX_SHADER, shader_spec, &resources, shader_output_language,
       static_cast<ShCompileOptions>(driver_bug_workarounds));
   if (!vertex_translator_.get()) {
     LOG(ERROR) << "Could not initialize vertex shader translator.";
     Destroy(true);
     return false;
   }
 
@@ skipping 1785 matching lines @@
     if (texture->target() != 0 && texture->target() != target) {
       LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION,
                          "glBindTexture",
                          "texture bound to more than 1 target.");
       return;
     }
     LogClientServiceForInfo(texture, client_id, "glBindTexture");
     glBindTexture(target, texture->service_id());
     if (texture->target() == 0) {
       texture_manager()->SetTarget(texture_ref, target);
-      if (!feature_info_->gl_version_info().BehavesLikeGLES() &&
-          feature_info_->gl_version_info().IsAtLeastGL(3, 2)) {
+      if (!gl_version_info().BehavesLikeGLES() &&
+          gl_version_info().IsAtLeastGL(3, 2)) {
         // In Desktop GL core profile and GL ES, depth textures are always
         // sampled to the RED channel, whereas on Desktop GL compatibility
         // proifle, they are sampled to RED, LUMINANCE, INTENSITY, or ALPHA
         // channel, depending on the DEPTH_TEXTURE_MODE value.
         // In theory we only need to apply this for depth textures, but it is
         // simpler to apply to all textures.
         glTexParameteri(target, GL_DEPTH_TEXTURE_MODE, GL_RED);
       }
     }
   } else {
@@ skipping 101 matching lines @@
       !state_.bound_transform_feedback->paused()) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glResumeTransformFeedback",
                        "transform feedback is not active or not paused");
     return;
   }
   state_.bound_transform_feedback->DoResumeTransformFeedback();
 }
 
 void GLES2DecoderImpl::DoDisableVertexAttribArray(GLuint index) {
   if (state_.vertex_attrib_manager->Enable(index, false)) {
-    if (index != 0 || feature_info_->gl_version_info().BehavesLikeGLES()) {
+    if (index != 0 || gl_version_info().BehavesLikeGLES()) {
       glDisableVertexAttribArray(index);
     }
   } else {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE,
         "glDisableVertexAttribArray", "index out of range");
   }
 }
 
 void GLES2DecoderImpl::InvalidateFramebufferImpl(
@@ skipping 71 matching lines @@
           NOTREACHED();
           return;
       }
     }
     translated_attachments[i] = attachment;
   }
 
   bool dirty = false;
   switch (op) {
     case kFramebufferDiscard:
-      if (feature_info_->gl_version_info().is_es3) {
+      if (gl_version_info().is_es3) {
         glInvalidateFramebuffer(
             target, validated_count, translated_attachments.get());
       } else {
         glDiscardFramebufferEXT(
             target, validated_count, translated_attachments.get());
       }
       dirty = true;
       break;
     case kFramebufferInvalidate:
-      if (feature_info_->gl_version_info().IsLowerThanGL(4, 3)) {
+      if (gl_version_info().IsLowerThanGL(4, 3)) {
         // no-op since the function isn't supported.
       } else {
         glInvalidateFramebuffer(
             target, validated_count, translated_attachments.get());
         dirty = true;
       }
       break;
     case kFramebufferInvalidateSub:
       // Make it an no-op because we don't have a mechanism to mark partial
       // pixels uncleared yet.
@@ skipping 212 matching lines @@
         }
         if (*params == GL_SRGB_EXT) {
           *params = GL_RGB;
         }
       }
       return true;
     default:
       break;
   }
 
-  if (gl::GetGLImplementation() != gl::kGLImplementationEGLGLES2) {
+  if (!gl_version_info().is_es) {
     switch (pname) {
       case GL_MAX_FRAGMENT_UNIFORM_VECTORS:
         *num_written = 1;
         if (params) {
           *params = group_->max_fragment_uniform_vectors();
         }
         return true;
       case GL_MAX_VARYING_VECTORS:
         *num_written = 1;
         if (params) {
           *params = group_->max_varying_vectors();
         }
         return true;
       case GL_MAX_VERTEX_UNIFORM_VECTORS:
         *num_written = 1;
         if (params) {
           *params = group_->max_vertex_uniform_vectors();
         }
         return true;
       }
   }
   if (unsafe_es3_apis_enabled()) {
     switch (pname) {
       case GL_MAX_VARYING_COMPONENTS: {
-        if (feature_info_->gl_version_info().is_es) {
+        if (gl_version_info().is_es) {
           // We can just delegate this query to the driver.
           return false;
         }
 
         // GL_MAX_VARYING_COMPONENTS is deprecated in the desktop
         // OpenGL core profile, so for simplicity, just compute it
         // from GL_MAX_VARYING_VECTORS on non-OpenGL ES
         // configurations.
         GLint max_varying_vectors = 0;
         glGetIntegerv(GL_MAX_VARYING_VECTORS, &max_varying_vectors);
@@ skipping 82 matching lines @@
       return true;
     case GL_ALPHA_BITS:
       *num_written = 1;
       if (params) {
         GLint v = 0;
         Framebuffer* framebuffer =
             GetFramebufferInfoForTarget(GL_DRAW_FRAMEBUFFER_EXT);
         if (framebuffer) {
           if (framebuffer->HasAlphaMRT() &&
               framebuffer->HasSameInternalFormatsMRT()) {
-            if (feature_info_->gl_version_info().is_desktop_core_profile) {
+            if (gl_version_info().is_desktop_core_profile) {
               for (uint32_t i = 0; i < group_->max_draw_buffers(); i++) {
                 if (framebuffer->HasColorAttachment(i)) {
                   glGetFramebufferAttachmentParameterivEXT(
                       GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + i,
                       GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE, &v);
                   break;
                 }
               }
             } else {
               glGetIntegerv(GL_ALPHA_BITS, &v);
             }
           }
         } else {
           v = (ClientExposedBackBufferHasAlpha() ? 8 : 0);
         }
         params[0] = v;
       }
       return true;
     case GL_DEPTH_BITS:
       *num_written = 1;
       if (params) {
         GLint v = 0;
-        if (feature_info_->gl_version_info().is_desktop_core_profile) {
+        if (gl_version_info().is_desktop_core_profile) {
           Framebuffer* framebuffer =
               GetFramebufferInfoForTarget(GL_DRAW_FRAMEBUFFER_EXT);
           if (framebuffer) {
             if (framebuffer->HasDepthAttachment()) {
               glGetFramebufferAttachmentParameterivEXT(
                   GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
                   GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE, &v);
             }
           } else {
             v = (back_buffer_has_depth_ ? 24 : 0);
           }
         } else {
           glGetIntegerv(GL_DEPTH_BITS, &v);
         }
         params[0] = BoundFramebufferHasDepthAttachment() ? v : 0;
       }
       return true;
     case GL_RED_BITS:
     case GL_GREEN_BITS:
     case GL_BLUE_BITS:
       *num_written = 1;
       if (params) {
         GLint v = 0;
-        if (feature_info_->gl_version_info().is_desktop_core_profile) {
+        if (gl_version_info().is_desktop_core_profile) {
           Framebuffer* framebuffer =
               GetFramebufferInfoForTarget(GL_DRAW_FRAMEBUFFER_EXT);
           if (framebuffer) {
             if (framebuffer->HasSameInternalFormatsMRT()) {
               GLenum framebuffer_enum = 0;
               switch (pname) {
                 case GL_RED_BITS:
                   framebuffer_enum = GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE;
                   break;
                 case GL_GREEN_BITS:
@@ skipping 18 matching lines @@
         } else {
           glGetIntegerv(pname, &v);
         }
         params[0] = v;
       }
       return true;
     case GL_STENCIL_BITS:
       *num_written = 1;
       if (params) {
         GLint v = 0;
-        if (feature_info_->gl_version_info().is_desktop_core_profile) {
+        if (gl_version_info().is_desktop_core_profile) {
           Framebuffer* framebuffer =
               GetFramebufferInfoForTarget(GL_DRAW_FRAMEBUFFER_EXT);
           if (framebuffer) {
             if (framebuffer->HasStencilAttachment()) {
               glGetFramebufferAttachmentParameterivEXT(
                   GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT,
                   GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE, &v);
             }
           } else {
             v = (back_buffer_has_stencil_ ? 8 : 0);
@@ skipping 230 matching lines @@
   }
   return GetHelper(pname, NULL, num_values);
 }
 
 GLenum GLES2DecoderImpl::AdjustGetPname(GLenum pname) {
   if (GL_MAX_SAMPLES == pname &&
       features().use_img_for_multisampled_render_to_texture) {
     return GL_MAX_SAMPLES_IMG;
   }
   if (GL_ALIASED_POINT_SIZE_RANGE == pname &&
-      feature_info_->gl_version_info().is_desktop_core_profile) {
+      gl_version_info().is_desktop_core_profile) {
     return GL_POINT_SIZE_RANGE;
   }
   return pname;
 }
 
 void GLES2DecoderImpl::DoGetBooleanv(GLenum pname, GLboolean* params) {
   DCHECK(params);
   GLsizei num_written = 0;
   if (GetNumValuesReturnedForGLGet(pname, &num_written)) {
     std::unique_ptr<GLint[]> values(new GLint[num_written]);
@@ skipping 24 matching lines @@
       glGetFloatv(pname, params);
     }
   }
 }
 
 void GLES2DecoderImpl::DoGetInteger64v(GLenum pname, GLint64* params) {
   DCHECK(params);
   if (unsafe_es3_apis_enabled()) {
     switch (pname) {
       case GL_MAX_ELEMENT_INDEX: {
-        if (feature_info_->gl_version_info().IsAtLeastGLES(3, 0) ||
-            feature_info_->gl_version_info().IsAtLeastGL(4, 3)) {
+        if (gl_version_info().IsAtLeastGLES(3, 0) ||
+            gl_version_info().IsAtLeastGL(4, 3)) {
           glGetInteger64v(GL_MAX_ELEMENT_INDEX, params);
         } else {
           // Assume that desktop GL implementations can generally support
           // 32-bit indices.
           if (params) {
             *params = std::numeric_limits<unsigned int>::max();
           }
         }
         return;
       }
@@ skipping 1059 matching lines @@
                                              GLint dstY0,
                                              GLint dstX1,
                                              GLint dstY1,
                                              GLbitfield mask,
                                              GLenum filter) {
   // TODO(sievers): This could be resolved at the GL binding level, but the
   // binding process is currently a bit too 'brute force'.
   if (feature_info_->feature_flags().use_core_framebuffer_multisample) {
     glBlitFramebuffer(
         srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
-  } else if (feature_info_->gl_version_info().is_angle) {
+  } else if (gl_version_info().is_angle) {
     // This is ES2 only.
     glBlitFramebufferANGLE(
         srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
   } else {
     glBlitFramebufferEXT(
         srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
   }
 }
 
 bool GLES2DecoderImpl::ValidateRenderbufferStorageMultisample(
@@ skipping 1276 matching lines @@
                          max_vertex_accessed,
                          instanced,
                          primcount);
 }
 
 bool GLES2DecoderImpl::SimulateAttrib0(
     const char* function_name, GLuint max_vertex_accessed, bool* simulated) {
   DCHECK(simulated);
   *simulated = false;
 
-  if (feature_info_->gl_version_info().BehavesLikeGLES())
+  if (gl_version_info().BehavesLikeGLES())
     return true;
 
   const VertexAttrib* attrib =
       state_.vertex_attrib_manager->GetVertexAttrib(0);
   // If it's enabled or it's not used then we don't need to do anything.
   bool attrib_0_used =
       state_.current_program->GetAttribInfoByLocation(0) != NULL;
   if (attrib->enabled() && attrib_0_used) {
     return true;
   }
@@ skipping 72 matching lines @@
 
   if (feature_info_->feature_flags().angle_instanced_arrays)
     glVertexAttribDivisorANGLE(attrib_index, attrib->divisor());
   glBindBuffer(
       GL_ARRAY_BUFFER, state_.bound_array_buffer.get() ?
           state_.bound_array_buffer->service_id() : 0);
 
   // Never touch vertex attribute 0's state (in particular, never disable it)
   // when running on desktop GL with compatibility profile because it will
   // never be re-enabled.
-  if (attrib_index != 0 || feature_info_->gl_version_info().BehavesLikeGLES()) {
+  if (attrib_index != 0 || gl_version_info().BehavesLikeGLES()) {
     if (attrib->enabled()) {
       glEnableVertexAttribArray(attrib_index);
     } else {
       glDisableVertexAttribArray(attrib_index);
     }
   }
 }
 
 bool GLES2DecoderImpl::SimulateFixedAttribs(
     const char* function_name,
     GLuint max_vertex_accessed, bool* simulated, GLsizei primcount) {
   DCHECK(simulated);
   *simulated = false;
-  if (feature_info_->gl_version_info().BehavesLikeGLES())
+  if (gl_version_info().BehavesLikeGLES())
     return true;
 
   if (!state_.vertex_attrib_manager->HaveFixedAttribs()) {
     return true;
   }
 
   LOCAL_PERFORMANCE_WARNING(
       "GL_FIXED attributes have a significant performance penalty");
 
   // NOTE: we could be smart and try to check if a buffer is used
@@ skipping 759 matching lines @@
     return;
   }
   Texture* texture = texture_ref->texture();
   switch (pname) {
     case GL_TEXTURE_MAX_ANISOTROPY_EXT:
       if (workarounds().init_texture_max_anisotropy) {
         texture->InitTextureMaxAnisotropyIfNeeded(target);
       }
       break;
     case GL_TEXTURE_IMMUTABLE_LEVELS:
-      if (feature_info_->gl_version_info().IsLowerThanGL(4, 2)) {
+      if (gl_version_info().IsLowerThanGL(4, 2)) {
         GLint levels = texture->GetImmutableLevels();
         if (fparams) {
           fparams[0] = static_cast<GLfloat>(levels);
         } else {
           iparams[0] = levels;
         }
         return;
       }
       break;
     // Get the level information from the texture to avoid a Mac driver
@@ skipping 348 matching lines @@
       ->SetAttribInfo(indx,
                       state_.bound_array_buffer.get(),
                       size,
                       type,
                       normalized,
                       stride,
                       stride != 0 ? stride : group_size,
                       offset,
                       GL_FALSE);
   // We support GL_FIXED natively on EGL/GLES2 implementations
-  if (type != GL_FIXED || feature_info_->gl_version_info().is_es) {
+  if (type != GL_FIXED || gl_version_info().is_es) {
     glVertexAttribPointer(indx, size, type, normalized, stride, ptr);
   }
   return error::kNoError;
 }
 
 void GLES2DecoderImpl::DoViewport(GLint x, GLint y, GLsizei width,
                                   GLsizei height) {
   state_.viewport_x = x;
   state_.viewport_y = y;
   state_.viewport_width = std::min(width, viewport_max_width_);
@@ skipping 355 matching lines @@
     if (format == static_cast<GLenum>(preferred_format) &&
         type == static_cast<GLenum>(preferred_type)) {
       format_type_acceptable = true;
     }
   }
   if (!format_type_acceptable) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glReadPixels",
         "format and type incompatible with the current read framebuffer");
     return error::kNoError;
   }
-  if (type == GL_HALF_FLOAT_OES &&
-      !(feature_info_->gl_version_info().is_es2)) {
+  if (type == GL_HALF_FLOAT_OES && !gl_version_info().is_es2) {
     type = GL_HALF_FLOAT;
   }
   if (width == 0 || height == 0) {
     return error::kNoError;
   }
 
   // Get the size of the current fbo or backbuffer.
   gfx::Size max_size = GetBoundReadFrameBufferSize();
 
   int32_t max_x;
@@ skipping 43 matching lines @@
     if (async && features().use_async_readpixels &&
         !state_.bound_pixel_pack_buffer.get()) {
       // To simply the state tracking, we don't go down the async path if
       // a PIXEL_PACK_BUFFER is bound (in which case the client can
       // implement something similar on their own - all necessary functions
       // should be exposed).
       GLuint buffer = 0;
       glGenBuffersARB(1, &buffer);
       glBindBuffer(GL_PIXEL_PACK_BUFFER_ARB, buffer);
       // For ANGLE client version 2, GL_STREAM_READ is not available.
-      const GLenum usage_hint = feature_info_->gl_version_info().is_angle ?
-          GL_STATIC_DRAW : GL_STREAM_READ;
+      const GLenum usage_hint =
+          gl_version_info().is_angle ? GL_STATIC_DRAW : GL_STREAM_READ;
       glBufferData(GL_PIXEL_PACK_BUFFER_ARB, pixels_size, NULL, usage_hint);
       GLenum error = glGetError();
       if (error == GL_NO_ERROR) {
         // No need to worry about ES3 pixel pack parameters, because no
         // PIXEL_PACK_BUFFER is bound, and all these settings haven't been
         // sent to GL.
         glReadPixels(x, y, width, height, format, type, 0);
         pending_readpixel_fences_.push(FenceCallback());
         WaitForReadPixels(base::Bind(&GLES2DecoderImpl::FinishReadPixels,
                                      base::AsWeakPtr(this), c, buffer));
@@ skipping 1039 matching lines @@
     {8, 5},
     {8, 6},
     {8, 8},
     {10, 5},
     {10, 6},
     {10, 8},
     {10, 10},
     {12, 10},
     {12, 12}};
 
-bool CheckETCFormatSupport(const FeatureInfo& featureInfo) {
-  const gl::GLVersionInfo& versionInfo = featureInfo.gl_version_info();
-  return versionInfo.IsAtLeastGL(4, 3) || versionInfo.IsAtLeastGLES(3, 0) ||
-         featureInfo.feature_flags().arb_es3_compatibility;
+bool CheckETCFormatSupport(const FeatureInfo& feature_info) {
+  const gl::GLVersionInfo& version_info = feature_info.gl_version_info();
+  return version_info.IsAtLeastGL(4, 3) || version_info.IsAtLeastGLES(3, 0) ||
+         feature_info.feature_flags().arb_es3_compatibility;
 }
 
 using CompressedFormatSupportCheck = bool (*)(const FeatureInfo&);
 using CompressedFormatDecompressionFunction = void (*)(size_t width,
                                                        size_t height,
                                                        size_t depth,
                                                        const uint8_t* input,
                                                        size_t inputRowPitch,
                                                        size_t inputDepthPitch,
                                                        uint8_t* output,
@@ skipping 1796 matching lines @@
   if (!validators_->shader_precision.IsValid(precision_type)) {
     LOCAL_SET_GL_ERROR_INVALID_ENUM(
         "glGetShaderPrecisionFormat", precision_type, "precision_type");
     return error::kNoError;
   }
 
   result->success = 1;  // true
 
   GLint range[2] = { 0, 0 };
   GLint precision = 0;
-  GetShaderPrecisionFormatImpl(shader_type, precision_type, range, &precision);
+  GetShaderPrecisionFormatImpl(gl_version_info(), shader_type, precision_type,
+                               range, &precision);
 
   result->min_range = range[0];
   result->max_range = range[1];
   result->precision = precision;
 
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetAttachedShaders(
     uint32_t immediate_data_size,
@@ skipping 416 matching lines @@
         offscreen_saved_color_texture_.swap(offscreen_target_color_texture_);
         offscreen_target_frame_buffer_->AttachRenderTexture(
             offscreen_target_color_texture_.get());
         offscreen_saved_frame_buffer_->AttachRenderTexture(
             offscreen_saved_color_texture_.get());
       }
 
       // Ensure the side effects of the copy are visible to the parent
       // context. There is no need to do this for ANGLE because it uses a
       // single D3D device for all contexts.
-      if (!feature_info_->gl_version_info().is_angle)
+      if (!gl_version_info().is_angle)
         glFlush();
     }
   } else if (supports_async_swap_) {
     TRACE_EVENT_ASYNC_BEGIN0("cc", "GLES2DecoderImpl::AsyncSwapBuffers", this);
     surface_->SwapBuffersAsync(base::Bind(&GLES2DecoderImpl::FinishSwapBuffers,
                                           base::AsWeakPtr(this)));
   } else {
     FinishSwapBuffers(surface_->SwapBuffers());
   }
 
@@ skipping 2253 matching lines @@
     return error::kNoError;
   }
   if (!validators_->internal_format_parameter.IsValid(pname)) {
     LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetInternalformativ", pname, "pname");
     return error::kNoError;
   }
 
   typedef cmds::GetInternalformativ::Result Result;
   GLsizei num_values = 0;
   std::vector<GLint> samples;
-  if (feature_info_->gl_version_info().IsLowerThanGL(4, 2)) {
+  if (gl_version_info().IsLowerThanGL(4, 2)) {
     if (!GLES2Util::IsIntegerFormat(format) &&
         !GLES2Util::IsFloatFormat(format)) {
       // No multisampling for integer formats and float formats.
       GLint max_samples = renderbuffer_manager()->max_samples();
       while (max_samples > 0) {
         samples.push_back(max_samples);
         max_samples = max_samples >> 1;
       }
     }
     switch (pname) {
@@ skipping 28 matching lines @@
   Result* result = GetSharedMemoryAs<Result*>(
       c.params_shm_id, c.params_shm_offset, Result::ComputeSize(num_values));
   GLint* params = result ? result->GetData() : NULL;
   if (params == nullptr) {
     return error::kOutOfBounds;
   }
   // Check that the client initialized the result.
   if (result->size != 0) {
     return error::kInvalidArguments;
   }
-  if (feature_info_->gl_version_info().IsLowerThanGL(4, 2)) {
+  if (gl_version_info().IsLowerThanGL(4, 2)) {
     switch (pname) {
       case GL_NUM_SAMPLE_COUNTS:
         params[0] = static_cast<GLint>(samples.size());
         break;
       case GL_SAMPLES:
         for (size_t ii = 0; ii < samples.size(); ++ii) {
           params[ii] = samples[ii];
         }
         break;
       default:
@@ skipping 1299 matching lines @@
 }
 
 // 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 "base/macros.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu