Fixed service side implementation of glTexStorage2DEXT to only initialize the number of

gpu/command_buffer/service/gles2_cmd_decoder.cc

 // Copyright (c) 2011 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 893 matching lines @@
 
   // overridden from GLES2Decoder
   virtual bool ClearLevel(
       unsigned service_id,
       unsigned bind_target,
       unsigned target,
       int level,
       unsigned format,
       unsigned type,
       int width,
-      int height);
+      int height,
+      bool is_texture_immutable);
 
   // Restore all GL state that affects clearing.
   void RestoreClearState();
 
   // Remembers the state of some capabilities.
   // Returns: true if glEnable/glDisable should actually be called.
   bool SetCapabilityState(GLenum cap, bool enabled);
 
   // Check that the currently bound framebuffers are valid.
   // Generates GL error if not.
@@ skipping 2306 matching lines @@
     glEnableVertexAttribArray(index);
   } else {
     SetGLError(GL_INVALID_VALUE,
                "glEnableVertexAttribArray: index out of range");
   }
 }
 
 void GLES2DecoderImpl::DoGenerateMipmap(GLenum target) {
   TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
   if (!info ||
-      !texture_manager()->MarkMipmapsGenerated(feature_info_, info, true)) {
+      !texture_manager()->MarkMipmapsGenerated(feature_info_, info)) {
     SetGLError(GL_INVALID_OPERATION,
                "glGenerateMipmaps: Can not generate mips for npot textures");
     return;
   }
   // Workaround for Mac driver bug. In the large scheme of things setting
   // glTexParamter twice for glGenerateMipmap is probably not a lage performance
   // hit so there's probably no need to make this conditional. The bug appears
   // to be that if the filtering mode is set to something that doesn't require
   // mipmaps for rendering, or is never set to something other than the default,
   // then glGenerateMipmap misbehaves.
@@ skipping 2884 matching lines @@
 }
 
 bool GLES2DecoderImpl::ClearLevel(
     unsigned service_id,
     unsigned bind_target,
     unsigned target,
     int level,
     unsigned format,
     unsigned type,
     int width,
-    int height) {
+    int height,
+    bool is_texture_immutable) {
   // Assumes the size has already been checked.
   uint32 pixels_size = 0;
   if (!GLES2Util::ComputeImageDataSize(
       width, height, format, type, unpack_alignment_, &pixels_size)) {
     return false;
   }
   scoped_array<char> zero(new char[pixels_size]);
   memset(zero.get(), 0, pixels_size);
   glBindTexture(bind_target, service_id);
-  WrappedTexImage2D(
-      target, level, format, width, height, 0, format, type, zero.get());
+  if (is_texture_immutable) {
+    glTexSubImage2D(
+        target, level, 0, 0, width, height, format, type, zero.get());
+  } else {
+    WrappedTexImage2D(
+        target, level, format, width, height, 0, format, type, zero.get());
+  }
   TextureManager::TextureInfo* info = GetTextureInfoForTarget(bind_target);
   glBindTexture(bind_target, info ? info->service_id() : 0);
   return true;
 }
 
 error::Error GLES2DecoderImpl::DoCompressedTexImage2D(
   GLenum target,
   GLint level,
   GLenum internal_format,
   GLsizei width,
@@ skipping 324 matching lines @@
   if (!info) {
     SetGLError(GL_INVALID_OPERATION,
                "glCompressedTexSubImage2D: unknown texture for target");
     return;
   }
   GLenum type = 0;
   GLenum internal_format = 0;
   if (!info->GetLevelType(target, level, &type, &internal_format)) {
     SetGLError(
         GL_INVALID_OPERATION,
-        "glCompressdTexSubImage2D: level does not exist.");
+        "glCompressedTexSubImage2D: level does not exist.");
     return;
   }
   if (internal_format != format) {
     SetGLError(
         GL_INVALID_OPERATION,
-        "glCompressdTexSubImage2D: format does not match internal format.");
+        "glCompressedTexSubImage2D: format does not match internal format.");
     return;
   }
   if (!info->ValidForTexture(
       target, level, xoffset, yoffset, width, height, format, type)) {
     SetGLError(GL_INVALID_VALUE,
-               "glCompressdTexSubImage2D: bad dimensions.");
+               "glCompressedTexSubImage2D: bad dimensions.");
     return;
   }
   // Note: There is no need to deal with texture cleared tracking here
   // because the validation above means you can only get here if the level
   // is already a matching compressed format and in that case
   // CompressedTexImage2D already cleared the texture.
   glCompressedTexSubImage2D(
       target, level, xoffset, yoffset, width, height, format, image_size, data);
 }
 
