Command buffer: clear rect for a specific layer/level of the uncleared texture for CopyTexSubImage3D

gpu/command_buffer/service/gles2_cmd_decoder.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/gles2_cmd_decoder.h"
 
 #include <limits.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
@@ skipping 2699 matching lines @@
           size, buffer_format, format);
   if (!image || !image->BindTexImage(Target()))
     return false;
 
   image_ = image;
   decoder_->texture_manager()->SetLevelInfo(
       texture_ref_.get(), Target(), 0, image_->GetInternalFormat(),
       size.width(), size.height(), 1, 0, image_->GetInternalFormat(),
       GL_UNSIGNED_BYTE, gfx::Rect(size));
   decoder_->texture_manager()->SetLevelImage(texture_ref_.get(), Target(), 0,
-                                             image_.get(), Texture::BOUND);
+                                             0, image_.get(), Texture::BOUND);
 
   // Ignore the zero flag if the alpha channel needs to be cleared for RGB
   // emulation.
   bool needs_clear_for_rgb_emulation =
       !decoder_->offscreen_buffer_should_have_alpha_ &&
       decoder_->ChromiumImageNeedsRGBEmulation();
   if (zero || needs_clear_for_rgb_emulation) {
     GLuint fbo;
     glGenFramebuffersEXT(1, &fbo);
     {
@@ skipping 14 matching lines @@
 void BackTexture::DestroyNativeGpuMemoryBuffer(bool have_context) {
   if (image_) {
     ScopedGLErrorSuppressor suppressor(
         "BackTexture::DestroyNativeGpuMemoryBuffer",
         decoder_->state_.GetErrorState());
 
     image_->ReleaseTexImage(Target());
     image_->Destroy(have_context);
 
     decoder_->texture_manager()->SetLevelImage(texture_ref_.get(), Target(), 0,
-                                               nullptr, Texture::UNBOUND);
+                                               0, nullptr, Texture::UNBOUND);
     image_ = nullptr;
   }
 }
 
 BackRenderbuffer::BackRenderbuffer(GLES2DecoderImpl* decoder)
     : decoder_(decoder),
       memory_tracker_(decoder->memory_tracker()),
       bytes_allocated_(0),
       id_(0) {}
 
@@ skipping 5788 matching lines @@
     GLint fake_location,
     GLboolean transpose,
     const GLfloat* transform) {
   float gl_matrix[16];
 
   // This refers to the bound external texture on the active unit.
   TextureUnit& unit = state_.texture_units[state_.active_texture_unit];
   if (TextureRef* texture_ref = unit.bound_texture_external_oes.get()) {
     if (GLStreamTextureImage* image =
             texture_ref->texture()->GetLevelStreamTextureImage(
-                GL_TEXTURE_EXTERNAL_OES, 0)) {
+                GL_TEXTURE_EXTERNAL_OES, 0, 0)) {
       gfx::Transform st_transform(gfx::Transform::kSkipInitialization);
       gfx::Transform pre_transform(gfx::Transform::kSkipInitialization);
       image->GetTextureMatrix(gl_matrix);
       st_transform.matrix().setColMajorf(gl_matrix);
       pre_transform.matrix().setColMajorf(transform);
       gfx::Transform(pre_transform, st_transform)
           .matrix()
           .asColMajorf(gl_matrix);
     } else {
       // Missing stream texture. Treat matrix as identity.
@@ skipping 165 matching lines @@
                      std::string("PERFORMANCE WARNING: ") + msg);
 }
 
 void GLES2DecoderImpl::DoCopyTexImage(Texture* texture,
                                       GLenum textarget,
                                       gl::GLImage* image) {
   // Note: We update the state to COPIED prior to calling CopyTexImage()
   // as that allows the GLImage implemenatation to set it back to UNBOUND
   // and ensure that CopyTexImage() is called each time the texture is
   // used.
-  texture->SetLevelImageState(textarget, 0, Texture::COPIED);
+  texture->SetLevelImageState(textarget, 0, 0, Texture::COPIED);
   bool rv = image->CopyTexImage(textarget);
   DCHECK(rv) << "CopyTexImage() failed";
 }
 
 void GLES2DecoderImpl::DoCopyTexImageIfNeeded(Texture* texture,
                                               GLenum textarget) {
   // Image is already in use if texture is attached to a framebuffer.
   if (texture && !texture->IsAttachedToFramebuffer()) {
     Texture::ImageState image_state;
-    gl::GLImage* image = texture->GetLevelImage(textarget, 0, &image_state);
+    gl::GLImage* image = texture->GetLevelImage(textarget, 0, 0, &image_state);
     if (image && image_state == Texture::UNBOUND) {
       ScopedGLErrorSuppressor suppressor(
           "GLES2DecoderImpl::DoCopyTexImageIfNeeded", GetErrorState());
       glBindTexture(textarget, texture->service_id());
       DoCopyTexImage(texture, textarget, image);
       RestoreCurrentTextureBindings(&state_, textarget);
     }
   }
 }
 
