Adds tracking of number of unrenderable textures so...

gpu/command_buffer/service/gles2_cmd_decoder.cc

 // Copyright (c) 2009 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/gles2_cmd_decoder.h"
 
 #include <stdio.h>
 
 #include <algorithm>
 #include <list>
@@ skipping 972 matching lines @@
   // errors caused by GL calls that it was not responsible for issuing.
   void ClearRealGLErrors();
 
   // Checks if the current program and vertex attributes are valid for drawing.
   bool IsDrawValid(GLuint max_vertex_accessed);
 
   // Returns true if attrib0 was simulated.
   bool SimulateAttrib0(GLuint max_vertex_accessed);
   void RestoreStateForSimulatedAttrib0();
 
-  void SetBlackTextureForNonRenderableTextures(
-      bool* has_non_renderable_textures);
+  // Returns true of textures were set.

[apatrick_chromium, 2010/06/02 22:20:56]

of -> if

+  bool SetBlackTextureForNonRenderableTextures();
   void RestoreStateForNonRenderableTextures();
 
   // Gets the buffer id for a given target.
   BufferManager::BufferInfo* GetBufferInfoForTarget(GLenum target) {
     DCHECK(target == GL_ARRAY_BUFFER || target == GL_ELEMENT_ARRAY_BUFFER);
     BufferManager::BufferInfo* info = target == GL_ARRAY_BUFFER ?
         bound_array_buffer_ : bound_element_array_buffer_;
     return (info && !info->IsDeleted()) ? info : NULL;
   }
 
@@ skipping 817 matching lines @@
 
     // Update the info about the offscreen saved color texture in the parent.
     // The reference to the parent is a weak pointer and will become null if the
     // parent is later destroyed.
     GLuint service_id = offscreen_saved_color_texture_->id();
 
     TextureManager::TextureInfo* info =
         parent_->texture_manager()->GetTextureInfo(service_id);
     DCHECK(info);
 
