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 "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"
 #include "gpu/command_buffer/service/mailbox_manager.h"
@@ skipping 132 matching lines @@
     : cleared(rhs.cleared),
       target(rhs.target),
       level(rhs.level),
       internal_format(rhs.internal_format),
       width(rhs.width),
       height(rhs.height),
       depth(rhs.depth),
       border(rhs.border),
       format(rhs.format),
       type(rhs.type),
+      image(rhs.image),
       estimated_size(rhs.estimated_size) {
 }
 
+TextureManager::TextureInfo::LevelInfo::~LevelInfo() {
+}
+
 bool TextureManager::TextureInfo::CanRender(
     const FeatureInfo* feature_info) const {
   if (target_ == 0) {
     return false;
   }
   bool needs_mips = NeedsMips();
   if ((npot() && !feature_info->feature_flags().npot_ok) ||
       (target_ == GL_TEXTURE_RECTANGLE_ARB)) {
     return !needs_mips &&
            wrap_s_ == GL_CLAMP_TO_EDGE &&
@@ skipping 79 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,
+    gfx::GLImage* image) {
+  DCHECK_GE(level, 0);
+  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;
+}
+
+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(
     MemoryTracker* memory_tracker,
     FeatureInfo* feature_info,
     GLint max_texture_size,
     GLint max_cube_map_texture_size)
     : texture_memory_tracker_(new MemoryTypeTracker(memory_tracker)),
       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,
@@ skipping 434 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,
+    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