@@ skipping 34 matching lines @@
                 " is not renderable. It maybe non-power-of-2 and have"
                 " incompatible texture filtering.");
           }
           continue;
         }
 
         if (textarget != GL_TEXTURE_CUBE_MAP) {
           Texture* texture = texture_ref->texture();
           Texture::ImageState image_state;
           gl::GLImage* image =
-              texture->GetLevelImage(textarget, 0, &image_state);
+              texture->GetLevelImage(textarget, 0, 0, &image_state);
           if (image && image_state == Texture::UNBOUND &&
               !texture->IsAttachedToFramebuffer()) {
             ScopedGLErrorSuppressor suppressor(
                 "GLES2DecoderImpl::PrepareTexturesForRender", GetErrorState());
             textures_set = true;
             glActiveTexture(GL_TEXTURE0 + texture_unit_index);
             DoCopyTexImage(texture, textarget, image);
             continue;
           }
         }
@@ skipping 2080 matching lines @@
       *static_cast<const gles2::cmds::ScheduleOverlayPlaneCHROMIUM*>(cmd_data);
   TextureRef* ref = texture_manager()->GetTexture(c.overlay_texture_id);
   if (!ref) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE,
                        "glScheduleOverlayPlaneCHROMIUM",
                        "unknown texture");
     return error::kNoError;
   }
   Texture::ImageState image_state;
   gl::GLImage* image =
-      ref->texture()->GetLevelImage(ref->texture()->target(), 0, &image_state);
+      ref->texture()->GetLevelImage(ref->texture()->target(), 0, 0,
+                                    &image_state);
   if (!image) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE,
                        "glScheduleOverlayPlaneCHROMIUM",
                        "unsupported texture format");
     return error::kNoError;
   }
   gfx::OverlayTransform transform = GetGFXOverlayTransform(c.plane_transform);
   if (transform == gfx::OVERLAY_TRANSFORM_INVALID) {
     LOCAL_SET_GL_ERROR(GL_INVALID_ENUM,
                        "glScheduleOverlayPlaneCHROMIUM",
@@ skipping 62 matching lines @@
   GLuint contents_texture_id = c.contents_texture_id;
   if (contents_texture_id) {
     TextureRef* ref = texture_manager()->GetTexture(contents_texture_id);
     if (!ref) {
       LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glScheduleCALayerCHROMIUM",
                          "unknown texture");
       return error::kNoError;
     }
     Texture::ImageState image_state;
     image = ref->texture()->GetLevelImage(ref->texture()->target(), 0,
-                                          &image_state);
+                                          0, &image_state);
     if (!image) {
       LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glScheduleCALayerCHROMIUM",
                          "unsupported texture format");
       return error::kNoError;
     }
   }
 
   const GLfloat* mem = GetSharedMemoryAs<const GLfloat*>(c.shm_id, c.shm_offset,
                                                          8 * sizeof(GLfloat));
   if (!mem) {
@@ skipping 64 matching lines @@
     if (texture_id) {
       TextureRef* ref = texture_manager()->GetTexture(texture_id);
       if (!ref) {
         LOCAL_SET_GL_ERROR(GL_INVALID_VALUE,
                            "glScheduleCALayerInUseQueryCHROMIUM",
                            "unknown texture");
         return;
       }
       Texture::ImageState image_state;
       image = ref->texture()->GetLevelImage(ref->texture()->target(), 0,
-                                            &image_state);
+                                            0, &image_state);
     }
     gl::GLSurface::CALayerInUseQuery query;
     query.image = image;
     query.texture = texture_id;
     queries.push_back(query);
   }
 
   surface_->ScheduleCALayerInUseQuery(std::move(queries));
 }
 