-    info->SetLevelInfo(GL_TEXTURE_2D,
-                       0,  // level
-                       GL_RGBA,
-                       pending_offscreen_size_.width(),
-                       pending_offscreen_size_.height(),
-                       1,  // depth
-                       0,  // border
-                       GL_RGBA,
-                       GL_UNSIGNED_BYTE);
+    texture_manager()->SetLevelInfo(
+        info,
+        GL_TEXTURE_2D,
+        0,  // level
+        GL_RGBA,
+        pending_offscreen_size_.width(),
+        pending_offscreen_size_.height(),
+        1,  // depth
+        0,  // border
+        GL_RGBA,
+        GL_UNSIGNED_BYTE);
   }
 
   return true;
 }
 
 void GLES2DecoderImpl::SetSwapBuffersCallback(Callback0::Type* callback) {
   swap_buffers_callback_.reset(callback);
 }
 
 void GLES2DecoderImpl::Destroy() {
@@ skipping 306 matching lines @@
   if (vertex_attrib_manager_.Enable(index, true)) {
     glEnableVertexAttribArray(index);
   } else {
     SetGLError(GL_INVALID_VALUE,
                "glEnableVertexAttribArray: index out of range");
   }
 }
 
 void GLES2DecoderImpl::DoGenerateMipmap(GLenum target) {
   TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
-  if (!info || !info->MarkMipmapsGenerated()) {
+  if (!info || !texture_manager()->MarkMipmapsGenerated(info)) {
     SetGLError(GL_INVALID_OPERATION,
                "glGenerateMipmaps: Can not generate mips for npot textures");
     return;
   }
   glGenerateMipmapEXT(target);
 }
 
 bool GLES2DecoderImpl::GetHelper(
     GLenum pname, GLint* params, GLsizei* num_written) {
   DCHECK(num_written);
@@ skipping 399 matching lines @@
   if (ids == NULL) {
     return error::kOutOfBounds;
   }
   DoRegisterSharedIds(namespace_id, n, ids);
   return error::kNoError;
 }
 
 void GLES2DecoderImpl::DoDrawArrays(
     GLenum mode, GLint first, GLsizei count) {
   if (IsDrawValid(first + count - 1)) {
-    bool has_non_renderable_textures;
     bool simulated_attrib_0 = SimulateAttrib0(first + count - 1);
-    SetBlackTextureForNonRenderableTextures(&has_non_renderable_textures);
+    bool textures_set = SetBlackTextureForNonRenderableTextures();
     glDrawArrays(mode, first, count);
-    if (has_non_renderable_textures) {
+    if (textures_set) {
       RestoreStateForNonRenderableTextures();
     }
     if (simulated_attrib_0) {
       RestoreStateForSimulatedAttrib0();
     }
   }
 }
 
 void GLES2DecoderImpl::DoFramebufferRenderbuffer(
     GLenum target, GLenum attachment, GLenum renderbuffertarget,
@@ skipping 91 matching lines @@
     info->Reset();
   }
 };
 
 void GLES2DecoderImpl::DoTexParameterf(
     GLenum target, GLenum pname, GLfloat param) {
   TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
   if (!info) {
     SetGLError(GL_INVALID_VALUE, "glTexParameterf: unknown texture");
   } else {
-    info->SetParameter(pname, static_cast<GLint>(param));
+    texture_manager()->SetParameter(info, pname, static_cast<GLint>(param));
     glTexParameterf(target, pname, param);
   }
 }
 
 void GLES2DecoderImpl::DoTexParameteri(
     GLenum target, GLenum pname, GLint param) {
   TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
   if (!info) {
     SetGLError(GL_INVALID_VALUE, "glTexParameteri: unknown texture");
   } else {
-    info->SetParameter(pname, param);
+    texture_manager()->SetParameter(info, pname, param);
     glTexParameteri(target, pname, param);
   }
 }
 
 void GLES2DecoderImpl::DoTexParameterfv(
     GLenum target, GLenum pname, const GLfloat* params) {
   TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
   if (!info) {
     SetGLError(GL_INVALID_VALUE, "glTexParameterfv: unknown texture");
   } else {
-    info->SetParameter(pname, *reinterpret_cast<const GLint*>(params));
+    texture_manager()->SetParameter(
+        info, pname, *reinterpret_cast<const GLint*>(params));
     glTexParameterfv(target, pname, params);
   }
 }
 
 void GLES2DecoderImpl::DoTexParameteriv(
   GLenum target, GLenum pname, const GLint* params) {
   TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
   if (!info) {
     SetGLError(GL_INVALID_VALUE, "glTexParameteriv: unknown texture");
   } else {
-    info->SetParameter(pname, *params);
+    texture_manager()->SetParameter(info, pname, *params);
     glTexParameteriv(target, pname, params);
   }
 }
 
 bool GLES2DecoderImpl::CheckCurrentProgram(const char* function_name) {
   if (!current_program_ || current_program_->IsDeleted()) {
       // The program does not exist.
       SetGLError(GL_INVALID_OPERATION,
                  (std::string(function_name) + ": no program in use").c_str());
       return false;
@@ skipping 169 matching lines @@
   }
 }
 
 void GLES2DecoderImpl::ClearRealGLErrors() {
   GLenum error;
   while ((error = glGetError()) != GL_NO_ERROR) {
     NOTREACHED() << "GL error " << error << " was unhandled.";
   }
 }
 
-void GLES2DecoderImpl::SetBlackTextureForNonRenderableTextures(
-    bool* has_non_renderable_textures) {
-  DCHECK(has_non_renderable_textures);
+bool GLES2DecoderImpl::SetBlackTextureForNonRenderableTextures() {
   DCHECK(current_program_);
   DCHECK(!current_program_->IsDeleted());
-  *has_non_renderable_textures = false;
+  // Only check if there are some unrenderable textures.
+  if (!texture_manager()->HaveUnrenderableTextures()) {
+    return false;
+  }
+  bool textures_set = false;
   const ProgramManager::ProgramInfo::SamplerIndices& sampler_indices =
      current_program_->sampler_indices();
   for (size_t ii = 0; ii < sampler_indices.size(); ++ii) {
     const ProgramManager::ProgramInfo::UniformInfo* uniform_info =
         current_program_->GetUniformInfo(sampler_indices[ii]);
     DCHECK(uniform_info);
     for (size_t jj = 0; jj < uniform_info->texture_units.size(); ++jj) {
       GLuint texture_unit_index = uniform_info->texture_units[jj];
       if (texture_unit_index < group_->max_texture_units()) {
         TextureUnit& texture_unit = texture_units_[texture_unit_index];
         TextureManager::TextureInfo* texture_info =
             uniform_info->type == GL_SAMPLER_2D ?
                 texture_unit.bound_texture_2d :
                 texture_unit.bound_texture_cube_map;
         if (!texture_info || !texture_info->CanRender()) {
-          *has_non_renderable_textures = true;
+          textures_set = true;
           glActiveTexture(GL_TEXTURE0 + texture_unit_index);
           glBindTexture(
               uniform_info->type == GL_SAMPLER_2D ? GL_TEXTURE_2D :
                                                     GL_TEXTURE_CUBE_MAP,
               uniform_info->type == GL_SAMPLER_2D ? black_2d_texture_id_ :
                                                     black_cube_texture_id_);
         }
       }
       // else: should this be an error?
     }
   }
+  return textures_set;
 }
 
 void GLES2DecoderImpl::RestoreStateForNonRenderableTextures() {
   DCHECK(current_program_);
   DCHECK(!current_program_->IsDeleted());
   const ProgramManager::ProgramInfo::SamplerIndices& sampler_indices =
      current_program_->sampler_indices();
   for (size_t ii = 0; ii < sampler_indices.size(); ++ii) {
     const ProgramManager::ProgramInfo::UniformInfo* uniform_info =
         current_program_->GetUniformInfo(sampler_indices[ii]);
@@ skipping 150 matching lines @@
 
   GLuint max_vertex_accessed;
   if (!bound_element_array_buffer_->GetMaxValueForRange(
       offset, count, type, &max_vertex_accessed)) {
     SetGLError(GL_INVALID_OPERATION,
                "glDrawElements: range out of bounds for buffer");
     return error::kNoError;
   }
 
   if (IsDrawValid(max_vertex_accessed)) {
-    bool has_non_renderable_textures;
     bool simulated_attrib_0 = SimulateAttrib0(max_vertex_accessed);
-    SetBlackTextureForNonRenderableTextures(
-        &has_non_renderable_textures);
+    bool textures_set = SetBlackTextureForNonRenderableTextures();
     const GLvoid* indices = reinterpret_cast<const GLvoid*>(offset);
     glDrawElements(mode, count, type, indices);
-    if (has_non_renderable_textures) {
+    if (textures_set) {
       RestoreStateForNonRenderableTextures();
     }
     if (simulated_attrib_0) {
       RestoreStateForSimulatedAttrib0();
     }
   }
   return error::kNoError;
 }
 
 GLuint GLES2DecoderImpl::DoGetMaxValueInBuffer(
@@ skipping 961 matching lines @@
     SetGLError(GL_INVALID_VALUE,
                "glCompressedTexImage2D: unknown texture target");
     return error::kNoError;
   }
   scoped_array<int8> zero;
   if (!data) {
     zero.reset(new int8[image_size]);
     memset(zero.get(), 0, image_size);
     data = zero.get();
   }
-  info->SetLevelInfo(
-      target, level, internal_format, width, height, 1, border, 0, 0);
+  texture_manager()->SetLevelInfo(
+      info, target, level, internal_format, width, height, 1, border, 0, 0);
   glCompressedTexImage2D(
       target, level, internal_format, width, height, border, image_size, data);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleCompressedTexImage2D(
     uint32 immediate_data_size, const gles2::CompressedTexImage2D& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLint level = static_cast<GLint>(c.level);
   GLenum internal_format = static_cast<GLenum>(c.internalformat);
@@ skipping 121 matching lines @@
     SetGLError(GL_INVALID_OPERATION,
                "glTexImage2D: unknown texture for target");
     return error::kNoError;
   }
   scoped_array<int8> zero;
   if (!pixels) {
     zero.reset(new int8[pixels_size]);
     memset(zero.get(), 0, pixels_size);
     pixels = zero.get();
   }
-  info->SetLevelInfo(
+  texture_manager()->SetLevelInfo(info,
       target, level, internal_format, width, height, 1, border, format, type);
   glTexImage2D(
       target, level, internal_format, width, height, border, format, type,
       pixels);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleTexImage2D(
     uint32 immediate_data_size, const gles2::TexImage2D& c) {
   GLenum target = static_cast<GLenum>(c.target);
@@ skipping 439 matching lines @@
   return error::kNoError;
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu