Adds support for the GL_ANGLE_texture_usage and GL_EXT_texture_storage

gpu/command_buffer/service/texture_manager.cc

 // Copyright (c) 2011 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 "base/bits.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
 namespace gpu {
 namespace gles2 {
 
-static GLsizei ComputeMipMapCount(
-    GLsizei width, GLsizei height, GLsizei depth) {
-  return 1 + base::bits::Log2Floor(std::max(std::max(width, height), depth));
-}
-
 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;
@@ skipping 75 matching lines @@
       return texture_complete();
     } else {
       return texture_complete() && cube_complete();
     }
   } else {
     return true;
   }
 }
 
 bool TextureManager::TextureInfo::MarkMipmapsGenerated(
-    const FeatureInfo* feature_info) {
+    const FeatureInfo* feature_info,
+    bool cleared) {
   if (!CanGenerateMipmaps(feature_info)) {
     return false;
   }
   for (size_t ii = 0; ii < level_infos_.size(); ++ii) {
     const TextureInfo::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);
     int num_mips = ComputeMipMapCount(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,
                    width,
                    height,
                    depth,
                    info1.border,
                    info1.format,
                    info1.type,
-                   true);
+                   cleared);
     }
   }
 
   return true;
 }
 
 void TextureManager::TextureInfo::SetTarget(GLenum target, GLint max_levels) {
   DCHECK_EQ(0u, target_);  // you can only set this once.
   target_ = target;
   size_t num_faces = (target == GL_TEXTURE_CUBE_MAP) ? 6 : 1;
@@ skipping 210 matching lines @@
       break;
     case GL_TEXTURE_WRAP_T:
       if (!feature_info->validators()->texture_wrap_mode.IsValid(param)) {
         return false;
       }
       wrap_t_ = param;
       break;
     case GL_TEXTURE_MAX_ANISOTROPY_EXT:
       // Nothing to do for this case at the moment.
       break;
+    case GL_TEXTURE_USAGE_ANGLE:
+      if (!feature_info->validators()->texture_usage.IsValid(param)) {
+        return false;
+      }
+      usage_ = param;
+      break;
     default:
       NOTREACHED();
       return false;
   }
   Update(feature_info);
   UpdateCleared();
   return true;
 }
 
 void TextureManager::TextureInfo::Update(const FeatureInfo* feature_info) {
@@ skipping 401 matching lines @@
     ++num_unrenderable_textures_;
   }
   if (!info->SafeToRenderFrom()) {
     ++num_unsafe_textures_;
   }
   return result;
 }
 
 bool TextureManager::MarkMipmapsGenerated(
     const FeatureInfo* feature_info,
-    TextureManager::TextureInfo* info) {
+    TextureManager::TextureInfo* info,
+    bool cleared) {
   DCHECK(info);
   if (!info->CanRender(feature_info)) {
     DCHECK_NE(0, num_unrenderable_textures_);
     --num_unrenderable_textures_;
   }
   if (!info->SafeToRenderFrom()) {
     DCHECK_NE(0, num_unsafe_textures_);
     --num_unsafe_textures_;
   }
   num_uncleared_mips_ -= info->num_uncleared_mips();
   DCHECK_GE(num_uncleared_mips_, 0);
-  bool result = info->MarkMipmapsGenerated(feature_info);
+  bool result = info->MarkMipmapsGenerated(feature_info, cleared);
   num_uncleared_mips_ += info->num_uncleared_mips();
   if (!info->CanRender(feature_info)) {
     ++num_unrenderable_textures_;
   }
   if (!info->SafeToRenderFrom()) {
     ++num_unsafe_textures_;
   }
   return result;
 }
 
@@ skipping 45 matching lines @@
   for (TextureInfoMap::const_iterator it = texture_infos_.begin();
        it != texture_infos_.end(); ++it) {
     if (it->second->service_id() == service_id) {
       *client_id = it->first;
       return true;
     }
   }
   return false;
 }
 
+GLsizei TextureManager::ComputeMipMapCount(
+    GLsizei width, GLsizei height, GLsizei depth) {
+  return 1 + base::bits::Log2Floor(std::max(std::max(width, height), depth));
+}
+
+
 }  // namespace gles2
 }  // namespace gpu