@@ skipping 1719 matching lines @@
   }
 
   if (!ValidateCompressedTexFuncData("glCompressedTexSubImage2D", width, height,
                                      1, format, image_size, data) ||
       !ValidateCompressedTexSubDimensions("glCompressedTexSubImage2D", target,
                                           level, xoffset, yoffset, 0, width,
                                           height, 1, format, texture)) {
     return;
   }
 
-  if (!texture->IsLevelCleared(target, level)) {
+  if (!texture->IsLevelCleared(target, level, 0)) {
     // This can only happen if the compressed texture was allocated
     // using TexStorage2D.
     DCHECK(texture->IsImmutable());
     GLsizei level_width = 0, level_height = 0;
     bool success = texture->GetLevelSize(
         target, level, &level_width, &level_height, nullptr);
     DCHECK(success);
     // We can skip the clear if we're uploading the entire level.
     if (xoffset == 0 && yoffset == 0 &&
         width == level_width && height == level_height) {
-      texture_manager()->SetLevelCleared(texture_ref, target, level, true);
+      texture_manager()->SetLevelCleared(texture_ref, target, level, 0, true);
     } else {
       texture_manager()->ClearTextureLevel(this, texture_ref, target, level);
     }
-    DCHECK(texture->IsLevelCleared(target, level));
+    DCHECK(texture->IsLevelCleared(target, level, 0));
   }
 
   const CompressedFormatInfo* format_info =
       GetCompressedFormatInfo(internal_format);
   if (format_info != nullptr && !format_info->support_check(*feature_info_)) {
     std::unique_ptr<uint8_t[]> decompressed_data = DecompressTextureData(
         state_, *format_info, width, height, 1, image_size, data);
     if (!decompressed_data) {
       MarkContextLost(error::kGuilty);
       group_->LoseContexts(error::kInnocent);
@@ skipping 355 matching lines @@
   Clip(y, height, size.height(), &copyY, &copyHeight);
 
   GLint dx = copyX - x;
   GLint dy = copyY - y;
   GLint destX = xoffset + dx;
   GLint destY = yoffset + dy;
   if (destX != 0 || destY != 0 || copyWidth != size.width() ||
       copyHeight != size.height()) {
     gfx::Rect cleared_rect;
     if (TextureManager::CombineAdjacentRects(
-            texture->GetLevelClearedRect(target, level),
+            texture->GetLevelClearedRect(target, level, 0),
             gfx::Rect(destX, destY, copyWidth, copyHeight), &cleared_rect)) {
       DCHECK_GE(cleared_rect.size().GetArea(),
-                texture->GetLevelClearedRect(target, level).size().GetArea());
-      texture_manager()->SetLevelClearedRect(texture_ref, target, level,
+                texture->GetLevelClearedRect(target, level, 0)
+                    .size().GetArea());
+      texture_manager()->SetLevelClearedRect(texture_ref, target, level, 0,
                                              cleared_rect);
     } else {
       // Otherwise clear part of texture level that is not already cleared.
       if (!texture_manager()->ClearTextureLevel(this, texture_ref, target,
                                                 level)) {
         LOCAL_SET_GL_ERROR(GL_OUT_OF_MEMORY, func_name, "dimensions too big");
         return;
       }
     }
   } else {
     // Write all pixels in below.
-    texture_manager()->SetLevelCleared(texture_ref, target, level, true);
+    texture_manager()->SetLevelCleared(texture_ref, target, level, 0, true);
   }
 
   if (copyHeight > 0 && copyWidth > 0) {
     if (CopyTexImageResourceManager::CopyTexImageRequiresBlit(
             feature_info_.get(), internal_format)) {
       if (!InitializeCopyTexImageBlitter("glCopyTexSubImage2D")) {
         return;
       }
       copy_tex_image_blit_->DoCopyTexSubImage2DToLUMAComatabilityTexture(
           this, texture->service_id(), texture->target(), target,
@@ skipping 53 matching lines @@
     return;
   }
 
   if (FormsTextureCopyingFeedbackLoop(texture_ref, level, zoffset)) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         func_name, "source and destination textures are the same");
     return;
   }
 
+  ScopedResolvedFrameBufferBinder binder(this, false, true);
+  gfx::Size size = GetBoundReadFrameBufferSize();
+  GLint copyX = 0;
+  GLint copyY = 0;
+  GLint copyWidth = 0;
+  GLint copyHeight = 0;
+  Clip(x, width, size.width(), &copyX, &copyWidth);
+  Clip(y, height, size.height(), &copyY, &copyHeight);
+
+  GLint dx = copyX - x;
+  GLint dy = copyY - y;
+  GLint destX = xoffset + dx;
+  GLint destY = yoffset + dy;
+  if (destX != 0 || destY != 0 || copyWidth != size.width() ||
+      copyHeight != size.height()) {
+    gfx::Rect cleared_rect;
+    if (TextureManager::CombineAdjacentRects(
+            texture->GetLevelClearedRect(target, level, zoffset),
+            gfx::Rect(destX, destY, copyWidth, copyHeight), &cleared_rect)) {
+      DCHECK_GE(cleared_rect.size().GetArea(),
+                texture->GetLevelClearedRect(target, level, zoffset)
+                    .size().GetArea());
+      texture_manager()->SetLevelClearedRect(texture_ref, target, level,
+                                             zoffset, cleared_rect);
+    } else {
+      // Otherwise clear part of texture level that is not already cleared.
+      if (!texture_manager()->ClearTextureLevel(this, texture_ref, target,
+                                                level)) {
+        LOCAL_SET_GL_ERROR(GL_OUT_OF_MEMORY, func_name, "dimensions too big");
+        return;
+      }
+    }
+  } else {
+    // Write all pixels in below.
+    texture_manager()->SetLevelCleared(texture_ref, target,
+                                       level, zoffset, true);
+  }
+
   // TODO(yunchao): Follow-up CLs are necessary. For instance:
   // 1. emulation of unsized formats in core profile
-  // 2. clear the 3d textures if it is uncleared.
-  // 3. out-of-bounds reading, etc.
+  // 2. out-of-bounds reading, etc.
 
   glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width,
                       height);
 
   // This may be a slow command.  Exit command processing to allow for
   // context preemption and GPU watchdog checks.
   ExitCommandProcessingEarly();
 }
 
 error::Error GLES2DecoderImpl::HandleTexSubImage2D(uint32_t immediate_data_size,
@@ skipping 1823 matching lines @@
     return;
   }
 
   Texture* source_texture = source_texture_ref->texture();
   Texture* dest_texture = dest_texture_ref->texture();
   GLenum source_target = source_texture->target();
   GLenum dest_target = dest_texture->target();
   int source_width = 0;
   int source_height = 0;
   gl::GLImage* image =
-      source_texture->GetLevelImage(source_target, 0);
+      source_texture->GetLevelImage(source_target, 0, 0);
   if (image) {
     gfx::Size size = image->GetSize();
     source_width = size.width();
     source_height = size.height();
     if (source_width <= 0 || source_height <= 0) {
       LOCAL_SET_GL_ERROR(
           GL_INVALID_VALUE,
           "glCopyTextureChromium", "invalid image size");
       return;
     }
@@ skipping 66 matching lines @@
       RestoreCurrentTextureBindings(&state_, dest_target);
       return;
     }
 
     texture_manager()->SetLevelInfo(
         dest_texture_ref, dest_target, 0, internal_format, source_width,
         source_height, 1, 0, internal_format, dest_type,
         gfx::Rect(source_width, source_height));
     dest_texture->ApplyFormatWorkarounds(feature_info_.get());
   } else {
-    texture_manager()->SetLevelCleared(dest_texture_ref, dest_target, 0,
-                                       true);
+    texture_manager()->SetLevelCleared(dest_texture_ref, dest_target,
+                                       0, 0, true);
   }
 
   // Try using GLImage::CopyTexImage when possible.
   bool unpack_premultiply_alpha_change =
       (unpack_premultiply_alpha ^ unpack_unmultiply_alpha) != 0;
   if (image && !unpack_flip_y && !unpack_premultiply_alpha_change) {
     glBindTexture(dest_target, dest_texture->service_id());
     if (image->CopyTexImage(dest_target))
       return;
   }
 
   DoCopyTexImageIfNeeded(source_texture, source_target);
 
   // GL_TEXTURE_EXTERNAL_OES texture requires that we apply a transform matrix
   // before presenting.
   if (source_target == GL_TEXTURE_EXTERNAL_OES) {
     if (GLStreamTextureImage* image =
             source_texture->GetLevelStreamTextureImage(GL_TEXTURE_EXTERNAL_OES,
-                                                       0)) {
+                                                       0, 0)) {
       GLfloat transform_matrix[16];
       image->GetTextureMatrix(transform_matrix);
       copy_texture_CHROMIUM_->DoCopyTextureWithTransform(
           this, source_target, source_texture->service_id(), dest_target,
           dest_texture->service_id(), source_width, source_height,
           unpack_flip_y == GL_TRUE, unpack_premultiply_alpha == GL_TRUE,
           unpack_unmultiply_alpha == GL_TRUE, transform_matrix);
       return;
     }
   }
