Move WrappedTexImage functionality to ui/gl

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 <list>
@@ skipping 226 matching lines @@
 
 static bool StringIsValidForGLES(const char* str) {
   for (; *str; ++str) {
     if (!CharacterIsValidForGLES(*str)) {
       return false;
     }
   }
   return true;
 }
 
-static inline GLenum GetTexInternalFormat(GLenum internal_format) {
-  if (gfx::GetGLImplementation() != gfx::kGLImplementationEGLGLES2) {
-    if (internal_format == GL_BGRA_EXT || internal_format == GL_BGRA8_EXT)
-      return GL_RGBA8;
-  }
-  return internal_format;
-}
-
-// TODO(epenner): Could the above function be merged into this and removed?
-static inline GLenum GetTexInternalFormat(GLenum internal_format,
-                                          GLenum format,
-                                          GLenum type) {
-  GLenum gl_internal_format = GetTexInternalFormat(internal_format);
-
-  if (gfx::GetGLImplementation() == gfx::kGLImplementationEGLGLES2)
-    return gl_internal_format;
-
-  if (type == GL_FLOAT) {
-    switch (format) {
-      case GL_RGBA:
-        gl_internal_format = GL_RGBA32F_ARB;
-        break;
-      case GL_RGB:
-        gl_internal_format = GL_RGB32F_ARB;
-        break;
-      case GL_LUMINANCE_ALPHA:
-        gl_internal_format = GL_LUMINANCE_ALPHA32F_ARB;
-        break;
-      case GL_LUMINANCE:
-        gl_internal_format = GL_LUMINANCE32F_ARB;
-        break;
-      case GL_ALPHA:
-        gl_internal_format = GL_ALPHA32F_ARB;
-        break;
-      default:
-        NOTREACHED();
-        break;
-    }
-  } else if (type == GL_HALF_FLOAT_OES) {
-    switch (format) {
-      case GL_RGBA:
-        gl_internal_format = GL_RGBA16F_ARB;
-        break;
-      case GL_RGB:
-        gl_internal_format = GL_RGB16F_ARB;
-        break;
-      case GL_LUMINANCE_ALPHA:
-        gl_internal_format = GL_LUMINANCE_ALPHA16F_ARB;
-        break;
-      case GL_LUMINANCE:
-        gl_internal_format = GL_LUMINANCE16F_ARB;
-        break;
-      case GL_ALPHA:
-        gl_internal_format = GL_ALPHA16F_ARB;
-        break;
-      default:
-        NOTREACHED();
-        break;
-    }
-  }
-  return gl_internal_format;
-}
-
-static void WrappedTexImage2D(
-    GLenum target,
-    GLint level,
-    GLenum internal_format,
-    GLsizei width,
-    GLsizei height,
-    GLint border,
-    GLenum format,
-    GLenum type,
-    const void* pixels) {
-  glTexImage2D(
-      target, level, GetTexInternalFormat(internal_format, format, type),
-      width, height, border, format, type, pixels);
-}
-
 // Wrapper for glEnable/glDisable that doesn't suck.
 static void EnableDisable(GLenum pname, bool enable) {
   if (enable) {
     glEnable(pname);
   } else {
     glDisable(pname);
   }
 }
 
 // This class prevents any GL errors that occur when it is in scope from
@@ skipping 1628 matching lines @@
   if (!memory_tracker_.EnsureGPUMemoryAvailable(image_size)) {
     return false;
   }
 
   scoped_ptr<char[]> zero_data;
   if (zero) {
     zero_data.reset(new char[image_size]);
     memset(zero_data.get(), 0, image_size);
   }
 
-  WrappedTexImage2D(GL_TEXTURE_2D,
-                    0,  // mip level
-                    format,
-                    size.width(),
-                    size.height(),
-                    0,  // border
-                    format,
-                    GL_UNSIGNED_BYTE,
-                    zero_data.get());
+  glTexImage2D(GL_TEXTURE_2D,
+               0,  // mip level
+               format,
+               size.width(),
+               size.height(),
+               0,  // border
+               format,
+               GL_UNSIGNED_BYTE,
+               zero_data.get());
 
   size_ = size;
 
   bool success = glGetError() == GL_NO_ERROR;
   if (success) {
     memory_tracker_.TrackMemFree(bytes_allocated_);
     bytes_allocated_ = image_size;
     memory_tracker_.TrackMemAlloc(bytes_allocated_);
   }
   return success;
@@ skipping 5402 matching lines @@
   scoped_ptr<char[]> zero(new char[size]);
   memset(zero.get(), 0, size);
   glBindTexture(bind_target, service_id);
 
   GLint y = 0;
   while (y < height) {
     GLint h = y + tile_height > height ? height - y : tile_height;
     if (is_texture_immutable || h != height) {
       glTexSubImage2D(target, level, 0, y, width, h, format, type, zero.get());
     } else {
-      WrappedTexImage2D(
+      glTexImage2D(
           target, level, format, width, h, 0, format, type, zero.get());
     }
     y += tile_height;
   }
   Texture* texture = GetTextureInfoForTarget(bind_target);
   glBindTexture(bind_target, texture ? texture->service_id() : 0);
   return true;
 }
 
 namespace {
@@ skipping 470 matching lines @@
   }
 
   if (!teximage2d_faster_than_texsubimage2d_ && level_is_same && pixels) {
     glTexSubImage2D(target, level, 0, 0, width, height, format, type, pixels);
     texture_manager()->SetLevelCleared(texture, target, level, true);
     tex_image_2d_failed_ = false;
     return;
   }
 
   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("glTexImage2D");
