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

gpu/command_buffer/service/gles2_cmd_copy_texture_chromium.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_copy_texture_chromium.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
 #include "gpu/command_buffer/service/gl_utils.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
-#include "ui/gl/gl_implementation.h"
+#include "ui/gl/gl_version_info.h"
 
 namespace {
 
 const GLfloat kIdentityMatrix[16] = {1.0f, 0.0f, 0.0f, 0.0f,
                                      0.0f, 1.0f, 0.0f, 0.0f,
                                      0.0f, 0.0f, 1.0f, 0.0f,
                                      0.0f, 0.0f, 0.0f, 1.0f};
 
 enum FragmentShaderId {
   FRAGMENT_SHADER_COPY_TEXTURE_2D,
@@ skipping 63 matching lines @@
 }
 
 const char* kShaderPrecisionPreamble = "\
     #ifdef GL_ES\n\
     precision mediump float;\n\
     #define TexCoordPrecision mediump\n\
     #else\n\
     #define TexCoordPrecision\n\
     #endif\n";
 
-std::string GetVertexShaderSource() {
+std::string GetVertexShaderSource(const gl::GLVersionInfo& gl_version_info) {
   std::string source;
 
   // Preamble for core and compatibility mode.
-  if (gl::GetGLImplementation() == gl::kGLImplementationDesktopGLCoreProfile) {
+  if (gl_version_info.is_desktop_core_profile) {
     source += std::string("\
         #version 150\n\
         #define ATTRIBUTE in\n\
         #define VARYING out\n");
   } else {
     source += std::string("\
         #define ATTRIBUTE attribute\n\
         #define VARYING varying\n");
   }
 
@@ skipping 11 matching lines @@
       void main(void) {\n\
         gl_Position = vec4(0, 0, 0, 1);\n\
         gl_Position.xy = a_position.xy * u_vertex_dest_mult + \
                          u_vertex_dest_add;\n\
         v_uv = a_position.xy * u_vertex_source_mult + u_vertex_source_add;\n\
       }\n");
 
   return source;
 }
 
-std::string GetFragmentShaderSource(bool premultiply_alpha,
+std::string GetFragmentShaderSource(const gl::GLVersionInfo& gl_version_info,
+                                    bool premultiply_alpha,
                                     bool unpremultiply_alpha,
                                     GLenum target) {
   std::string source;
 
   // Preamble for core and compatibility mode.
-  if (gl::GetGLImplementation() == gl::kGLImplementationDesktopGLCoreProfile) {
+  if (gl_version_info.is_desktop_core_profile) {
     source += std::string("\
         #version 150\n\
         out vec4 frag_color;\n\
         #define VARYING in\n\
         #define FRAGCOLOR frag_color\n\
         #define TextureLookup texture\n");
   } else {
     switch (target) {
       case GL_TEXTURE_2D:
         source += std::string("#define TextureLookup texture2D\n");
@@ skipping 417 matching lines @@
   DCHECK_LE(yoffset + height, dest_height);
   if (dest_width == 0 || dest_height == 0 || source_width == 0 ||
       source_height == 0) {
     return;
   }
 
   if (!initialized_) {
     DLOG(ERROR) << "CopyTextureCHROMIUM: Uninitialized manager.";
     return;
   }
+  const gl::GLVersionInfo& gl_version_info =
+      decoder->GetFeatureInfo()->gl_version_info();
 
   if (vertex_array_object_id_) {
     glBindVertexArrayOES(vertex_array_object_id_);
   } else {
-    if (gl::GetGLImplementation() !=
-        gl::kGLImplementationDesktopGLCoreProfile) {
+    if (!gl_version_info.is_desktop_core_profile) {
       decoder->ClearAllAttributes();
     }
     glEnableVertexAttribArray(kVertexPositionAttrib);
     glBindBuffer(GL_ARRAY_BUFFER, buffer_id_);
     glVertexAttribPointer(kVertexPositionAttrib, 2, GL_FLOAT, GL_FALSE, 0, 0);
   }
 
   FragmentShaderId fragment_shader_id = GetFragmentShaderId(
       premultiply_alpha, unpremultiply_alpha, source_target);
   DCHECK_LT(static_cast<size_t>(fragment_shader_id), fragment_shaders_.size());
 
   ProgramMapKey key(fragment_shader_id);
   ProgramInfo* info = &programs_[key];
   // Create program if necessary.
   if (!info->program) {
     info->program = glCreateProgram();
     if (!vertex_shader_) {
       vertex_shader_ = glCreateShader(GL_VERTEX_SHADER);
-      std::string source = GetVertexShaderSource();
+      std::string source = GetVertexShaderSource(gl_version_info);
       CompileShader(vertex_shader_, source.c_str());
     }
     glAttachShader(info->program, vertex_shader_);
     GLuint* fragment_shader = &fragment_shaders_[fragment_shader_id];
     if (!*fragment_shader) {
       *fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
-      std::string source = GetFragmentShaderSource(
-          premultiply_alpha, unpremultiply_alpha, source_target);
+      std::string source =
+          GetFragmentShaderSource(gl_version_info, premultiply_alpha,
+                                  unpremultiply_alpha, source_target);
       CompileShader(*fragment_shader, source.c_str());
     }
     glAttachShader(info->program, *fragment_shader);
     glBindAttribLocation(info->program, kVertexPositionAttrib, "a_position");
     glLinkProgram(info->program);
 #ifndef NDEBUG
     GLint linked;
     glGetProgramiv(info->program, GL_LINK_STATUS, &linked);
     if (!linked)
       DLOG(ERROR) << "CopyTextureCHROMIUM: program link failure.";
@@ skipping 129 matching lines @@
   decoder->RestoreTextureState(dest_id);
   decoder->RestoreTextureUnitBindings(0);
   decoder->RestoreActiveTexture();
   decoder->RestoreProgramBindings();
   decoder->RestoreBufferBindings();
   decoder->RestoreFramebufferBindings();
   decoder->RestoreGlobalState();
 }
 
 }  // namespace gpu