@@ skipping 27 matching lines @@
     return;
   }
 
   Texture* source_texture = source_texture_ref->texture();
   Texture* dest_texture = dest_texture_ref->texture();
   GLenum source_target = source_texture->target();
   GLenum dest_target = dest_texture->target();
   int source_width = 0;
   int source_height = 0;
   gl::GLImage* image =
-      source_texture->GetLevelImage(source_target, 0);
+      source_texture->GetLevelImage(source_target, 0, 0);
   if (image) {
     gfx::Size size = image->GetSize();
     source_width = size.width();
     source_height = size.height();
     if (source_width <= 0 || source_height <= 0) {
       LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, kFunctionName, "invalid image size");
       return;
     }
 
     // Ideally we should not need to check that the sub-texture copy rectangle
@@ skipping 73 matching lines @@
 
   int dest_width = 0;
   int dest_height = 0;
   bool ok = dest_texture->GetLevelSize(
       dest_target, 0, &dest_width, &dest_height, nullptr);
   DCHECK(ok);
   if (xoffset != 0 || yoffset != 0 || width != dest_width ||
       height != dest_height) {
     gfx::Rect cleared_rect;
     if (TextureManager::CombineAdjacentRects(
-            dest_texture->GetLevelClearedRect(dest_target, 0),
+            dest_texture->GetLevelClearedRect(dest_target, 0, 0),
             gfx::Rect(xoffset, yoffset, width, height), &cleared_rect)) {
       DCHECK_GE(
           cleared_rect.size().GetArea(),
-          dest_texture->GetLevelClearedRect(dest_target, 0).size().GetArea());
+          dest_texture->GetLevelClearedRect(dest_target, 0, 0).size()
+                                                              .GetArea());
       texture_manager()->SetLevelClearedRect(dest_texture_ref, dest_target, 0,
-                                             cleared_rect);
+                                             0, cleared_rect);
     } else {
       // Otherwise clear part of texture level that is not already cleared.
       if (!texture_manager()->ClearTextureLevel(this, dest_texture_ref,
                                                 dest_target, 0)) {
         LOCAL_SET_GL_ERROR(GL_OUT_OF_MEMORY, kFunctionName,
                            "destination texture dimensions too big");
         return;
       }
     }
   } else {
-    texture_manager()->SetLevelCleared(dest_texture_ref, dest_target, 0,
-                                       true);
+    texture_manager()->SetLevelCleared(dest_texture_ref, dest_target,
+                                       0, 0, true);
   }
 
   // Try using GLImage::CopyTexSubImage when possible.
   bool unpack_premultiply_alpha_change =
       (unpack_premultiply_alpha ^ unpack_unmultiply_alpha) != 0;
   if (image && !unpack_flip_y && !unpack_premultiply_alpha_change) {
     ScopedTextureBinder binder(
         &state_, dest_texture->service_id(), dest_target);
     if (image->CopyTexSubImage(dest_target, gfx::Point(xoffset, yoffset),
                                gfx::Rect(x, y, width, height))) {
       return;
     }
   }
 
   DoCopyTexImageIfNeeded(source_texture, source_target);
 
   // GL_TEXTURE_EXTERNAL_OES texture requires apply a transform matrix
   // before presenting.
   if (source_target == GL_TEXTURE_EXTERNAL_OES) {
     if (GLStreamTextureImage* image =
             source_texture->GetLevelStreamTextureImage(GL_TEXTURE_EXTERNAL_OES,
-                                                       0)) {
+                                                       0, 0)) {
       GLfloat transform_matrix[16];
       image->GetTextureMatrix(transform_matrix);
       copy_texture_CHROMIUM_->DoCopySubTextureWithTransform(
           this, source_target, source_texture->service_id(),
           source_internal_format, dest_target, dest_texture->service_id(),
           dest_internal_format, xoffset, yoffset, x, y, width, height,
           dest_width, dest_height, source_width, source_height,
           unpack_flip_y == GL_TRUE, unpack_premultiply_alpha == GL_TRUE,
           unpack_unmultiply_alpha == GL_TRUE, transform_matrix);
       return;
@@ skipping 49 matching lines @@
   if (!ValidateCompressedCopyTextureCHROMIUM(kFunctionName, source_texture_ref,
                                              dest_texture_ref)) {
     return;
   }
 
   Texture* source_texture = source_texture_ref->texture();
   Texture* dest_texture = dest_texture_ref->texture();
   int source_width = 0;
   int source_height = 0;
   gl::GLImage* image =
-      source_texture->GetLevelImage(source_texture->target(), 0);
+      source_texture->GetLevelImage(source_texture->target(), 0, 0);
   if (image) {
     gfx::Size size = image->GetSize();
     source_width = size.width();
     source_height = size.height();
     if (source_width <= 0 || source_height <= 0) {
       LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, kFunctionName, "invalid image size");
       return;
     }
   } else {
     if (!source_texture->GetLevelSize(source_texture->target(), 0,
@@ skipping 70 matching lines @@
         RestoreCurrentTextureBindings(&state_, dest_texture->target());
         return;
       }
 
       texture_manager()->SetLevelInfo(
           dest_texture_ref, dest_texture->target(), 0, source_internal_format,
           source_width, source_height, 1, 0, source_internal_format,
           source_type, gfx::Rect(source_width, source_height));
     } else {
       texture_manager()->SetLevelCleared(
-          dest_texture_ref, dest_texture->target(), 0, true);
+          dest_texture_ref, dest_texture->target(), 0, 0, true);
     }
 
     if (image->CopyTexImage(dest_texture->target()))
       return;
   }
 
   TRACE_EVENT0(
       "gpu",
       "GLES2DecoderImpl::DoCompressedCopyTextureCHROMIUM, fallback");
 