-  WrappedTexImage2D(
+  glTexImage2D(
       target, level, internal_format, width, height, border, format, type,
       pixels);
   GLenum error = LOCAL_PEEK_GL_ERROR("glTexImage2D");
   if (error == GL_NO_ERROR) {
     texture_manager()->SetLevelInfo(
         texture,
         target, level, internal_format, width, height, 1, border, format, type,
         pixels != NULL);
     tex_image_2d_failed_ = false;
   }
@@ skipping 471 matching lines @@
     ScopedTextureUploadTimer timer(this);
     glTexSubImage2D(
         target, level, xoffset, yoffset, width, height, format, type, data);
     return error::kNoError;
   }
 
   if (teximage2d_faster_than_texsubimage2d_ && !texture->IsImmutable()) {
     ScopedTextureUploadTimer timer(this);
     // NOTE: In OpenGL ES 2.0 border is always zero and format is always the
     // same as internal_foramt. If that changes we'll need to look them up.
-    WrappedTexImage2D(
+    glTexImage2D(
         target, level, format, width, height, 0, format, type, data);
   } else {
     ScopedTextureUploadTimer timer(this);
     glTexSubImage2D(
         target, level, xoffset, yoffset, width, height, format, type, data);
   }
   texture_manager()->SetLevelCleared(texture, target, level, true);
   return error::kNoError;
 }
 
@@ skipping 1313 matching lines @@
   }
 
   // Resize the destination texture to the dimensions of the source texture.
   if (!dest_level_defined || dest_width != source_width ||
       dest_height != source_height ||
       dest_internal_format != internal_format ||
       dest_type_previous != dest_type) {
     // Ensure that the glTexImage2D succeeds.
     LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("glCopyTextureCHROMIUM");
     glBindTexture(GL_TEXTURE_2D, dest_texture->service_id());
-    WrappedTexImage2D(
+    glTexImage2D(
         GL_TEXTURE_2D, level, internal_format, source_width, source_height,
         0, internal_format, dest_type, NULL);
     GLenum error = LOCAL_PEEK_GL_ERROR("glCopyTextureCHROMIUM");
     if (error != GL_NO_ERROR) {
       RestoreCurrentTexture2DBindings();
       return;
     }
 
     texture_manager()->SetLevelInfo(
         dest_texture, GL_TEXTURE_2D, level, internal_format, source_width,
@@ skipping 133 matching lines @@
       level_height = std::max(1, level_height >> 1);
     }
     if (!EnsureGPUMemoryAvailable(estimated_size)) {
       LOCAL_SET_GL_ERROR(
           GL_OUT_OF_MEMORY, "glTexStorage2DEXT", "out of memory");
       return;
     }
   }
 
   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("glTexStorage2DEXT");
-  glTexStorage2DEXT(target, levels, GetTexInternalFormat(internal_format),
-                    width, height);
+  glTexStorage2DEXT(target, levels, internal_format, width, height);
   GLenum error = LOCAL_PEEK_GL_ERROR("glTexStorage2DEXT");
   if (error == GL_NO_ERROR) {
     GLsizei level_width = width;
     GLsizei level_height = height;
     for (int ii = 0; ii < levels; ++ii) {
       texture_manager()->SetLevelInfo(
           texture, target, ii, format, level_width, level_height, 1, 0, format,
           type, false);
       level_width = std::max(1, level_width >> 1);
       level_height = std::max(1, level_height >> 1);
@@ skipping 374 matching lines @@
 
   // We know the memory/size is safe, so get the real shared memory since
   // it might need to be duped to prevent use-after-free of the memory.
   gpu::Buffer buffer = GetSharedMemoryBuffer(c.pixels_shm_id);
   base::SharedMemory* shared_memory = buffer.shared_memory;
   uint32 shm_size = buffer.size;
   uint32 shm_data_offset = c.pixels_shm_offset;
   uint32 shm_data_size = pixels_size;
 
   // Setup the parameters.
-  GLenum gl_internal_format =
-      GetTexInternalFormat(internal_format, format, type);
-  gfx::AsyncTexImage2DParams tex_params = {target, level, gl_internal_format,
+  gfx::AsyncTexImage2DParams tex_params = {target, level, internal_format,
                                            width, height, border, format, type};
   gfx::AsyncMemoryParams mem_params = {shared_memory, shm_size,
                                        shm_data_offset, shm_data_size};
 
   // Set up the async state if needed, and make the texture
   // immutable so the async state stays valid. The level info
   // is set up lazily when the transfer completes.
   DCHECK(!texture->GetAsyncTransferState());
   texture->SetAsyncTransferState(
       make_scoped_ptr(
@@ skipping 128 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