@@ skipping 70 matching lines @@
   Clip(x, width, size.width(), &copyX, &copyWidth);
   Clip(y, height, size.height(), &copyY, &copyHeight);
 
   if (copyX != x ||
       copyY != y ||
       copyWidth != width ||
       copyHeight != height) {
     // some part was clipped so clear the texture.
     if (!ClearLevel(
         info->service_id(), info->target(),
-        target, level, internal_format, GL_UNSIGNED_BYTE, width, height)) {
+        target, level, internal_format, GL_UNSIGNED_BYTE, width, height,
+        info->IsImmutable())) {
       SetGLError(GL_OUT_OF_MEMORY, "glCopyTexImage2D: dimensions too big");
       return;
     }
     if (copyHeight > 0 && copyWidth > 0) {
       GLint dx = copyX - x;
       GLint dy = copyY - y;
       GLint destX = dx;
       GLint destY = dy;
       glCopyTexSubImage2D(target, level,
                           destX, destY, copyX, copyY,
@@ skipping 129 matching lines @@
     return;
   }
 
   if (!info->ValidForTexture(
           target, level, xoffset, yoffset, width, height, format, type)) {
     SetGLError(GL_INVALID_VALUE,
                "glTexSubImage2D: bad dimensions.");
     return;
   }
 
-  // See if we can call glTexImage2D instead since it appears to be faster.
-  if (teximage2d_faster_than_texsubimage2d_ && xoffset == 0 && yoffset == 0 &&
-      !info->IsImmutable()) {
-    GLsizei tex_width = 0;
-    GLsizei tex_height = 0;
-    bool ok = info->GetLevelSize(target, level, &tex_width, &tex_height);
-    DCHECK(ok);
-    if (width == tex_width && height == tex_height) {
-      // NOTE: In OpenGL ES 2.0 border is always zero and format is always the
-      // same as internal_foramt. If that changes we'll need to look them up.
-      WrappedTexImage2D(
-          target, level, format, width, height, 0, format, type, data);
-      texture_manager()->SetLevelCleared(info, target, level);
+  GLsizei tex_width = 0;
+  GLsizei tex_height = 0;
+  bool ok = info->GetLevelSize(target, level, &tex_width, &tex_height);
+  DCHECK(ok);
+  if (xoffset != 0 || yoffset != 0 ||
+      width != tex_width || height != tex_height) {
+    if (!texture_manager()->ClearTextureLevel(this, info, target, level)) {
+      SetGLError(GL_OUT_OF_MEMORY, "glTexSubImage2D: dimensions too big");
       return;
     }
-  }
-  if (!texture_manager()->ClearTextureLevel(this, info, target, level)) {
-    SetGLError(GL_OUT_OF_MEMORY, "glTexSubImage2D: dimensions too big");
+    glTexSubImage2D(
+        target, level, xoffset, yoffset, width, height, format, type, data);
     return;
   }
-  glTexSubImage2D(
-      target, level, xoffset, yoffset, width, height, format, type, data);
+
+  if (teximage2d_faster_than_texsubimage2d_ && !info->IsImmutable()) {
+    // NOTE: In OpenGL ES 2.0 border is always zero and format is always the
+    // same as internal_foramt. If that changes we'll need to look them up.
+    WrappedTexImage2D(
+        target, level, format, width, height, 0, format, type, data);
+  } else {
+    glTexSubImage2D(
+        target, level, xoffset, yoffset, width, height, format, type, data);
+  }
+  texture_manager()->SetLevelCleared(info, target, level);
 }
 
 error::Error GLES2DecoderImpl::HandleTexSubImage2D(
     uint32 immediate_data_size, const gles2::TexSubImage2D& c) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::HandleTexSubImage2D");
   GLboolean internal = static_cast<GLboolean>(c.internal);
   if (internal == GL_TRUE && tex_image_2d_failed_)
     return error::kNoError;
 
   GLenum target = static_cast<GLenum>(c.target);
@@ skipping 1037 matching lines @@
     SetGLError(GL_INVALID_OPERATION,
                "glTexStorage2DEXT: texture is immutable");
     return;
   }
   CopyRealGLErrorsToWrapper();
   glTexStorage2DEXT(target, levels, internal_format, width, height);
   GLenum error = PeekGLError();
   if (error == GL_NO_ERROR) {
     GLenum format = ExtractFormatFromStorageFormat(internal_format);
     GLenum type = ExtractTypeFromStorageFormat(internal_format);
-    texture_manager()->SetLevelInfo(
-        feature_info_, info,
-        target, 0, format, width, height, 1, 0, format, type,
-        false);
-    texture_manager()->MarkMipmapsGenerated(feature_info_, info, false);
+    GLsizei level_width = width;
+    GLsizei level_height = height;
+    for (int ii = 0; ii < levels; ++ii) {
+      texture_manager()->SetLevelInfo(
+          feature_info_, info,
+          target, 0, format, level_width, level_height, 1, 0, format, type,
+          false);
+      level_width = std::max(1, level_width >> 1);
+      level_height = std::max(1, level_height >> 1);
+    }
     info->SetImmutable(true);
   }
 
 }
 
 // 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