Refactor GL bindings so there is no global GLApi or DriverGL.

gpu/command_buffer/service/memory_program_cache.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/memory_program_cache.h"
 
 #include <stddef.h>
 
 #include "base/base64.h"
 #include "base/callback.h"
@@ skipping 182 matching lines @@
                        GpuProgramProto* proto,
                        std::string sha_string) {
   std::string shader;
   proto->SerializeToString(&shader);
 
   std::string key;
   base::Base64Encode(sha_string, &key);
   callback.Run(key, shader);
 }
 
+bool ProgramBinaryExtensionsAvailable() {
+  return gl::g_current_gl_driver &&
+         (gl::g_current_gl_driver->ext.b_GL_ARB_get_program_binary ||
+          gl::g_current_gl_driver->ext.b_GL_OES_get_program_binary);
+}
+
 }  // namespace
 
 MemoryProgramCache::MemoryProgramCache(
     size_t max_cache_size_bytes,
     bool disable_gpu_shader_disk_cache,
     bool disable_program_caching_for_transform_feedback)
     : max_size_bytes_(max_cache_size_bytes),
       disable_gpu_shader_disk_cache_(disable_gpu_shader_disk_cache),
       disable_program_caching_for_transform_feedback_(
           disable_program_caching_for_transform_feedback),
       curr_size_bytes_(0),
       store_(ProgramMRUCache::NO_AUTO_EVICT) {
 }
 
 MemoryProgramCache::~MemoryProgramCache() {}
 
 void MemoryProgramCache::ClearBackend() {
   store_.Clear();
   DCHECK_EQ(0U, curr_size_bytes_);
 }
 
 ProgramCache::ProgramLoadResult MemoryProgramCache::LoadLinkedProgram(
     GLuint program,
     Shader* shader_a,
     Shader* shader_b,
     const LocationMap* bind_attrib_location_map,
     const std::vector<std::string>& transform_feedback_varyings,
     GLenum transform_feedback_buffer_mode,
     const ShaderCacheCallback& shader_callback) {
+  if (!ProgramBinaryExtensionsAvailable()) {
+    // Early exit if this context can't support program binaries
+    return PROGRAM_LOAD_FAILURE;
+  }
+
   char a_sha[kHashLength];
   char b_sha[kHashLength];
   DCHECK(shader_a && !shader_a->last_compiled_source().empty() &&
          shader_b && !shader_b->last_compiled_source().empty());
   ComputeShaderHash(
       shader_a->last_compiled_signature(), a_sha);
   ComputeShaderHash(
       shader_b->last_compiled_signature(), b_sha);
 
   char sha[kHashLength];
@@ skipping 46 matching lines @@
 }
 
 void MemoryProgramCache::SaveLinkedProgram(
     GLuint program,
     const Shader* shader_a,
     const Shader* shader_b,
     const LocationMap* bind_attrib_location_map,
     const std::vector<std::string>& transform_feedback_varyings,
     GLenum transform_feedback_buffer_mode,
     const ShaderCacheCallback& shader_callback) {
+  if (!ProgramBinaryExtensionsAvailable()) {
+    // Early exit if this context can't support program binaries
+    return;
+  }
   if (disable_program_caching_for_transform_feedback_ &&
       !transform_feedback_varyings.empty()) {
     return;
   }
   GLenum format;
   GLsizei length = 0;
   glGetProgramiv(program, GL_PROGRAM_BINARY_LENGTH_OES, &length);
   if (length == 0 || static_cast<unsigned int>(length) > max_size_bytes_) {
     return;
   }
@@ skipping 181 matching lines @@
   program_cache_->LinkedProgramCacheSuccess(program_hash);
 }
 
 MemoryProgramCache::ProgramCacheValue::~ProgramCacheValue() {
   program_cache_->curr_size_bytes_ -= length_;
   program_cache_->Evict(program_hash_);
 }
 
 }  // namespace gles2
 }  // namespace gpu