@@ skipping 460 matching lines @@
     // when BindTexImage() fails.
     if (image->BindTexImage(target))
       image_state = Texture::BOUND;
   }
 
   gfx::Size size = image->GetSize();
   GLenum internalformat = image->GetInternalFormat();
   texture_manager()->SetLevelInfo(
       texture_ref, target, 0, internalformat, size.width(), size.height(), 1, 0,
       internalformat, GL_UNSIGNED_BYTE, gfx::Rect(size));
-  texture_manager()->SetLevelImage(texture_ref, target, 0, image, image_state);
+  texture_manager()->SetLevelImage(texture_ref, target, 0, 0,
+                                   image, image_state);
 }
 
 void GLES2DecoderImpl::DoReleaseTexImage2DCHROMIUM(
     GLenum target, GLint image_id) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::DoReleaseTexImage2DCHROMIUM");
 
   // Default target might be conceptually valid, but disallow it to avoid
   // accidents.
   TextureRef* texture_ref =
       texture_manager()->GetTextureInfoForTargetUnlessDefault(&state_, target);
   if (!texture_ref) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         "glReleaseTexImage2DCHROMIUM", "no texture bound");
     return;
   }
 
   gl::GLImage* image = image_manager()->LookupImage(image_id);
   if (!image) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         "glReleaseTexImage2DCHROMIUM", "no image found with the given ID");
     return;
   }
 
   Texture::ImageState image_state;
 
   // Do nothing when image is not currently bound.
