gpu: Add support for GLX_EXT_texture_from_pixmap extension.

gpu/command_buffer/service/texture_manager.cc

Index: gpu/command_buffer/service/texture_manager.cc
diff --git a/gpu/command_buffer/service/texture_manager.cc b/gpu/command_buffer/service/texture_manager.cc
index fbbdec6b91f0e203adff5b9523eec40e957dee12..b16d4bf526c9eb961f4172267206799a623b56b0 100644
--- a/gpu/command_buffer/service/texture_manager.cc
+++ b/gpu/command_buffer/service/texture_manager.cc
@@ -224,7 +224,8 @@ bool TextureManager::TextureInfo::CanGenerateMipmaps(
         (info.internal_format != first.internal_format) ||
         (info.type != first.type) ||
         feature_info->validators()->compressed_texture_format.IsValid(
-            info.internal_format)) {
+            info.internal_format) ||
+        info.image) {
         return false;
     }
   }
@@ -299,6 +300,7 @@ void TextureManager::TextureInfo::SetLevelInfo(
   info.border = border;
   info.format = format;
   info.type = type;
+  info.image = 0;
 
   estimated_size_ -= info.estimated_size;
   GLES2Util::ComputeImageDataSizes(
@@ -588,6 +590,36 @@ bool TextureManager::TextureInfo::ClearLevel(
   return info.cleared;
 }
 
+void TextureManager::TextureInfo::SetLevelImage(
+    const FeatureInfo* feature_info,
+    GLenum target,
+    GLint level,
+    scoped_refptr<gfx::GLImage> image) {
+  DCHECK_GE(level, 0);

[apatrick_chromium, 2012/10/11 23:09:57]

Should these range checks be stronger than DCHECKs? It seems a buggy /
compromised renderer might pass out an out-of-ranger level.

[reveman, 2012/10/12 03:29:11]

I think it should be consistent with SetLevelInfo. The decoder currently
protects against a bad value being passed to SetLevelInfo by calling
TextureManager::ValidForTarget before using a level value from the renderer with
this function. The same should be done for SetLevelImage() if the renderer is
ever allowed to specify the level here.

+  DCHECK_LT(static_cast<size_t>(GLTargetToFaceIndex(target)),
+            level_infos_.size());
+  DCHECK_LT(static_cast<size_t>(level),
+            level_infos_[GLTargetToFaceIndex(target)].size());
+  TextureInfo::LevelInfo& info =
+      level_infos_[GLTargetToFaceIndex(target)][level];
+  DCHECK_EQ(info.target, target);
+  DCHECK_EQ(info.level, level);
+  info.image = image;
+}
+
+scoped_refptr<gfx::GLImage> TextureManager::TextureInfo::GetLevelImage(
+  GLint face, GLint level) const {
+  size_t face_index = GLTargetToFaceIndex(face);
+  if (level >= 0 && face_index < level_infos_.size() &&
+      static_cast<size_t>(level) < level_infos_[face_index].size()) {
+    const LevelInfo& info = level_infos_[GLTargetToFaceIndex(face)][level];
+    if (info.target != 0) {
+      return info.image;
+    }
+  }
+  return 0;
+}
+
 TextureManager::TextureManager(
     FeatureInfo* feature_info,
     GLint max_texture_size,
@@ -1047,6 +1079,29 @@ GLsizei TextureManager::ComputeMipMapCount(
   return 1 + base::bits::Log2Floor(std::max(std::max(width, height), depth));
 }
 
+void TextureManager::SetLevelImage(
+    TextureManager::TextureInfo* info,
+    GLenum target,
+    GLint level,
+    scoped_refptr<gfx::GLImage> image) {
+  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_;
+  }
+  info->SetLevelImage(feature_info_, target, level, image);
+  if (!info->CanRender(feature_info_)) {
+    ++num_unrenderable_textures_;
+  }
+  if (!info->SafeToRenderFrom()) {
+    ++num_unsafe_textures_;
+  }
+}
+
 }  // namespace gles2
 }  // namespace gpu