Allow immutable textures into mailboxes

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 843 matching lines @@
     ++num_unsafe_textures_;
   }
 }
 
 TextureDefinition* TextureManager::Save(TextureInfo* info) {
   DCHECK(info->owned_);
 
   if (info->IsAttachedToFramebuffer())
     return NULL;
 
-  if (info->IsImmutable())
-    return NULL;
-
   TextureDefinition::LevelInfos level_infos(info->level_infos_.size());
   for (size_t face = 0; face < level_infos.size(); ++face) {
     GLenum target = info->target() == GL_TEXTURE_2D ?
         GL_TEXTURE_2D : FaceIndexToGLTarget(face);
     for (size_t level = 0; level < info->level_infos_[face].size(); ++level) {
       const TextureInfo::LevelInfo& level_info =
           info->level_infos_[face][level];
       level_infos[face].push_back(
           TextureDefinition::LevelInfo(target,
                                        level_info.internal_format,
                                        level_info.width,
                                        level_info.height,
                                        level_info.depth,
                                        level_info.border,
                                        level_info.format,
                                        level_info.type,
                                        level_info.cleared));
 
       SetLevelInfo(info,

[apatrick_chromium, 2012/09/24 22:55:16]

Should a immutable texture object that has been produced become mutable?

[piman, 2012/09/24 22:59:50]

That seems reasonable. done.

                    target,
                    level,
                    GL_RGBA,
                    0,
                    0,
                    0,
                    0,
                    GL_RGBA,
                    GL_UNSIGNED_BYTE,
                    true);
     }
   }
 
   GLuint old_service_id = info->service_id();
 
   GLuint new_service_id = 0;
   glGenTextures(1, &new_service_id);
   info->SetServiceId(new_service_id);
 
   return new TextureDefinition(info->target(),
                                old_service_id,
+                               info->IsImmutable(),
                                level_infos);
 }
 
 bool TextureManager::Restore(TextureInfo* info,
                              TextureDefinition* definition) {
   DCHECK(info->owned_);
 
   scoped_ptr<TextureDefinition> scoped_definition(definition);
 
   if (info->IsAttachedToFramebuffer())
     return false;
 
-  if (info->IsImmutable())
-    return false;
+  //if (info->IsImmutable())

[apatrick_chromium, 2012/09/24 22:55:16]

This can be deleted.

[piman, 2012/09/24 22:59:50]

Of course! Done.

+  //  return false;
 
   if (info->target() != definition->target())
     return false;
 
   if (info->level_infos_.size() != definition->level_infos().size())
     return false;
 
   if (info->level_infos_[0].size() != definition->level_infos()[0].size())
     return false;
 
@@ skipping 13 matching lines @@
                    level_info.border,
                    level_info.format,
                    level_info.type,
                    level_info.cleared);
     }
   }
 
   GLuint old_service_id = info->service_id();
   glDeleteTextures(1, &old_service_id);
   info->SetServiceId(definition->ReleaseServiceId());
+  info->SetImmutable(definition->immutable());
 
   return true;
 }
 
 bool TextureManager::SetParameter(
     TextureManager::TextureInfo* info, GLenum pname, GLint param) {
   DCHECK(info);
   if (!info->CanRender(feature_info_)) {
     DCHECK_NE(0, num_unrenderable_textures_);
     --num_unrenderable_textures_;
@@ skipping 103 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));
 }
 
 }  // namespace gles2
 }  // namespace gpu