gpu: Add support for GLX_EXT_texture_from_pixmap extension.

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 "base/bits.h"
 #include "base/debug/trace_event.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"
@@ skipping 206 matching lines @@
   for (size_t ii = 0; ii < level_infos_.size(); ++ii) {
     const LevelInfo& info = level_infos_[ii][0];
     if ((info.target == 0) ||
         (info.width != first.width) ||
         (info.height != first.height) ||
         (info.depth != 1) ||
         (info.format != first.format) ||
         (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;
     }
   }
   return true;
 }
 
 void TextureManager::TextureInfo::SetLevelCleared(GLenum target, GLint level) {
   DCHECK_GE(level, 0);
   DCHECK_LT(static_cast<size_t>(GLTargetToFaceIndex(target)),
             level_infos_.size());
@@ skipping 54 matching lines @@
       level_infos_[GLTargetToFaceIndex(target)][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;
 
   estimated_size_ -= info.estimated_size;
   GLES2Util::ComputeImageDataSizes(
       width, height, format, type, 4, &info.estimated_size, NULL, NULL);
   estimated_size_ += info.estimated_size;
 
   if (!info.cleared) {
     DCHECK_NE(0, num_uncleared_mips_);
     --num_uncleared_mips_;
   }
@@ skipping 269 matching lines @@
   // needed to be able to call GL correctly.
   info.cleared = decoder->ClearLevel(
       service_id_, target_, info.target, info.level, info.format, info.type,
       info.width, info.height, immutable_);
   if (!info.cleared) {
     ++num_uncleared_mips_;
   }
   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,
     GLint max_cube_map_texture_size)
     : feature_info_(feature_info),
       max_texture_size_(max_texture_size),
       max_cube_map_texture_size_(max_cube_map_texture_size),
       max_levels_(ComputeMipMapCount(max_texture_size,
                                      max_texture_size,
                                      max_texture_size)),
@@ skipping 439 matching lines @@
     }
   }
   return false;
 }
 
 GLsizei TextureManager::ComputeMipMapCount(
     GLsizei width, GLsizei height, GLsizei depth) {
   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