Reuse GLES2Util code instead of defining new function in TextureManager

gpu/command_buffer/service/texture_manager.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/texture_manager.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bits.h"
 #include "base/strings/stringprintf.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/context_state.h"
 #include "gpu/command_buffer/service/error_state.h"
 #include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/framebuffer_manager.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "gpu/command_buffer/service/mailbox_manager.h"
 #include "gpu/command_buffer/service/memory_tracking.h"
 
 namespace gpu {
 namespace gles2 {
 
-static size_t GLTargetToFaceIndex(GLenum target) {
-  switch (target) {
-    case GL_TEXTURE_2D:
-    case GL_TEXTURE_EXTERNAL_OES:
-    case GL_TEXTURE_RECTANGLE_ARB:
-      return 0;
-    case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
-      return 0;
-    case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
-      return 1;
-    case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
-      return 2;
-    case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
-      return 3;
-    case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
-      return 4;
-    case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
-      return 5;
-    default:
-      NOTREACHED();
-      return 0;
-  }
-}
-
-static size_t FaceIndexToGLTarget(size_t index) {
-  switch (index) {
-    case 0:
-      return GL_TEXTURE_CUBE_MAP_POSITIVE_X;
-    case 1:
-      return GL_TEXTURE_CUBE_MAP_NEGATIVE_X;
-    case 2:
-      return GL_TEXTURE_CUBE_MAP_POSITIVE_Y;
-    case 3:
-      return GL_TEXTURE_CUBE_MAP_NEGATIVE_Y;
-    case 4:
-      return GL_TEXTURE_CUBE_MAP_POSITIVE_Z;
-    case 5:
-      return GL_TEXTURE_CUBE_MAP_NEGATIVE_Z;
-    default:
-      NOTREACHED();
-      return 0;
-  }
-}
-
 TextureManager::DestructionObserver::DestructionObserver() {}
 
 TextureManager::DestructionObserver::~DestructionObserver() {}
 
 TextureManager::~TextureManager() {
   for (unsigned int i = 0; i < destruction_observers_.size(); i++)
     destruction_observers_[i]->OnTextureManagerDestroying(this);
 
   DCHECK(textures_.empty());
 
@@ skipping 172 matching lines @@
 }
 
 void Texture::AddToSignature(
     const FeatureInfo* feature_info,
     GLenum target,
     GLint level,
     std::string* signature) const {
   DCHECK(feature_info);
   DCHECK(signature);
   DCHECK_GE(level, 0);
-  DCHECK_LT(static_cast<size_t>(GLTargetToFaceIndex(target)),
+  size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
+  DCHECK_LT(static_cast<size_t>(face_index),
             level_infos_.size());
   DCHECK_LT(static_cast<size_t>(level),
-            level_infos_[GLTargetToFaceIndex(target)].size());
+            level_infos_[face_index].size());
   const Texture::LevelInfo& info =
-      level_infos_[GLTargetToFaceIndex(target)][level];
+      level_infos_[face_index][level];
   *signature += base::StringPrintf(
       "|Texture|target=%04x|level=%d|internal_format=%04x"
       "|width=%d|height=%d|depth=%d|border=%d|format=%04x|type=%04x"
       "|image=%d|canrender=%d|canrenderto=%d|npot_=%d"
       "|min_filter=%04x|mag_filter=%04x|wrap_s=%04x|wrap_t=%04x"
       "|usage=%04x",
       target, level, info.internal_format,
       info.width, info.height, info.depth, info.border,
       info.format, info.type, info.image.get() != NULL,
       CanRender(feature_info), CanRenderTo(), npot_,
@@ skipping 10 matching lines @@
     const FeatureInfo* feature_info) {
   if (!CanGenerateMipmaps(feature_info)) {
     return false;
   }
   for (size_t ii = 0; ii < level_infos_.size(); ++ii) {
     const Texture::LevelInfo& info1 = level_infos_[ii][0];
     GLsizei width = info1.width;
     GLsizei height = info1.height;
     GLsizei depth = info1.depth;
     GLenum target = target_ == GL_TEXTURE_2D ? GL_TEXTURE_2D :
-                               FaceIndexToGLTarget(ii);
+                               GLES2Util::IndexToGLFaceTarget(ii);
     int num_mips =
         TextureManager::ComputeMipMapCount(target_, width, height, depth);
     for (int level = 1; level < num_mips; ++level) {
       width = std::max(1, width >> 1);
       height = std::max(1, height >> 1);
       depth = std::max(1, depth >> 1);
       SetLevelInfo(feature_info,
                    target,
                    level,
                    info1.internal_format,
@@ skipping 60 matching lines @@
             info.internal_format) ||
         info.image.get()) {
       return false;
     }
   }
   return true;
 }
 
 void Texture::SetLevelCleared(GLenum target, GLint level, bool cleared) {
   DCHECK_GE(level, 0);
-  DCHECK_LT(static_cast<size_t>(GLTargetToFaceIndex(target)),
+  size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
+  DCHECK_LT(static_cast<size_t>(face_index),
             level_infos_.size());
   DCHECK_LT(static_cast<size_t>(level),
-            level_infos_[GLTargetToFaceIndex(target)].size());
+            level_infos_[face_index].size());
   Texture::LevelInfo& info =
-      level_infos_[GLTargetToFaceIndex(target)][level];
+      level_infos_[face_index][level];
   UpdateMipCleared(&info, cleared);
   UpdateCleared();
 }
 
 void Texture::UpdateCleared() {
   if (level_infos_.empty()) {
     return;
   }
 
   const Texture::LevelInfo& first_face = level_infos_[0][0];
@@ skipping 83 matching lines @@
     GLint level,
     GLenum internal_format,
     GLsizei width,
     GLsizei height,
     GLsizei depth,
     GLint border,
     GLenum format,
     GLenum type,
     bool cleared) {
   DCHECK_GE(level, 0);
-  DCHECK_LT(static_cast<size_t>(GLTargetToFaceIndex(target)),
+  size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
+  DCHECK_LT(static_cast<size_t>(face_index),
             level_infos_.size());
   DCHECK_LT(static_cast<size_t>(level),
-            level_infos_[GLTargetToFaceIndex(target)].size());
+            level_infos_[face_index].size());
   DCHECK_GE(width, 0);
   DCHECK_GE(height, 0);
   DCHECK_GE(depth, 0);
   Texture::LevelInfo& info =
-      level_infos_[GLTargetToFaceIndex(target)][level];
+      level_infos_[face_index][level];
   info.target = target;
   info.level = level;
   info.internal_format = internal_format;
   info.width = width;
   info.height = height;
   info.depth = depth;
   info.border = border;
   info.format = format;
   info.type = type;
   info.image = 0;
@@ skipping 17 matching lines @@
 }
 
 bool Texture::ValidForTexture(
     GLint target,
     GLint level,
     GLint xoffset,
     GLint yoffset,
     GLsizei width,
     GLsizei height,
     GLenum type) const {
-  size_t face_index = GLTargetToFaceIndex(target);
+  size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
   if (level >= 0 && face_index < level_infos_.size() &&
       static_cast<size_t>(level) < level_infos_[face_index].size()) {
-    const LevelInfo& info = level_infos_[GLTargetToFaceIndex(target)][level];
+    const LevelInfo& info = level_infos_[face_index][level];
     int32 right;
     int32 top;
     return SafeAddInt32(xoffset, width, &right) &&
            SafeAddInt32(yoffset, height, &top) &&
            xoffset >= 0 &&
            yoffset >= 0 &&
            right <= info.width &&
            top <= info.height &&
            type == info.type;
   }
   return false;
 }
 
 bool Texture::GetLevelSize(
     GLint target, GLint level, GLsizei* width, GLsizei* height) const {
   DCHECK(width);
   DCHECK(height);
-  size_t face_index = GLTargetToFaceIndex(target);
+  size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
   if (level >= 0 && face_index < level_infos_.size() &&
       static_cast<size_t>(level) < level_infos_[face_index].size()) {
-    const LevelInfo& info = level_infos_[GLTargetToFaceIndex(target)][level];
+    const LevelInfo& info = level_infos_[face_index][level];
     if (info.target != 0) {
       *width = info.width;
       *height = info.height;
       return true;
     }
   }
   return false;
 }
 
 bool Texture::GetLevelType(
     GLint target, GLint level, GLenum* type, GLenum* internal_format) const {
   DCHECK(type);
   DCHECK(internal_format);
-  size_t face_index = GLTargetToFaceIndex(target);
+  size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
   if (level >= 0 && face_index < level_infos_.size() &&
       static_cast<size_t>(level) < level_infos_[face_index].size()) {
-    const LevelInfo& info = level_infos_[GLTargetToFaceIndex(target)][level];
+    const LevelInfo& info = level_infos_[face_index][level];
     if (info.target != 0) {
       *type = info.type;
       *internal_format = info.internal_format;
       return true;
     }
   }
   return false;
 }
 
 GLenum Texture::SetParameteri(
@@ skipping 189 matching lines @@
           return false;
         }
       }
     }
   }
   UpdateSafeToRenderFrom(true);
   return true;
 }
 
 bool Texture::IsLevelCleared(GLenum target, GLint level) const {
-  size_t face_index = GLTargetToFaceIndex(target);
+  size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
   if (face_index >= level_infos_.size() ||
       level >= static_cast<GLint>(level_infos_[face_index].size())) {
     return true;
   }
 
   const Texture::LevelInfo& info = level_infos_[face_index][level];
 
   return info.cleared;
 }
 
 void Texture::InitTextureMaxAnisotropyIfNeeded(GLenum target) {
   if (texture_max_anisotropy_initialized_)
     return;
   texture_max_anisotropy_initialized_ = true;
   GLfloat params[] = { 1.0f };
   glTexParameterfv(target, GL_TEXTURE_MAX_ANISOTROPY_EXT, params);
 }
 
 bool Texture::ClearLevel(
     GLES2Decoder* decoder, GLenum target, GLint level) {
   DCHECK(decoder);
-  size_t face_index = GLTargetToFaceIndex(target);
+  size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
   if (face_index >= level_infos_.size() ||
       level >= static_cast<GLint>(level_infos_[face_index].size())) {
     return true;
   }
 
   Texture::LevelInfo& info = level_infos_[face_index][level];
 
   DCHECK(target == info.target);
 
   if (info.target == 0 ||
@@ skipping 13 matching lines @@
   UpdateMipCleared(&info, cleared);
   return info.cleared;
 }
 
 void Texture::SetLevelImage(
     const FeatureInfo* feature_info,
     GLenum target,
     GLint level,
     gfx::GLImage* image) {
   DCHECK_GE(level, 0);
-  DCHECK_LT(static_cast<size_t>(GLTargetToFaceIndex(target)),
+  size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
+  DCHECK_LT(static_cast<size_t>(face_index),
             level_infos_.size());
   DCHECK_LT(static_cast<size_t>(level),
-            level_infos_[GLTargetToFaceIndex(target)].size());
+            level_infos_[face_index].size());
   Texture::LevelInfo& info =
-      level_infos_[GLTargetToFaceIndex(target)][level];
+      level_infos_[face_index][level];
   DCHECK_EQ(info.target, target);
   DCHECK_EQ(info.level, level);
   info.image = image;
   UpdateCanRenderCondition();
   UpdateHasImages();
 }
 
 gfx::GLImage* Texture::GetLevelImage(GLint target, GLint level) const {
   if (target != GL_TEXTURE_2D && target != GL_TEXTURE_EXTERNAL_OES &&
       target != GL_TEXTURE_RECTANGLE_ARB) {
     return NULL;
   }
 
-  size_t face_index = GLTargetToFaceIndex(target);
+  size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
   if (level >= 0 && face_index < level_infos_.size() &&
       static_cast<size_t>(level) < level_infos_[face_index].size()) {
-    const LevelInfo& info = level_infos_[GLTargetToFaceIndex(target)][level];
+    const LevelInfo& info = level_infos_[face_index][level];
     if (info.target != 0) {
       return info.image.get();
     }
   }
-  return 0;
+  return NULL;
 }
 
 void Texture::OnWillModifyPixels() {
   gfx::GLImage* image = GetLevelImage(target(), 0);
   if (image)
     image->WillModifyTexImage();
 }
 
 void Texture::OnDidModifyPixels() {
   gfx::GLImage* image = GetLevelImage(target(), 0);
@@ skipping 706 matching lines @@
 }
 
 ScopedTextureUploadTimer::~ScopedTextureUploadTimer() {
   texture_state_->texture_upload_count++;
   texture_state_->total_texture_upload_time +=
       base::TimeTicks::HighResNow() - begin_time_;
 }
 
 }  // namespace gles2
 }  // namespace gpu