-  if (texture_ref->texture()->GetLevelImage(target, 0, &image_state) != image)
+  if (texture_ref->texture()->GetLevelImage(target, 0, 0, &image_state)
+      != image)
     return;
 
   if (image_state == Texture::BOUND) {
     ScopedGLErrorSuppressor suppressor(
         "GLES2DecoderImpl::DoReleaseTexImage2DCHROMIUM", GetErrorState());
 
     image->ReleaseTexImage(target);
     texture_manager()->SetLevelInfo(texture_ref, target, 0, GL_RGBA, 0, 0, 1, 0,
                                     GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect());
   }
 
-  texture_manager()->SetLevelImage(texture_ref, target, 0, nullptr,
+  texture_manager()->SetLevelImage(texture_ref, target, 0, 0, nullptr,
                                    Texture::UNBOUND);
 }
 
 error::Error GLES2DecoderImpl::HandleTraceBeginCHROMIUM(
     uint32_t immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::TraceBeginCHROMIUM& c =
       *static_cast<const gles2::cmds::TraceBeginCHROMIUM*>(cmd_data);
   Bucket* category_bucket = GetBucket(c.category_bucket_id);
   Bucket* name_bucket = GetBucket(c.name_bucket_id);
@@ skipping 1623 matching lines @@
 }
 
 // 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 "base/macros.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu