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

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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 404 matching lines @@
     memory_tracking_ref_ = *refs_.begin();
     GetMemTracker()->TrackMemAlloc(estimated_size());
   }
 }
 
 MemoryTypeTracker* Texture::GetMemTracker() {
   DCHECK(memory_tracking_ref_);
   return memory_tracking_ref_->manager()->GetMemTracker();
 }
 
+Texture::LayerInfo::LayerInfo()
+    : image_state(UNBOUND),
+      layer(0) {}
+
+Texture::LayerInfo::LayerInfo(const LayerInfo& rhs)
+    : image(rhs.image),
+      image_state(rhs.image_state),
+      layer(rhs.layer) {}
+
+Texture::LayerInfo::~LayerInfo() {
+}
+
 Texture::LevelInfo::LevelInfo()
     : target(0),
       level(-1),
       internal_format(0),
       width(0),
       height(0),
       depth(0),
       border(0),
       format(0),
       type(0),
-      image_state(UNBOUND),
       estimated_size(0),
-      internal_workaround(false) {}
+      internal_workaround(false),
+      num_uncleared_layers(0) {}
 
 Texture::LevelInfo::LevelInfo(const LevelInfo& rhs)
-    : cleared_rect(rhs.cleared_rect),
-      target(rhs.target),
+    : 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),
-      image_state(rhs.image_state),
       estimated_size(rhs.estimated_size),
-      internal_workaround(rhs.internal_workaround) {}
+      internal_workaround(rhs.internal_workaround),
+      num_uncleared_layers(rhs.num_uncleared_layers) {
+  GLint layers = rhs.layer_infos.size();
+  layer_infos.resize(layers);
+  for (int jj = 0; jj < layers; ++jj) {
+    layer_infos[jj].cleared_rect = rhs.layer_infos[jj].cleared_rect;
+    layer_infos[jj].image = rhs.layer_infos[jj].image;
+    layer_infos[jj].image_state = rhs.layer_infos[jj].image_state;
+  }
+}
 
 Texture::LevelInfo::~LevelInfo() {
 }
 
 Texture::FaceInfo::FaceInfo()
     : num_mip_levels(0) {
 }
 
 Texture::FaceInfo::FaceInfo(const FaceInfo& other) = default;
 
@@ skipping 93 matching lines @@
     }
   }
 
   return true;
 }
 
 void Texture::AddToSignature(
     const FeatureInfo* feature_info,
     GLenum target,
     GLint level,
+    GLint layer,
     std::string* signature) const {
   DCHECK(feature_info);
   DCHECK(signature);
   DCHECK_GE(level, 0);
   size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
   DCHECK_LT(static_cast<size_t>(face_index),
             face_infos_.size());
   DCHECK_LT(static_cast<size_t>(level),
             face_infos_[face_index].level_infos.size());
+  DCHECK_LT(static_cast<size_t>(layer),
+            face_infos_[face_index].level_infos[level].layer_infos.size());
 
-  const Texture::LevelInfo& info =
+  const Texture::LevelInfo& level_info =
       face_infos_[face_index].level_infos[level];
+  const Texture::LayerInfo& layer_info = level_info.layer_infos[layer];
 
   TextureSignature signature_data(target,
                                   level,
                                   sampler_state_,
                                   usage_,
-                                  info.internal_format,
-                                  info.width,
-                                  info.height,
-                                  info.depth,
+                                  level_info.internal_format,
+                                  level_info.width,
+                                  level_info.height,
+                                  level_info.depth,
                                   base_level_,
-                                  info.border,
+                                  level_info.border,
                                   max_level_,
-                                  info.format,
-                                  info.type,
-                                  info.image.get() != NULL,
+                                  level_info.format,
+                                  level_info.type,
+                                  layer_info.image.get() != NULL,
                                   CanRender(feature_info),
                                   CanRenderTo(feature_info, level),
                                   npot_,
                                   emulating_rgb_);
 
   signature->append(TextureTag, sizeof(TextureTag));
   signature->append(reinterpret_cast<const char*>(&signature_data),
                     sizeof(signature_data));
 }
 
@@ skipping 18 matching lines @@
       width = std::max(1, width >> 1);
       height = std::max(1, height >> 1);
       depth = target == GL_TEXTURE_2D_ARRAY ? depth : std::max(1, depth >> 1);
       SetLevelInfo(target, level, level0_info.internal_format,
                    width, height, depth, level0_info.border, level0_info.format,
                    level0_info.type, gfx::Rect(width, height));
     }
   }
 }
 
-void Texture::SetTarget(GLenum target, GLint max_levels) {
+void Texture::SetTarget(GLenum target, GLint max_levels, GLint layers) {
   DCHECK_EQ(0u, target_);  // you can only set this once.
   target_ = target;
   size_t num_faces = (target == GL_TEXTURE_CUBE_MAP) ? 6 : 1;
   face_infos_.resize(num_faces);
   for (size_t ii = 0; ii < num_faces; ++ii) {
     face_infos_[ii].level_infos.resize(max_levels);
+    for (int jj = 0; jj < max_levels; ++jj) {
+    Texture::LevelInfo& level_info = face_infos_[ii].level_infos[jj];
+      level_info.layer_infos.resize(layers);
+      level_info.num_uncleared_layers = 0;
+      for (int kk = 0; kk < layers; ++kk)
+        level_info.layer_infos[kk].image_state = UNBOUND;
+    }
   }
 
   if (target == GL_TEXTURE_EXTERNAL_OES || target == GL_TEXTURE_RECTANGLE_ARB) {
     sampler_state_.min_filter = GL_LINEAR;
     sampler_state_.wrap_s = sampler_state_.wrap_t = GL_CLAMP_TO_EDGE;
   }
 
   if (target == GL_TEXTURE_EXTERNAL_OES) {
     immutable_ = true;
   }
@@ skipping 20 matching lines @@
     return false;
   }
 
   if (!Texture::ColorRenderable(feature_info, base.internal_format) ||
       !Texture::TextureFilterable(
           feature_info, base.internal_format, base.type)) {
     return false;
   }
 
   for (size_t ii = 0; ii < face_infos_.size(); ++ii) {
-    const LevelInfo& info = face_infos_[ii].level_infos[base_level_];
-    if ((info.target == 0) ||
+    const LevelInfo& level_info = face_infos_[ii].level_infos[base_level_];
+    if ((level_info.target == 0) ||
         feature_info->validators()->compressed_texture_format.IsValid(
-            info.internal_format) ||
-        info.image.get()) {
+            level_info.internal_format)) {
       return false;
     }
+    for (size_t jj = 0; jj < level_info.layer_infos.size(); ++jj) {
+      if ( level_info.layer_infos[jj].image.get()) {
+        return false;
+      }
+    }
   }
   if (face_infos_.size() == 6 && !cube_complete_) {
     return false;
   }
   return true;
 }
 
 bool Texture::TextureIsNPOT(GLsizei width,
                             GLsizei height,
                             GLsizei depth) {
@@ skipping 76 matching lines @@
         // GL_HALF_FLOAT is ES3 only and should only be used with sized formats.
         return true;
     }
   }
   return feature_info->validators()->
       texture_sized_texture_filterable_internal_format.IsValid(internal_format);
 }
 
 void Texture::SetLevelClearedRect(GLenum target,
                                   GLint level,
+                                  GLint layer,
                                   const gfx::Rect& cleared_rect) {
   DCHECK_GE(level, 0);
+  DCHECK_GE(layer, 0);
   size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
   DCHECK_LT(static_cast<size_t>(face_index),
             face_infos_.size());
   DCHECK_LT(static_cast<size_t>(level),
             face_infos_[face_index].level_infos.size());
+  DCHECK_LT(static_cast<size_t>(layer),
+            face_infos_[face_index].level_infos[level].layer_infos.size());
   Texture::LevelInfo& info =
       face_infos_[face_index].level_infos[level];
-  UpdateMipCleared(&info, info.width, info.height, cleared_rect);
+  UpdateMipCleared(&info, info.width, info.height, cleared_rect, layer);
   UpdateCleared();
 }
 
-void Texture::SetLevelCleared(GLenum target, GLint level, bool cleared) {
+void Texture::SetLevelCleared(GLenum target,
+                              GLint level,
+                              GLint layer,
+                              bool cleared) {
   DCHECK_GE(level, 0);
+  DCHECK_GE(layer, 0);
   size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
   DCHECK_LT(static_cast<size_t>(face_index), face_infos_.size());
   DCHECK_LT(static_cast<size_t>(level),
             face_infos_[face_index].level_infos.size());
   Texture::LevelInfo& info = face_infos_[face_index].level_infos[level];
   UpdateMipCleared(&info, info.width, info.height,
-                   cleared ? gfx::Rect(info.width, info.height) : gfx::Rect());
+                   cleared ? gfx::Rect(info.width, info.height) : gfx::Rect(),
+                   layer);
   UpdateCleared();
 }
 
 void Texture::UpdateCleared() {
   if (face_infos_.empty()) {
     return;
   }
 
   const bool cleared = (num_uncleared_mips_ == 0);
 
   // If texture is uncleared and is attached to a framebuffer,
   // that framebuffer must be marked possibly incomplete.
   if (!cleared && IsAttachedToFramebuffer()) {
     IncAllFramebufferStateChangeCount();
   }
 
   UpdateSafeToRenderFrom(cleared);
 }
 
 void Texture::UpdateSafeToRenderFrom(bool cleared) {
   if (cleared_ == cleared)
     return;
   cleared_ = cleared;
   int delta = cleared ? -1 : +1;
   for (RefSet::iterator it = refs_.begin(); it != refs_.end(); ++it)
     (*it)->manager()->UpdateSafeToRenderFrom(delta);
 }
 
+void Texture::UpdateMipClearedHelper(LevelInfo* info) {
+  int layers = info->layer_infos.size();
+  const gfx::Rect cleared_rect = info->layer_infos[0].cleared_rect;
+  for (int ii = 1; ii < layers; ++ii) {
+    info->layer_infos[ii].cleared_rect = cleared_rect;
+  }
+}
+
 void Texture::UpdateMipCleared(LevelInfo* info,
                                GLsizei width,
                                GLsizei height,
-                               const gfx::Rect& cleared_rect) {
-  bool was_cleared = info->cleared_rect == gfx::Rect(info->width, info->height);
+                               const gfx::Rect& cleared_rect,
+                               GLint layer) {
+  bool was_cleared = info->layer_infos[layer].cleared_rect ==
+      gfx::Rect(info->width, info->height);
   info->width = width;
   info->height = height;
-  info->cleared_rect = cleared_rect;
-  bool cleared = info->cleared_rect == gfx::Rect(info->width, info->height);
+  info->layer_infos[layer].cleared_rect = cleared_rect;
+  bool cleared = info->layer_infos[layer].cleared_rect ==
+      gfx::Rect(info->width, info->height);
   if (cleared == was_cleared)
     return;
   int delta = cleared ? -1 : +1;
-  num_uncleared_mips_ += delta;
-  for (RefSet::iterator it = refs_.begin(); it != refs_.end(); ++it)
-    (*it)->manager()->UpdateUnclearedMips(delta);
+  if (info->num_uncleared_layers == 0 ||
+      info->num_uncleared_layers + delta == 0) {
+    num_uncleared_mips_ += delta;
+    for (RefSet::iterator it = refs_.begin(); it != refs_.end(); ++it)
+      (*it)->manager()->UpdateUnclearedMips(delta);
+  }
+  info->num_uncleared_layers += delta;
 }
 
 void Texture::UpdateCanRenderCondition() {
   can_render_condition_ = GetCanRenderCondition();
 }
 
 void Texture::UpdateHasImages() {
   if (face_infos_.empty())
     return;
 
   bool has_images = false;
   for (size_t ii = 0; ii < face_infos_.size(); ++ii) {
     for (size_t jj = 0; jj < face_infos_[ii].level_infos.size(); ++jj) {
-      const Texture::LevelInfo& info = face_infos_[ii].level_infos[jj];
-      if (info.image.get() != NULL) {
-        has_images = true;
-        break;
+      const Texture::LevelInfo& level_info = face_infos_[ii].level_infos[jj];
+      for (size_t kk = 0; kk < level_info.layer_infos.size(); ++kk) {
+        if (level_info.layer_infos[kk].image.get() != NULL) {
+          has_images = true;
+          break;
+        }
       }
     }
   }
 
   if (has_images_ == has_images)
     return;
   has_images_ = has_images;
   int delta = has_images ? +1 : -1;
   for (RefSet::iterator it = refs_.begin(); it != refs_.end(); ++it)
     (*it)->manager()->UpdateNumImages(delta);
 }
 
 void Texture::UpdateEmulatingRGB() {
   for (const FaceInfo& face_info : face_infos_) {
     for (const LevelInfo& level_info : face_info.level_infos) {
-      if (level_info.image && level_info.image->EmulatingRGB()) {
-        emulating_rgb_ = true;
-        return;
+      for (const LayerInfo& layer_info : level_info.layer_infos) {
+        if (layer_info.image && layer_info.image->EmulatingRGB()) {
+          emulating_rgb_ = true;
+          return;
+        }
       }
     }
   }
   emulating_rgb_ = false;
 }
 
 
 void Texture::IncAllFramebufferStateChangeCount() {
   for (RefSet::iterator it = refs_.begin(); it != refs_.end(); ++it)
     (*it)->manager()->IncFramebufferStateChangeCount();
@@ skipping 43 matching lines @@
                            GLint border,
                            GLenum format,
                            GLenum type,
                            const gfx::Rect& cleared_rect) {
   DCHECK_GE(level, 0);
   size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
   DCHECK_LT(static_cast<size_t>(face_index),
             face_infos_.size());
   DCHECK_LT(static_cast<size_t>(level),
             face_infos_[face_index].level_infos.size());
+  DCHECK_LE(static_cast<size_t>(depth),
+            face_infos_[face_index].level_infos[level].layer_infos.size());
   DCHECK_GE(width, 0);
   DCHECK_GE(height, 0);
   DCHECK_GE(depth, 0);
   Texture::LevelInfo& info =
       face_infos_[face_index].level_infos[level];
 
   // Update counters only if any attributes have changed. Counters are
   // comparisons between the old and new values so it must be done before any
   // assignment has been done to the LevelInfo.
   if (info.target != target ||
@@ skipping 20 matching lines @@
     texture_mips_dirty_ = true;
   }
 
   info.target = target;
   info.level = level;
   info.internal_format = internal_format;
   info.depth = depth;
   info.border = border;
   info.format = format;
   info.type = type;
-  info.image = 0;
-  info.stream_texture_image = 0;
-  info.image_state = UNBOUND;
+  info.layer_infos[depth - 1].image = 0;
+  info.layer_infos[depth - 1].stream_texture_image = 0;
+  info.layer_infos[depth - 1].image_state = UNBOUND;
   info.internal_workaround = false;
 
-  UpdateMipCleared(&info, width, height, cleared_rect);
+  // UpdateMipCleared(&info, width, height, cleared_rect, depth - 1);
+  UpdateMipCleared(&info, width, height, cleared_rect, 0);
+  if (target == GL_TEXTURE_3D || target == GL_TEXTURE_2D_ARRAY) {
+    // UpdateMipClearedHelper(&info);
+    for (int i = 1; i < depth; ++i) {
+      UpdateMipCleared(&info, width, height, cleared_rect, i);
+    }
+  }
 
   estimated_size_ -= info.estimated_size;
   GLES2Util::ComputeImageDataSizes(
       width, height, depth, format, type, 4, &info.estimated_size, NULL, NULL);
   estimated_size_ += info.estimated_size;
 
   max_level_set_ = std::max(max_level_set_, level);
   Update();
   UpdateCleared();
   UpdateCanRenderCondition();
@@ skipping 348 matching lines @@
   if (cleared_) {
     return true;
   }
 
   for (size_t ii = 0; ii < face_infos_.size(); ++ii) {
     const Texture::FaceInfo& face_info = face_infos_[ii];
     for (GLint jj = base_level_;
          jj < base_level_ + face_info.num_mip_levels; ++jj) {
       const Texture::LevelInfo& info = face_info.level_infos[jj];
       if (info.target != 0) {
-        if (!ClearLevel(decoder, info.target, jj)) {
+        if (!ClearLevel(decoder, info.target, jj, 0)) {
           return false;
         }
       }
     }
   }
   UpdateSafeToRenderFrom(true);
   return true;
 }
 
 GLint Texture::GetImmutableLevels() const {
   if (!immutable_)
     return 0;
   GLint levels = 0;
   if (immutable_) {
     DCHECK(face_infos_.size() > 0);
     for (size_t ii = 0; ii < face_infos_[0].level_infos.size(); ++ii) {
       const Texture::LevelInfo& info = face_infos_[0].level_infos[ii];
       if (info.target != 0)
         levels++;
     }
   }
   return levels;
 }
 
-gfx::Rect Texture::GetLevelClearedRect(GLenum target, GLint level) const {
+gfx::Rect Texture::GetLevelClearedRect(GLenum target,
+                                       GLint level,
+                                       GLint layer) const {
   size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
   if (face_index >= face_infos_.size() ||
-      level >= static_cast<GLint>(face_infos_[face_index].level_infos.size())) {
+      level >= static_cast<GLint>(face_infos_[face_index].level_infos.size()) ||
+      layer >= static_cast<GLint>(face_infos_[face_index].
+          level_infos[level].layer_infos.size())) {
     return gfx::Rect();
   }
 
-  const Texture::LevelInfo& info = face_infos_[face_index].level_infos[level];
+  const Texture::LayerInfo& layer_info =
+      face_infos_[face_index].level_infos[level].layer_infos[layer];
 
-  return info.cleared_rect;
+  return layer_info.cleared_rect;
 }
 
-bool Texture::IsLevelCleared(GLenum target, GLint level) const {
+bool Texture::IsLevelCleared(GLenum target, GLint level, GLint layer) const {
   size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
   if (face_index >= face_infos_.size() ||
       level < 0 ||
       level >= static_cast<GLint>(face_infos_[face_index].level_infos.size())) {
     return true;
   }
-  const Texture::LevelInfo& info = face_infos_[face_index].level_infos[level];
-  return info.cleared_rect == gfx::Rect(info.width, info.height);
+  const Texture::LevelInfo& level_info =
+      face_infos_[face_index].level_infos[level];
+  const Texture::LayerInfo& layer_info = level_info.layer_infos[layer];
+  return layer_info.cleared_rect ==
+      gfx::Rect(level_info.width, level_info.height);
 }
 
-bool Texture::IsLevelPartiallyCleared(GLenum target, GLint level) const {
+bool Texture::IsLevelPartiallyCleared(GLenum target,
+                                      GLint level,
+                                      GLint layer) const {
   size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
   if (face_index >= face_infos_.size() ||
       level < 0 ||
       level >= static_cast<GLint>(face_infos_[face_index].level_infos.size())) {
     return false;
   }
-  const Texture::LevelInfo& info = face_infos_[face_index].level_infos[level];
-  return (info.cleared_rect != gfx::Rect(info.width, info.height) &&
-          info.cleared_rect != gfx::Rect());
+  const Texture::LevelInfo& level_info =
+      face_infos_[face_index].level_infos[level];
+  const Texture::LayerInfo& layer_info = level_info.layer_infos[layer];
+  return (layer_info.cleared_rect !=
+          gfx::Rect(level_info.width, level_info.height) &&
+          layer_info.cleared_rect != gfx::Rect());
 }
 
 void Texture::InitTextureMaxAnisotropyIfNeeded(GLenum target) {
   if (texture_max_anisotropy_initialized_)
     return;
   texture_max_anisotropy_initialized_ = true;
   GLfloat params[] = { 1.0f };
   glTexParameterfv(target, GL_TEXTURE_MAX_ANISOTROPY_EXT, params);
 }
 
 bool Texture::ClearLevel(
-    GLES2Decoder* decoder, GLenum target, GLint level) {
+    GLES2Decoder* decoder, GLenum target, GLint level, GLint layer) {
   DCHECK(decoder);
   size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
   if (face_index >= face_infos_.size() || level < 0 ||
       level >= static_cast<GLint>(face_infos_[face_index].level_infos.size())) {
     return true;
   }
 
-  Texture::LevelInfo& info = face_infos_[face_index].level_infos[level];
+  Texture::LevelInfo& level_info = face_infos_[face_index].level_infos[level];
+  Texture::LayerInfo& layer_info = level_info.layer_infos[layer];
 
-  DCHECK(target == info.target);
+  DCHECK(target == level_info.target);
 
-  if (info.target == 0 ||
-      info.cleared_rect == gfx::Rect(info.width, info.height) ||
-      info.width == 0 || info.height == 0 || info.depth == 0) {
+  if (level_info.target == 0 ||
+      layer_info.cleared_rect ==
+      gfx::Rect(level_info.width, level_info.height) ||
+      level_info.width == 0 ||
+      level_info.height == 0 ||
+      level_info.depth == 0) {
     return true;
   }
 
-  if (info.target == GL_TEXTURE_3D || info.target == GL_TEXTURE_2D_ARRAY) {
+  if (level_info.target == GL_TEXTURE_3D ||
+      level_info.target == GL_TEXTURE_2D_ARRAY) {
     // For 3D textures, we always clear the entire texture.
-    DCHECK(info.cleared_rect == gfx::Rect());
+    DCHECK(layer_info.cleared_rect == gfx::Rect());
     bool cleared = decoder->ClearLevel3D(
-        this, info.target, info.level, info.format, info.type,
-        info.width, info.height, info.depth);
+        this, level_info.target, level_info.level, level_info.format,
+        level_info.type, level_info.width, level_info.height, level_info.depth);
     if (!cleared)
       return false;
   } else {
-    if (decoder->IsCompressedTextureFormat(info.internal_format)) {
+    if (decoder->IsCompressedTextureFormat(level_info.internal_format)) {
       // An uncleared level of a compressed texture can only occur when
       // allocating the texture with TexStorage2D. In this case the level
       // is cleared just before a call to CompressedTexSubImage2D, to avoid
       // having to clear a sub-rectangle of a compressed texture, which
       // would be problematic.
       DCHECK(IsImmutable());
-      DCHECK(info.cleared_rect == gfx::Rect());
+      DCHECK(layer_info.cleared_rect == gfx::Rect());
       bool cleared = decoder->ClearCompressedTextureLevel(
-          this, info.target, info.level, info.internal_format,
-          info.width, info.height);
+          this, level_info.target, level_info.level, level_info.internal_format,
+          level_info.width, level_info.height);
       if (!cleared)
         return false;
     } else {
       // Clear all remaining sub regions.
       const int x[] = {
-        0, info.cleared_rect.x(), info.cleared_rect.right(), info.width};
+        0, layer_info.cleared_rect.x(),
+        layer_info.cleared_rect.right(), level_info.width};
       const int y[] = {
-        0, info.cleared_rect.y(), info.cleared_rect.bottom(), info.height};
+        0, layer_info.cleared_rect.y(),
+        layer_info.cleared_rect.bottom(), level_info.height};
 
       for (size_t j = 0; j < 3; ++j) {
         for (size_t i = 0; i < 3; ++i) {
           // Center of nine patch is already cleared.
           if (j == 1 && i == 1)
             continue;
 
           gfx::Rect rect(x[i], y[j], x[i + 1] - x[i], y[j + 1] - y[j]);
           if (rect.IsEmpty())
             continue;
 
           // NOTE: It seems kind of gross to call back into the decoder for this
           // but only the decoder knows all the state (like unpack_alignment_)
           // that's needed to be able to call GL correctly.
           bool cleared = decoder->ClearLevel(
-              this, info.target, info.level, info.format, info.type,
-              rect.x(), rect.y(), rect.width(), rect.height());
+              this, level_info.target, level_info.level, level_info.format,
+              level_info.type, rect.x(), rect.y(), rect.width(), rect.height());
           if (!cleared)
             return false;
         }
       }
     }
   }
 
-  UpdateMipCleared(&info, info.width, info.height,
-                   gfx::Rect(info.width, info.height));
+  UpdateMipCleared(&level_info, level_info.width, level_info.height,
+                   gfx::Rect(level_info.width, level_info.height), 0);
+  if (level_info.target == GL_TEXTURE_3D ||
+      level_info.target == GL_TEXTURE_2D_ARRAY) {
+    for (int i = 1; i < level_info.depth; ++i) {
+      UpdateMipCleared(&level_info, level_info.width, level_info.height,
+                       gfx::Rect(level_info.width, level_info.height), i);
+    }
+  }
   return true;
 }
 
 void Texture::SetLevelImageInternal(GLenum target,
                                     GLint level,
+                                    GLint layer,
                                     gl::GLImage* image,
                                     GLStreamTextureImage* stream_texture_image,
                                     ImageState state) {
   DCHECK(!stream_texture_image || stream_texture_image == image);
   DCHECK_GE(level, 0);
   size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
   DCHECK_LT(static_cast<size_t>(face_index), face_infos_.size());
   DCHECK_LT(static_cast<size_t>(level),
             face_infos_[face_index].level_infos.size());
-  Texture::LevelInfo& info = face_infos_[face_index].level_infos[level];
-  DCHECK_EQ(info.target, target);
-  DCHECK_EQ(info.level, level);
-  info.image = image;
-  info.stream_texture_image = stream_texture_image;
-  info.image_state = state;
+  DCHECK_LT(static_cast<size_t>(layer),
+            face_infos_[face_index].level_infos[level].layer_infos.size());
+  Texture::LevelInfo& level_info = face_infos_[face_index].level_infos[level];
+  DCHECK_EQ(level_info.target, target);
+  DCHECK_EQ(level_info.level, level);
+
+  Texture::LayerInfo& layer_info = level_info.layer_infos[layer];
+  layer_info.image = image;
+  layer_info.stream_texture_image = stream_texture_image;
+  layer_info.image_state = state;
 
   UpdateCanRenderCondition();
   UpdateHasImages();
   UpdateEmulatingRGB();
 }
 
 void Texture::SetLevelImage(GLenum target,
                             GLint level,
+                            GLint layer,
                             gl::GLImage* image,
                             ImageState state) {
   SetStreamTextureServiceId(0);
-  SetLevelImageInternal(target, level, image, nullptr, state);
+  SetLevelImageInternal(target, level, layer, image, nullptr, state);
 }
 
 void Texture::SetLevelStreamTextureImage(GLenum target,
                                          GLint level,
+                                         GLint layer,
                                          GLStreamTextureImage* image,
                                          ImageState state,
                                          GLuint service_id) {
   SetStreamTextureServiceId(service_id);
-  SetLevelImageInternal(target, level, image, image, state);
+  SetLevelImageInternal(target, level, layer, image, image, state);
 }
 
-void Texture::SetLevelImageState(GLenum target, GLint level, ImageState state) {
+void Texture::SetLevelImageState(GLenum target,
+                                 GLint level,
+                                 GLint layer,
+                                 ImageState state) {
   DCHECK_GE(level, 0);
   size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
   DCHECK_LT(static_cast<size_t>(face_index), face_infos_.size());
   DCHECK_LT(static_cast<size_t>(level),
             face_infos_[face_index].level_infos.size());
-  Texture::LevelInfo& info = face_infos_[face_index].level_infos[level];
-  DCHECK_EQ(info.target, target);
-  DCHECK_EQ(info.level, level);
-  info.image_state = state;
+  DCHECK_LT(static_cast<size_t>(layer),
+            face_infos_[face_index].level_infos[level].layer_infos.size());
+  Texture::LevelInfo& level_info = face_infos_[face_index].level_infos[level];
+  DCHECK_EQ(level_info.target, target);
+  DCHECK_EQ(level_info.level, level);
+  Texture::LayerInfo& layer_info = level_info.layer_infos[layer];
+  layer_info.image_state = state;
 }
 
 const Texture::LevelInfo* Texture::GetLevelInfo(GLint target,
                                                 GLint level) const {
+  // TODO(yunchao): add TEXTURE_3D and TEXTURE_2D_ARRAY
   if (target != GL_TEXTURE_2D && target != GL_TEXTURE_EXTERNAL_OES &&
       target != GL_TEXTURE_RECTANGLE_ARB) {
     return NULL;
   }
 
   size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
   if (level >= 0 && face_index < face_infos_.size() &&
       static_cast<size_t>(level) < face_infos_[face_index].level_infos.size()) {
     const LevelInfo& info = face_infos_[face_index].level_infos[level];
     if (info.target != 0)
       return &info;
   }
   return NULL;
 }
 
 gl::GLImage* Texture::GetLevelImage(GLint target,
                                     GLint level,
+                                    GLint layer,
                                     ImageState* state) const {
-  const LevelInfo* info = GetLevelInfo(target, level);
-  if (!info)
+  const LevelInfo* level_info = GetLevelInfo(target, level);
+  if (!level_info)
     return nullptr;
+  if (static_cast<size_t>(layer) >= level_info->layer_infos.size())
+    return nullptr;
+  const LayerInfo& layer_info = level_info->layer_infos[layer];
 
   if (state)
-    *state = info->image_state;
-  return info->image.get();
+    *state = layer_info.image_state;
+  return layer_info.image.get();
 }
 
-gl::GLImage* Texture::GetLevelImage(GLint target, GLint level) const {
-  return GetLevelImage(target, level, nullptr);
+gl::GLImage* Texture::GetLevelImage(GLint target,
+                                    GLint level,
+                                    GLint layer) const {
+  return GetLevelImage(target, level, layer, nullptr);
 }
 
 GLStreamTextureImage* Texture::GetLevelStreamTextureImage(GLint target,
-                                                          GLint level) const {
-  const LevelInfo* info = GetLevelInfo(target, level);
-  if (!info)
+                                                          GLint level,
+                                                          GLint layer) const {
+  const LevelInfo* level_info = GetLevelInfo(target, level);
+  if (!level_info)
     return nullptr;
+  if (static_cast<size_t>(layer) >= level_info->layer_infos.size())
+    return nullptr;
+  const LayerInfo& layer_info = level_info->layer_infos[layer];
 
-  return info->stream_texture_image.get();
+  return layer_info.stream_texture_image.get();
 }
 
 void Texture::DumpLevelMemory(base::trace_event::ProcessMemoryDump* pmd,
                               uint64_t client_tracing_id,
                               const std::string& dump_name) const {
   for (uint32_t face_index = 0; face_index < face_infos_.size(); ++face_index) {
     const auto& level_infos = face_infos_[face_index].level_infos;
     for (uint32_t level_index = 0; level_index < level_infos.size();
          ++level_index) {
       // Skip levels with no size. Textures will have empty levels for all
       // potential mip levels which are not in use.
       if (!level_infos[level_index].estimated_size)
         continue;
 
-      // If a level has a GLImage, ask the GLImage to dump itself.
-      if (level_infos[level_index].image) {
-        level_infos[level_index].image->OnMemoryDump(
-            pmd, client_tracing_id,
-            base::StringPrintf("%s/face_%d/level_%d", dump_name.c_str(),
-                               face_index, level_index));
-      }
+      for (uint32_t layer_index = 0;
+           layer_index < level_infos[level_index].layer_infos.size();
+           ++layer_index) {
+        // If a level has a GLImage, ask the GLImage to dump itself.
+        if (level_infos[level_index].layer_infos[layer_index].image) {
+          level_infos[level_index].layer_infos[layer_index].image->OnMemoryDump(
+              pmd, client_tracing_id,
+              base::StringPrintf("%s/face_%d/level_%d/layer_%d",
+                                 dump_name.c_str(),
+                                 face_index, level_index, layer_index));
+        }
 
       // If a level does not have a GLImage bound to it, then dump the
       // texture allocation also as the storage is not provided by the
       // GLImage in that case.
-      if (level_infos[level_index].image_state != BOUND) {
+      if (level_infos[level_index].layer_infos[layer_index].image_state
+          != BOUND) {
         base::trace_event::MemoryAllocatorDump* dump = pmd->CreateAllocatorDump(
-            base::StringPrintf("%s/face_%d/level_%d", dump_name.c_str(),
-                               face_index, level_index));
+            base::StringPrintf("%s/face_%d/level_%d/layer_%d",
+                               dump_name.c_str(),
+                               face_index, level_index, layer_index));
         dump->AddScalar(
             base::trace_event::MemoryAllocatorDump::kNameSize,
             base::trace_event::MemoryAllocatorDump::kUnitsBytes,
             static_cast<uint64_t>(level_infos[level_index].estimated_size));
       }
+      }
     }
   }
 }
 
 bool Texture::CanRenderTo(const FeatureInfo* feature_info, GLint level) const {
   if (target_ == GL_TEXTURE_EXTERNAL_OES || target_ == 0)
     return false;
   DCHECK_LT(0u, face_infos_.size());
   // In GLES2, cube completeness is not required for framebuffer completeness.
   // However, it is required if command buffer is implemented on top of
@@ skipping 243 matching lines @@
          (level == 0 || feature_info_->feature_flags().npot_ok ||
           (!GLES2Util::IsNPOT(width) &&
            !GLES2Util::IsNPOT(height) &&
            !GLES2Util::IsNPOT(depth))) &&
          (target != GL_TEXTURE_CUBE_MAP || (width == height && depth == 1)) &&
          (target != GL_TEXTURE_2D || (depth == 1));
 }
 
 void TextureManager::SetTarget(TextureRef* ref, GLenum target) {
   DCHECK(ref);
-  ref->texture()->SetTarget(target, MaxLevelsForTarget(target));
+  GLint layers;
+  switch (target) {
+    case GL_TEXTURE_3D:
+      layers = max_3d_texture_size();
+      break;
+    case GL_TEXTURE_2D_ARRAY:
+      layers = max_array_texture_layers();
+      break;
+    default:
+      layers = 1;
+  }
+  ref->texture()->SetTarget(target, MaxLevelsForTarget(target), layers);
 }
 
 void TextureManager::SetLevelClearedRect(TextureRef* ref,
                                          GLenum target,
                                          GLint level,
+                                         GLint layer,
                                          const gfx::Rect& cleared_rect) {
   DCHECK(ref);
-  ref->texture()->SetLevelClearedRect(target, level, cleared_rect);
+  ref->texture()->SetLevelClearedRect(target, level, layer, cleared_rect);
 }
 
 void TextureManager::SetLevelCleared(TextureRef* ref,
                                      GLenum target,
                                      GLint level,
+                                     GLint layer,
                                      bool cleared) {
   DCHECK(ref);
-  ref->texture()->SetLevelCleared(target, level, cleared);
+  ref->texture()->SetLevelCleared(target, level, layer, cleared);
 }
 
 bool TextureManager::ClearRenderableLevels(
     GLES2Decoder* decoder, TextureRef* ref) {
   DCHECK(ref);
   return ref->texture()->ClearRenderableLevels(decoder);
 }
 
 bool TextureManager::ClearTextureLevel(
     GLES2Decoder* decoder, TextureRef* ref,
     GLenum target, GLint level) {
   DCHECK(ref);
   Texture* texture = ref->texture();
   if (texture->num_uncleared_mips() == 0) {
     return true;
   }
-  bool result = texture->ClearLevel(decoder, target, level);
+  bool result = texture->ClearLevel(decoder, target, level, 0);
   texture->UpdateCleared();
   return result;
 }
 
 void TextureManager::SetLevelInfo(TextureRef* ref,
                                   GLenum target,
                                   GLint level,
                                   GLenum internal_format,
                                   GLsizei width,
                                   GLsizei height,
@@ skipping 171 matching lines @@
              base::bits::Log2Floor(std::max(std::max(width, height), depth));
     default:
       return 1 +
              base::bits::Log2Floor(std::max(width, height));
   }
 }
 
 void TextureManager::SetLevelImage(TextureRef* ref,
                                    GLenum target,
                                    GLint level,
+                                   GLint layer,
                                    gl::GLImage* image,
                                    Texture::ImageState state) {
   DCHECK(ref);
-  ref->texture()->SetLevelImage(target, level, image, state);
+  ref->texture()->SetLevelImage(target, level, layer, image, state);
 }
 
 void TextureManager::SetLevelStreamTextureImage(TextureRef* ref,
                                                 GLenum target,
                                                 GLint level,
+                                                GLint layer,
                                                 GLStreamTextureImage* image,
                                                 Texture::ImageState state,
                                                 GLuint service_id) {
   DCHECK(ref);
-  ref->texture()->SetLevelStreamTextureImage(target, level, image, state,
+  ref->texture()->SetLevelStreamTextureImage(target, level, layer, image, state,
                                              service_id);
 }
 
 void TextureManager::SetLevelImageState(TextureRef* ref,
                                         GLenum target,
                                         GLint level,
+                                        GLint layer,
                                         Texture::ImageState state) {
   DCHECK(ref);
-  ref->texture()->SetLevelImageState(target, level, state);
+  ref->texture()->SetLevelImageState(target, level, layer, state);
 }
 
 size_t TextureManager::GetSignatureSize() const {
   return sizeof(TextureTag) + sizeof(TextureSignature);
 }
 
 void TextureManager::AddToSignature(
     TextureRef* ref,
     GLenum target,
     GLint level,
+    GLint layer,
     std::string* signature) const {
-  ref->texture()->AddToSignature(feature_info_.get(), target, level, signature);
+  ref->texture()->AddToSignature(feature_info_.get(), target,
+                                 level, layer, signature);
 }
 
 void TextureManager::UpdateSafeToRenderFrom(int delta) {
   num_unsafe_textures_ += delta;
   DCHECK_GE(num_unsafe_textures_, 0);
 }
 
 void TextureManager::UpdateUnclearedMips(int delta) {
   num_uncleared_mips_ += delta;
   DCHECK_GE(num_uncleared_mips_, 0);
@@ skipping 284 matching lines @@
 
       DoTexSubImageArguments sub_args = {
           args.target, args.level, 0, 0, 0, args.width, args.height, args.depth,
           args.format, args.type, args.pixels, args.pixels_size, args.padding,
           args.command_type == DoTexImageArguments::kTexImage3D
               ? DoTexSubImageArguments::kTexSubImage3D
               : DoTexSubImageArguments::kTexSubImage2D};
       DoTexSubImageRowByRowWorkaround(texture_state, state, sub_args,
                                       unpack_params);
 
-      SetLevelCleared(texture_ref, args.target, args.level, true);
+      SetLevelCleared(texture_ref, args.target,
+                      args.level, args.depth - 1, true);
       return;
     }
   }
 
   if (texture_state->unpack_alignment_workaround_with_unpack_buffer && buffer) {
     uint32_t buffer_size = static_cast<uint32_t>(buffer->size());
     if (buffer_size - args.pixels_size - ToGLuint(args.pixels) < args.padding) {
       // In ValidateTexImage(), we already made sure buffer size is no less
       // than offset + pixels_size.
       ReserveTexImageToBeFilled(texture_state, state, framebuffer_state,
                                 function_name, texture_ref, args);
 
       DoTexSubImageArguments sub_args = {
           args.target, args.level, 0, 0, 0, args.width, args.height, args.depth,
           args.format, args.type, args.pixels, args.pixels_size, args.padding,
           args.command_type == DoTexImageArguments::kTexImage3D ?
               DoTexSubImageArguments::kTexSubImage3D :
               DoTexSubImageArguments::kTexSubImage2D};
       DoTexSubImageWithAlignmentWorkaround(texture_state, state, sub_args);
 
-      SetLevelCleared(texture_ref, args.target, args.level, true);
+      SetLevelCleared(texture_ref, args.target,
+                      args.level, args.depth - 1, true);
       return;
     }
   }
   DoTexImage(texture_state, state, framebuffer_state,
              function_name, texture_ref, args);
 }
 
 void TextureManager::ReserveTexImageToBeFilled(
     DecoderTextureState* texture_state,
     ContextState* state,
@@ skipping 130 matching lines @@
   bool ok = texture->GetLevelSize(args.target, args.level, &tex_width,
                                   &tex_height, &tex_depth);
   DCHECK(ok);
   bool full_image;
   if (args.xoffset != 0 || args.yoffset != 0 || args.zoffset != 0 ||
       args.width != tex_width || args.height != tex_height ||
       args.depth != tex_depth) {
     gfx::Rect cleared_rect;
     if (args.command_type == DoTexSubImageArguments::kTexSubImage2D &&
         CombineAdjacentRects(
-            texture->GetLevelClearedRect(args.target, args.level),
+            texture->GetLevelClearedRect(args.target, args.level,
+                                         args.depth - 1),
             gfx::Rect(args.xoffset, args.yoffset, args.width, args.height),
             &cleared_rect)) {
       DCHECK_GE(cleared_rect.size().GetArea(),
-                texture->GetLevelClearedRect(args.target, args.level)
+                texture->GetLevelClearedRect(args.target, args.level,
+                                             args.depth - 1)
                     .size()
                     .GetArea());
-      SetLevelClearedRect(texture_ref, args.target, args.level, cleared_rect);
+      SetLevelClearedRect(texture_ref, args.target,
+                          args.level, args.depth - 1, cleared_rect);
     } else {
       // Otherwise clear part of texture level that is not already cleared.
       if (!ClearTextureLevel(decoder, texture_ref, args.target, args.level)) {
         ERRORSTATE_SET_GL_ERROR(error_state, GL_OUT_OF_MEMORY,
                                 function_name, "dimensions too big");
         return;
       }
     }
     full_image = false;
   } else {
-    SetLevelCleared(texture_ref, args.target, args.level, true);
+    SetLevelCleared(texture_ref, args.target,
+                    args.level, args.depth - 1, true);
     full_image = true;
   }
 
   Buffer* buffer = state->bound_pixel_unpack_buffer.get();
 
   if (texture_state->unpack_overlapping_rows_separately_unpack_buffer &&
       buffer) {
     ContextState::Dimension dimension =
         (args.command_type == DoTexSubImageArguments::kTexSubImage3D)
             ? ContextState::k3D
@@ skipping 722 matching lines @@
 uint32_t TextureManager::GetServiceIdGeneration() const {
   return current_service_id_generation_;
 }
 
 void TextureManager::IncrementServiceIdGeneration() {
   current_service_id_generation_++;
 }
 
 }  // namespace gles2
 }  // namespace gpu