tor-browser

Texture.cpp (85913B)

---

//
// Copyright 2002 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//

// Texture.cpp: Implements the gl::Texture class. [OpenGL ES 2.0.24] section 3.7 page 63.

#include "libANGLE/Texture.h"

#include "common/mathutil.h"
#include "common/utilities.h"
#include "libANGLE/Config.h"
#include "libANGLE/Context.h"
#include "libANGLE/Image.h"
#include "libANGLE/State.h"
#include "libANGLE/Surface.h"
#include "libANGLE/formatutils.h"
#include "libANGLE/renderer/GLImplFactory.h"
#include "libANGLE/renderer/TextureImpl.h"

namespace gl
{

namespace
{
constexpr angle::SubjectIndex kBufferSubjectIndex = 2;
static_assert(kBufferSubjectIndex != rx::kTextureImageImplObserverMessageIndex, "Index collision");
static_assert(kBufferSubjectIndex != rx::kTextureImageSiblingMessageIndex, "Index collision");

bool IsPointSampled(const SamplerState &samplerState)
{
   return (samplerState.getMagFilter() == GL_NEAREST &&
           (samplerState.getMinFilter() == GL_NEAREST ||
            samplerState.getMinFilter() == GL_NEAREST_MIPMAP_NEAREST));
}

size_t GetImageDescIndex(TextureTarget target, size_t level)
{
   return IsCubeMapFaceTarget(target) ? (level * 6 + CubeMapTextureTargetToFaceIndex(target))
                                      : level;
}

InitState DetermineInitState(const Context *context, Buffer *unpackBuffer, const uint8_t *pixels)
{
   // Can happen in tests.
   if (!context || !context->isRobustResourceInitEnabled())
   {
       return InitState::Initialized;
   }

   return (!pixels && !unpackBuffer) ? InitState::MayNeedInit : InitState::Initialized;
}
}  // namespace

GLenum ConvertToNearestFilterMode(GLenum filterMode)
{
   switch (filterMode)
   {
       case GL_LINEAR:
           return GL_NEAREST;
       case GL_LINEAR_MIPMAP_NEAREST:
           return GL_NEAREST_MIPMAP_NEAREST;
       case GL_LINEAR_MIPMAP_LINEAR:
           return GL_NEAREST_MIPMAP_LINEAR;
       default:
           return filterMode;
   }
}

GLenum ConvertToNearestMipFilterMode(GLenum filterMode)
{
   switch (filterMode)
   {
       case GL_LINEAR_MIPMAP_LINEAR:
           return GL_LINEAR_MIPMAP_NEAREST;
       case GL_NEAREST_MIPMAP_LINEAR:
           return GL_NEAREST_MIPMAP_NEAREST;
       default:
           return filterMode;
   }
}

bool IsMipmapSupported(const TextureType &type)
{
   if (type == TextureType::_2DMultisample || type == TextureType::Buffer)
   {
       return false;
   }
   return true;
}

SwizzleState::SwizzleState()
   : swizzleRed(GL_RED), swizzleGreen(GL_GREEN), swizzleBlue(GL_BLUE), swizzleAlpha(GL_ALPHA)
{}

SwizzleState::SwizzleState(GLenum red, GLenum green, GLenum blue, GLenum alpha)
   : swizzleRed(red), swizzleGreen(green), swizzleBlue(blue), swizzleAlpha(alpha)
{}

bool SwizzleState::swizzleRequired() const
{
   return swizzleRed != GL_RED || swizzleGreen != GL_GREEN || swizzleBlue != GL_BLUE ||
          swizzleAlpha != GL_ALPHA;
}

bool SwizzleState::operator==(const SwizzleState &other) const
{
   return swizzleRed == other.swizzleRed && swizzleGreen == other.swizzleGreen &&
          swizzleBlue == other.swizzleBlue && swizzleAlpha == other.swizzleAlpha;
}

bool SwizzleState::operator!=(const SwizzleState &other) const
{
   return !(*this == other);
}

TextureState::TextureState(TextureType type)
   : mType(type),
     mSamplerState(SamplerState::CreateDefaultForTarget(type)),
     mSrgbOverride(SrgbOverride::Default),
     mBaseLevel(0),
     mMaxLevel(kInitialMaxLevel),
     mDepthStencilTextureMode(GL_DEPTH_COMPONENT),
     mHasBeenBoundAsImage(false),
     mIs3DAndHasBeenBoundAs2DImage(false),
     mHasBeenBoundAsAttachment(false),
     mImmutableFormat(false),
     mImmutableLevels(0),
     mUsage(GL_NONE),
     mHasProtectedContent(false),
     mImageDescs((IMPLEMENTATION_MAX_TEXTURE_LEVELS + 1) * (type == TextureType::CubeMap ? 6 : 1)),
     mCropRect(0, 0, 0, 0),
     mGenerateMipmapHint(GL_FALSE),
     mInitState(InitState::Initialized),
     mCachedSamplerFormat(SamplerFormat::InvalidEnum),
     mCachedSamplerCompareMode(GL_NONE),
     mCachedSamplerFormatValid(false)
{}

TextureState::~TextureState() {}

bool TextureState::swizzleRequired() const
{
   return mSwizzleState.swizzleRequired();
}

GLuint TextureState::getEffectiveBaseLevel() const
{
   if (mImmutableFormat)
   {
       // GLES 3.0.4 section 3.8.10
       return std::min(mBaseLevel, mImmutableLevels - 1);
   }
   // Some classes use the effective base level to index arrays with level data. By clamping the
   // effective base level to max levels these arrays need just one extra item to store properties
   // that should be returned for all out-of-range base level values, instead of needing special
   // handling for out-of-range base levels.
   return std::min(mBaseLevel, static_cast<GLuint>(IMPLEMENTATION_MAX_TEXTURE_LEVELS));
}

GLuint TextureState::getEffectiveMaxLevel() const
{
   if (mImmutableFormat)
   {
       // GLES 3.0.4 section 3.8.10
       GLuint clampedMaxLevel = std::max(mMaxLevel, getEffectiveBaseLevel());
       clampedMaxLevel        = std::min(clampedMaxLevel, mImmutableLevels - 1);
       return clampedMaxLevel;
   }
   return mMaxLevel;
}

GLuint TextureState::getMipmapMaxLevel() const
{
   const ImageDesc &baseImageDesc = getImageDesc(getBaseImageTarget(), getEffectiveBaseLevel());
   GLuint expectedMipLevels       = 0;
   if (mType == TextureType::_3D)
   {
       const int maxDim  = std::max(std::max(baseImageDesc.size.width, baseImageDesc.size.height),
                                    baseImageDesc.size.depth);
       expectedMipLevels = static_cast<GLuint>(log2(maxDim));
   }
   else
   {
       expectedMipLevels = static_cast<GLuint>(
           log2(std::max(baseImageDesc.size.width, baseImageDesc.size.height)));
   }

   return std::min<GLuint>(getEffectiveBaseLevel() + expectedMipLevels, getEffectiveMaxLevel());
}

bool TextureState::setBaseLevel(GLuint baseLevel)
{
   if (mBaseLevel != baseLevel)
   {
       mBaseLevel = baseLevel;
       return true;
   }
   return false;
}

bool TextureState::setMaxLevel(GLuint maxLevel)
{
   if (mMaxLevel != maxLevel)
   {
       mMaxLevel = maxLevel;
       return true;
   }

   return false;
}

// Tests for cube texture completeness. [OpenGL ES 2.0.24] section 3.7.10 page 81.
// According to [OpenGL ES 3.0.5] section 3.8.13 Texture Completeness page 160 any
// per-level checks begin at the base-level.
// For OpenGL ES2 the base level is always zero.
bool TextureState::isCubeComplete() const
{
   ASSERT(mType == TextureType::CubeMap);

   angle::EnumIterator<TextureTarget> face = kCubeMapTextureTargetMin;
   const ImageDesc &baseImageDesc          = getImageDesc(*face, getEffectiveBaseLevel());
   if (baseImageDesc.size.width == 0 || baseImageDesc.size.width != baseImageDesc.size.height)
   {
       return false;
   }

   ++face;

   for (; face != kAfterCubeMapTextureTargetMax; ++face)
   {
       const ImageDesc &faceImageDesc = getImageDesc(*face, getEffectiveBaseLevel());
       if (faceImageDesc.size.width != baseImageDesc.size.width ||
           faceImageDesc.size.height != baseImageDesc.size.height ||
           !Format::SameSized(faceImageDesc.format, baseImageDesc.format))
       {
           return false;
       }
   }

   return true;
}

const ImageDesc &TextureState::getBaseLevelDesc() const
{
   ASSERT(mType != TextureType::CubeMap || isCubeComplete());
   return getImageDesc(getBaseImageTarget(), getEffectiveBaseLevel());
}

const ImageDesc &TextureState::getLevelZeroDesc() const
{
   ASSERT(mType != TextureType::CubeMap || isCubeComplete());
   return getImageDesc(getBaseImageTarget(), 0);
}

void TextureState::setCrop(const Rectangle &rect)
{
   mCropRect = rect;
}

const Rectangle &TextureState::getCrop() const
{
   return mCropRect;
}

void TextureState::setGenerateMipmapHint(GLenum hint)
{
   mGenerateMipmapHint = hint;
}

GLenum TextureState::getGenerateMipmapHint() const
{
   return mGenerateMipmapHint;
}

SamplerFormat TextureState::computeRequiredSamplerFormat(const SamplerState &samplerState) const
{
   const ImageDesc &baseImageDesc = getImageDesc(getBaseImageTarget(), getEffectiveBaseLevel());
   if ((baseImageDesc.format.info->format == GL_DEPTH_COMPONENT ||
        baseImageDesc.format.info->format == GL_DEPTH_STENCIL) &&
       samplerState.getCompareMode() != GL_NONE)
   {
       return SamplerFormat::Shadow;
   }
   else
   {
       switch (baseImageDesc.format.info->componentType)
       {
           case GL_UNSIGNED_NORMALIZED:
           case GL_SIGNED_NORMALIZED:
           case GL_FLOAT:
               return SamplerFormat::Float;
           case GL_INT:
               return SamplerFormat::Signed;
           case GL_UNSIGNED_INT:
               return SamplerFormat::Unsigned;
           default:
               return SamplerFormat::InvalidEnum;
       }
   }
}

bool TextureState::computeSamplerCompleteness(const SamplerState &samplerState,
                                             const State &state) const
{
   // Buffer textures cannot be incomplete.
   if (mType == TextureType::Buffer)
   {
       return true;
   }

   // Check for all non-format-based completeness rules
   if (!computeSamplerCompletenessForCopyImage(samplerState, state))
   {
       return false;
   }

   const ImageDesc &baseImageDesc = getImageDesc(getBaseImageTarget(), getEffectiveBaseLevel());

   // According to es 3.1 spec, texture is justified as incomplete if sized internalformat is
   // unfilterable(table 20.11) and filter is not GL_NEAREST(8.16). The default value of minFilter
   // is NEAREST_MIPMAP_LINEAR and magFilter is LINEAR(table 20.11,). For multismaple texture,
   // filter state of multisample texture is ignored(11.1.3.3). So it shouldn't be judged as
   // incomplete texture. So, we ignore filtering for multisample texture completeness here.
   if (!IsMultisampled(mType) &&
       !baseImageDesc.format.info->filterSupport(state.getClientVersion(),
                                                 state.getExtensions()) &&
       !IsPointSampled(samplerState))
   {
       return false;
   }

   // OpenGLES 3.0.2 spec section 3.8.13 states that a texture is not mipmap complete if:
   // The internalformat specified for the texture arrays is a sized internal depth or
   // depth and stencil format (see table 3.13), the value of TEXTURE_COMPARE_-
   // MODE is NONE, and either the magnification filter is not NEAREST or the mini-
   // fication filter is neither NEAREST nor NEAREST_MIPMAP_NEAREST.
   if (!IsMultisampled(mType) && baseImageDesc.format.info->depthBits > 0 &&
       state.getClientMajorVersion() >= 3)
   {
       // Note: we restrict this validation to sized types. For the OES_depth_textures
       // extension, due to some underspecification problems, we must allow linear filtering
       // for legacy compatibility with WebGL 1.
       // See http://crbug.com/649200
       if (samplerState.getCompareMode() == GL_NONE && baseImageDesc.format.info->sized)
       {
           if ((samplerState.getMinFilter() != GL_NEAREST &&
                samplerState.getMinFilter() != GL_NEAREST_MIPMAP_NEAREST) ||
               samplerState.getMagFilter() != GL_NEAREST)
           {
               return false;
           }
       }
   }

   // OpenGLES 3.1 spec section 8.16 states that a texture is not mipmap complete if:
   // The internalformat specified for the texture is DEPTH_STENCIL format, the value of
   // DEPTH_STENCIL_TEXTURE_MODE is STENCIL_INDEX, and either the magnification filter is
   // not NEAREST or the minification filter is neither NEAREST nor NEAREST_MIPMAP_NEAREST.
   // However, the ES 3.1 spec differs from the statement above, because it is incorrect.
   // See the issue at https://github.com/KhronosGroup/OpenGL-API/issues/33.
   // For multismaple texture, filter state of multisample texture is ignored(11.1.3.3).
   // So it shouldn't be judged as incomplete texture. So, we ignore filtering for multisample
   // texture completeness here.
   if (!IsMultisampled(mType) && baseImageDesc.format.info->depthBits > 0 &&
       mDepthStencilTextureMode == GL_STENCIL_INDEX)
   {
       if ((samplerState.getMinFilter() != GL_NEAREST &&
            samplerState.getMinFilter() != GL_NEAREST_MIPMAP_NEAREST) ||
           samplerState.getMagFilter() != GL_NEAREST)
       {
           return false;
       }
   }

   return true;
}

// CopyImageSubData has more lax rules for texture completeness: format-based completeness rules are
// ignored, so a texture can still be considered complete even if it violates format-specific
// conditions
bool TextureState::computeSamplerCompletenessForCopyImage(const SamplerState &samplerState,
                                                         const State &state) const
{
   // Buffer textures cannot be incomplete.
   if (mType == TextureType::Buffer)
   {
       return true;
   }

   if (!mImmutableFormat && mBaseLevel > mMaxLevel)
   {
       return false;
   }
   const ImageDesc &baseImageDesc = getImageDesc(getBaseImageTarget(), getEffectiveBaseLevel());
   if (baseImageDesc.size.width == 0 || baseImageDesc.size.height == 0 ||
       baseImageDesc.size.depth == 0)
   {
       return false;
   }
   // The cases where the texture is incomplete because base level is out of range should be
   // handled by the above condition.
   ASSERT(mBaseLevel < IMPLEMENTATION_MAX_TEXTURE_LEVELS || mImmutableFormat);

   if (mType == TextureType::CubeMap && baseImageDesc.size.width != baseImageDesc.size.height)
   {
       return false;
   }

   bool npotSupport = state.getExtensions().textureNpotOES || state.getClientMajorVersion() >= 3;
   if (!npotSupport)
   {
       if ((samplerState.getWrapS() != GL_CLAMP_TO_EDGE &&
            samplerState.getWrapS() != GL_CLAMP_TO_BORDER && !isPow2(baseImageDesc.size.width)) ||
           (samplerState.getWrapT() != GL_CLAMP_TO_EDGE &&
            samplerState.getWrapT() != GL_CLAMP_TO_BORDER && !isPow2(baseImageDesc.size.height)))
       {
           return false;
       }
   }

   if (IsMipmapSupported(mType) && IsMipmapFiltered(samplerState.getMinFilter()))
   {
       if (!npotSupport)
       {
           if (!isPow2(baseImageDesc.size.width) || !isPow2(baseImageDesc.size.height))
           {
               return false;
           }
       }

       if (!computeMipmapCompleteness())
       {
           return false;
       }
   }
   else
   {
       if (mType == TextureType::CubeMap && !isCubeComplete())
       {
           return false;
       }
   }

   // From GL_OES_EGL_image_external_essl3: If state is present in a sampler object bound to a
   // texture unit that would have been rejected by a call to TexParameter* for the texture bound
   // to that unit, the behavior of the implementation is as if the texture were incomplete. For
   // example, if TEXTURE_WRAP_S or TEXTURE_WRAP_T is set to anything but CLAMP_TO_EDGE on the
   // sampler object bound to a texture unit and the texture bound to that unit is an external
   // texture and EXT_EGL_image_external_wrap_modes is not enabled, the texture will be considered
   // incomplete.
   // Sampler object state which does not affect sampling for the type of texture bound
   // to a texture unit, such as TEXTURE_WRAP_R for an external texture, does not affect
   // completeness.
   if (mType == TextureType::External)
   {
       if (!state.getExtensions().EGLImageExternalWrapModesEXT)
       {
           if (samplerState.getWrapS() != GL_CLAMP_TO_EDGE ||
               samplerState.getWrapT() != GL_CLAMP_TO_EDGE)
           {
               return false;
           }
       }

       if (samplerState.getMinFilter() != GL_LINEAR && samplerState.getMinFilter() != GL_NEAREST)
       {
           return false;
       }
   }

   return true;
}

bool TextureState::computeMipmapCompleteness() const
{
   const GLuint maxLevel = getMipmapMaxLevel();

   for (GLuint level = getEffectiveBaseLevel(); level <= maxLevel; level++)
   {
       if (mType == TextureType::CubeMap)
       {
           for (TextureTarget face : AllCubeFaceTextureTargets())
           {
               if (!computeLevelCompleteness(face, level))
               {
                   return false;
               }
           }
       }
       else
       {
           if (!computeLevelCompleteness(NonCubeTextureTypeToTarget(mType), level))
           {
               return false;
           }
       }
   }

   return true;
}

bool TextureState::computeLevelCompleteness(TextureTarget target, size_t level) const
{
   ASSERT(level < IMPLEMENTATION_MAX_TEXTURE_LEVELS);

   if (mImmutableFormat)
   {
       return true;
   }

   const ImageDesc &baseImageDesc = getImageDesc(getBaseImageTarget(), getEffectiveBaseLevel());
   if (baseImageDesc.size.width == 0 || baseImageDesc.size.height == 0 ||
       baseImageDesc.size.depth == 0)
   {
       return false;
   }

   const ImageDesc &levelImageDesc = getImageDesc(target, level);
   if (levelImageDesc.size.width == 0 || levelImageDesc.size.height == 0 ||
       levelImageDesc.size.depth == 0)
   {
       return false;
   }

   if (!Format::SameSized(levelImageDesc.format, baseImageDesc.format))
   {
       return false;
   }

   ASSERT(level >= getEffectiveBaseLevel());
   const size_t relativeLevel = level - getEffectiveBaseLevel();
   if (levelImageDesc.size.width != std::max(1, baseImageDesc.size.width >> relativeLevel))
   {
       return false;
   }

   if (levelImageDesc.size.height != std::max(1, baseImageDesc.size.height >> relativeLevel))
   {
       return false;
   }

   if (mType == TextureType::_3D)
   {
       if (levelImageDesc.size.depth != std::max(1, baseImageDesc.size.depth >> relativeLevel))
       {
           return false;
       }
   }
   else if (IsArrayTextureType(mType))
   {
       if (levelImageDesc.size.depth != baseImageDesc.size.depth)
       {
           return false;
       }
   }

   return true;
}

TextureTarget TextureState::getBaseImageTarget() const
{
   return mType == TextureType::CubeMap ? kCubeMapTextureTargetMin
                                        : NonCubeTextureTypeToTarget(mType);
}

GLuint TextureState::getEnabledLevelCount() const
{
   GLuint levelCount      = 0;
   const GLuint baseLevel = getEffectiveBaseLevel();
   const GLuint maxLevel  = std::min(getEffectiveMaxLevel(), getMipmapMaxLevel());

   // The mip chain will have either one or more sequential levels, or max levels,
   // but not a sparse one.
   Optional<Extents> expectedSize;
   for (size_t enabledLevel = baseLevel; enabledLevel <= maxLevel; ++enabledLevel, ++levelCount)
   {
       // Note: for cube textures, we only check the first face.
       TextureTarget target     = TextureTypeToTarget(mType, 0);
       size_t descIndex         = GetImageDescIndex(target, enabledLevel);
       const Extents &levelSize = mImageDescs[descIndex].size;

       if (levelSize.empty())
       {
           break;
       }
       if (expectedSize.valid())
       {
           Extents newSize = expectedSize.value();
           newSize.width   = std::max(1, newSize.width >> 1);
           newSize.height  = std::max(1, newSize.height >> 1);

           if (!IsArrayTextureType(mType))
           {
               newSize.depth = std::max(1, newSize.depth >> 1);
           }

           if (newSize != levelSize)
           {
               break;
           }
       }
       expectedSize = levelSize;
   }

   return levelCount;
}

ImageDesc::ImageDesc()
   : ImageDesc(Extents(0, 0, 0), Format::Invalid(), 0, GL_TRUE, InitState::Initialized)
{}

ImageDesc::ImageDesc(const Extents &size, const Format &format, const InitState initState)
   : size(size), format(format), samples(0), fixedSampleLocations(GL_TRUE), initState(initState)
{}

ImageDesc::ImageDesc(const Extents &size,
                    const Format &format,
                    const GLsizei samples,
                    const bool fixedSampleLocations,
                    const InitState initState)
   : size(size),
     format(format),
     samples(samples),
     fixedSampleLocations(fixedSampleLocations),
     initState(initState)
{}

GLint ImageDesc::getMemorySize() const
{
   // Assume allocated size is around width * height * depth * samples * pixelBytes
   angle::CheckedNumeric<GLint> levelSize = 1;
   levelSize *= format.info->pixelBytes;
   levelSize *= size.width;
   levelSize *= size.height;
   levelSize *= size.depth;
   levelSize *= std::max(samples, 1);
   return levelSize.ValueOrDefault(std::numeric_limits<GLint>::max());
}

const ImageDesc &TextureState::getImageDesc(TextureTarget target, size_t level) const
{
   size_t descIndex = GetImageDescIndex(target, level);
   ASSERT(descIndex < mImageDescs.size());
   return mImageDescs[descIndex];
}

void TextureState::setImageDesc(TextureTarget target, size_t level, const ImageDesc &desc)
{
   size_t descIndex = GetImageDescIndex(target, level);
   ASSERT(descIndex < mImageDescs.size());
   mImageDescs[descIndex] = desc;
   if (desc.initState == InitState::MayNeedInit)
   {
       mInitState = InitState::MayNeedInit;
   }
   else
   {
       // Scan for any uninitialized images. If there are none, set the init state of the entire
       // texture to initialized. The cost of the scan is only paid after doing image
       // initialization which is already very expensive.
       bool allImagesInitialized = true;

       for (const ImageDesc &initDesc : mImageDescs)
       {
           if (initDesc.initState == InitState::MayNeedInit)
           {
               allImagesInitialized = false;
               break;
           }
       }

       if (allImagesInitialized)
       {
           mInitState = InitState::Initialized;
       }
   }
}

// Note that an ImageIndex that represents an entire level of a cube map corresponds to 6
// ImageDescs, so if the cube map is cube complete, we return the ImageDesc of the first cube
// face, and we don't allow using this function when the cube map is not cube complete.
const ImageDesc &TextureState::getImageDesc(const ImageIndex &imageIndex) const
{
   if (imageIndex.isEntireLevelCubeMap())
   {
       ASSERT(isCubeComplete());
       const GLint levelIndex = imageIndex.getLevelIndex();
       return getImageDesc(kCubeMapTextureTargetMin, levelIndex);
   }

   return getImageDesc(imageIndex.getTarget(), imageIndex.getLevelIndex());
}

void TextureState::setImageDescChain(GLuint baseLevel,
                                    GLuint maxLevel,
                                    Extents baseSize,
                                    const Format &format,
                                    InitState initState)
{
   for (GLuint level = baseLevel; level <= maxLevel; level++)
   {
       int relativeLevel = (level - baseLevel);
       Extents levelSize(std::max<int>(baseSize.width >> relativeLevel, 1),
                         std::max<int>(baseSize.height >> relativeLevel, 1),
                         (IsArrayTextureType(mType))
                             ? baseSize.depth
                             : std::max<int>(baseSize.depth >> relativeLevel, 1));
       ImageDesc levelInfo(levelSize, format, initState);

       if (mType == TextureType::CubeMap)
       {
           for (TextureTarget face : AllCubeFaceTextureTargets())
           {
               setImageDesc(face, level, levelInfo);
           }
       }
       else
       {
           setImageDesc(NonCubeTextureTypeToTarget(mType), level, levelInfo);
       }
   }
}

void TextureState::setImageDescChainMultisample(Extents baseSize,
                                               const Format &format,
                                               GLsizei samples,
                                               bool fixedSampleLocations,
                                               InitState initState)
{
   ASSERT(mType == TextureType::_2DMultisample || mType == TextureType::_2DMultisampleArray);
   ImageDesc levelInfo(baseSize, format, samples, fixedSampleLocations, initState);
   setImageDesc(NonCubeTextureTypeToTarget(mType), 0, levelInfo);
}

void TextureState::clearImageDesc(TextureTarget target, size_t level)
{
   setImageDesc(target, level, ImageDesc());
}

void TextureState::clearImageDescs()
{
   for (size_t descIndex = 0; descIndex < mImageDescs.size(); descIndex++)
   {
       mImageDescs[descIndex] = ImageDesc();
   }
}

Texture::Texture(rx::GLImplFactory *factory, TextureID id, TextureType type)
   : RefCountObject(factory->generateSerial(), id),
     mState(type),
     mTexture(factory->createTexture(mState)),
     mImplObserver(this, rx::kTextureImageImplObserverMessageIndex),
     mBufferObserver(this, kBufferSubjectIndex),
     mBoundSurface(nullptr),
     mBoundStream(nullptr)
{
   mImplObserver.bind(mTexture);

   // Initially assume the implementation is dirty.
   mDirtyBits.set(DIRTY_BIT_IMPLEMENTATION);
}

void Texture::onDestroy(const Context *context)
{
   if (mBoundSurface)
   {
       ANGLE_SWALLOW_ERR(mBoundSurface->releaseTexImage(context, EGL_BACK_BUFFER));
       mBoundSurface = nullptr;
   }
   if (mBoundStream)
   {
       mBoundStream->releaseTextures();
       mBoundStream = nullptr;
   }

   egl::RefCountObjectReleaser<egl::Image> releaseImage;
   (void)orphanImages(context, &releaseImage);

   mState.mBuffer.set(context, nullptr, 0, 0);

   if (mTexture)
   {
       mTexture->onDestroy(context);
   }
}

Texture::~Texture()
{
   SafeDelete(mTexture);
}

angle::Result Texture::setLabel(const Context *context, const std::string &label)
{
   mState.mLabel = label;
   return mTexture->onLabelUpdate(context);
}

const std::string &Texture::getLabel() const
{
   return mState.mLabel;
}

void Texture::setSwizzleRed(const Context *context, GLenum swizzleRed)
{
   if (mState.mSwizzleState.swizzleRed != swizzleRed)
   {
       mState.mSwizzleState.swizzleRed = swizzleRed;
       signalDirtyState(DIRTY_BIT_SWIZZLE_RED);
   }
}

GLenum Texture::getSwizzleRed() const
{
   return mState.mSwizzleState.swizzleRed;
}

void Texture::setSwizzleGreen(const Context *context, GLenum swizzleGreen)
{
   if (mState.mSwizzleState.swizzleGreen != swizzleGreen)
   {
       mState.mSwizzleState.swizzleGreen = swizzleGreen;
       signalDirtyState(DIRTY_BIT_SWIZZLE_GREEN);
   }
}

GLenum Texture::getSwizzleGreen() const
{
   return mState.mSwizzleState.swizzleGreen;
}

void Texture::setSwizzleBlue(const Context *context, GLenum swizzleBlue)
{
   if (mState.mSwizzleState.swizzleBlue != swizzleBlue)
   {
       mState.mSwizzleState.swizzleBlue = swizzleBlue;
       signalDirtyState(DIRTY_BIT_SWIZZLE_BLUE);
   }
}

GLenum Texture::getSwizzleBlue() const
{
   return mState.mSwizzleState.swizzleBlue;
}

void Texture::setSwizzleAlpha(const Context *context, GLenum swizzleAlpha)
{
   if (mState.mSwizzleState.swizzleAlpha != swizzleAlpha)
   {
       mState.mSwizzleState.swizzleAlpha = swizzleAlpha;
       signalDirtyState(DIRTY_BIT_SWIZZLE_ALPHA);
   }
}

GLenum Texture::getSwizzleAlpha() const
{
   return mState.mSwizzleState.swizzleAlpha;
}

void Texture::setMinFilter(const Context *context, GLenum minFilter)
{
   if (mState.mSamplerState.setMinFilter(minFilter))
   {
       signalDirtyState(DIRTY_BIT_MIN_FILTER);
   }
}

GLenum Texture::getMinFilter() const
{
   return mState.mSamplerState.getMinFilter();
}

void Texture::setMagFilter(const Context *context, GLenum magFilter)
{
   if (mState.mSamplerState.setMagFilter(magFilter))
   {
       signalDirtyState(DIRTY_BIT_MAG_FILTER);
   }
}

GLenum Texture::getMagFilter() const
{
   return mState.mSamplerState.getMagFilter();
}

void Texture::setWrapS(const Context *context, GLenum wrapS)
{
   if (mState.mSamplerState.setWrapS(wrapS))
   {
       signalDirtyState(DIRTY_BIT_WRAP_S);
   }
}

GLenum Texture::getWrapS() const
{
   return mState.mSamplerState.getWrapS();
}

void Texture::setWrapT(const Context *context, GLenum wrapT)
{
   if (mState.mSamplerState.getWrapT() == wrapT)
       return;
   if (mState.mSamplerState.setWrapT(wrapT))
   {
       signalDirtyState(DIRTY_BIT_WRAP_T);
   }
}

GLenum Texture::getWrapT() const
{
   return mState.mSamplerState.getWrapT();
}

void Texture::setWrapR(const Context *context, GLenum wrapR)
{
   if (mState.mSamplerState.setWrapR(wrapR))
   {
       signalDirtyState(DIRTY_BIT_WRAP_R);
   }
}

GLenum Texture::getWrapR() const
{
   return mState.mSamplerState.getWrapR();
}

void Texture::setMaxAnisotropy(const Context *context, float maxAnisotropy)
{
   if (mState.mSamplerState.setMaxAnisotropy(maxAnisotropy))
   {
       signalDirtyState(DIRTY_BIT_MAX_ANISOTROPY);
   }
}

float Texture::getMaxAnisotropy() const
{
   return mState.mSamplerState.getMaxAnisotropy();
}

void Texture::setMinLod(const Context *context, GLfloat minLod)
{
   if (mState.mSamplerState.setMinLod(minLod))
   {
       signalDirtyState(DIRTY_BIT_MIN_LOD);
   }
}

GLfloat Texture::getMinLod() const
{
   return mState.mSamplerState.getMinLod();
}

void Texture::setMaxLod(const Context *context, GLfloat maxLod)
{
   if (mState.mSamplerState.setMaxLod(maxLod))
   {
       signalDirtyState(DIRTY_BIT_MAX_LOD);
   }
}

GLfloat Texture::getMaxLod() const
{
   return mState.mSamplerState.getMaxLod();
}

void Texture::setCompareMode(const Context *context, GLenum compareMode)
{
   if (mState.mSamplerState.setCompareMode(compareMode))
   {
       signalDirtyState(DIRTY_BIT_COMPARE_MODE);
   }
}

GLenum Texture::getCompareMode() const
{
   return mState.mSamplerState.getCompareMode();
}

void Texture::setCompareFunc(const Context *context, GLenum compareFunc)
{
   if (mState.mSamplerState.setCompareFunc(compareFunc))
   {
       signalDirtyState(DIRTY_BIT_COMPARE_FUNC);
   }
}

GLenum Texture::getCompareFunc() const
{
   return mState.mSamplerState.getCompareFunc();
}

void Texture::setSRGBDecode(const Context *context, GLenum sRGBDecode)
{
   if (mState.mSamplerState.setSRGBDecode(sRGBDecode))
   {
       signalDirtyState(DIRTY_BIT_SRGB_DECODE);
   }
}

GLenum Texture::getSRGBDecode() const
{
   return mState.mSamplerState.getSRGBDecode();
}

void Texture::setSRGBOverride(const Context *context, GLenum sRGBOverride)
{
   SrgbOverride oldOverride = mState.mSrgbOverride;
   mState.mSrgbOverride = (sRGBOverride == GL_SRGB) ? SrgbOverride::SRGB : SrgbOverride::Default;
   if (mState.mSrgbOverride != oldOverride)
   {
       signalDirtyState(DIRTY_BIT_SRGB_OVERRIDE);
   }
}

GLenum Texture::getSRGBOverride() const
{
   return (mState.mSrgbOverride == SrgbOverride::SRGB) ? GL_SRGB : GL_NONE;
}

const SamplerState &Texture::getSamplerState() const
{
   return mState.mSamplerState;
}

angle::Result Texture::setBaseLevel(const Context *context, GLuint baseLevel)
{
   if (mState.setBaseLevel(baseLevel))
   {
       ANGLE_TRY(mTexture->setBaseLevel(context, mState.getEffectiveBaseLevel()));
       signalDirtyState(DIRTY_BIT_BASE_LEVEL);
   }

   return angle::Result::Continue;
}

GLuint Texture::getBaseLevel() const
{
   return mState.mBaseLevel;
}

void Texture::setMaxLevel(const Context *context, GLuint maxLevel)
{
   if (mState.setMaxLevel(maxLevel))
   {
       signalDirtyState(DIRTY_BIT_MAX_LEVEL);
   }
}

GLuint Texture::getMaxLevel() const
{
   return mState.mMaxLevel;
}

void Texture::setDepthStencilTextureMode(const Context *context, GLenum mode)
{
   if (mState.mDepthStencilTextureMode != mode)
   {
       mState.mDepthStencilTextureMode = mode;
       signalDirtyState(DIRTY_BIT_DEPTH_STENCIL_TEXTURE_MODE);
   }
}

GLenum Texture::getDepthStencilTextureMode() const
{
   return mState.mDepthStencilTextureMode;
}

bool Texture::getImmutableFormat() const
{
   return mState.mImmutableFormat;
}

GLuint Texture::getImmutableLevels() const
{
   return mState.mImmutableLevels;
}

void Texture::setUsage(const Context *context, GLenum usage)
{
   mState.mUsage = usage;
   signalDirtyState(DIRTY_BIT_USAGE);
}

GLenum Texture::getUsage() const
{
   return mState.mUsage;
}

void Texture::setProtectedContent(Context *context, bool hasProtectedContent)
{
   mState.mHasProtectedContent = hasProtectedContent;
}

bool Texture::hasProtectedContent() const
{
   return mState.mHasProtectedContent;
}

const TextureState &Texture::getTextureState() const
{
   return mState;
}

const Extents &Texture::getExtents(TextureTarget target, size_t level) const
{
   ASSERT(TextureTargetToType(target) == mState.mType);
   return mState.getImageDesc(target, level).size;
}

size_t Texture::getWidth(TextureTarget target, size_t level) const
{
   ASSERT(TextureTargetToType(target) == mState.mType);
   return mState.getImageDesc(target, level).size.width;
}

size_t Texture::getHeight(TextureTarget target, size_t level) const
{
   ASSERT(TextureTargetToType(target) == mState.mType);
   return mState.getImageDesc(target, level).size.height;
}

size_t Texture::getDepth(TextureTarget target, size_t level) const
{
   ASSERT(TextureTargetToType(target) == mState.mType);
   return mState.getImageDesc(target, level).size.depth;
}

const Format &Texture::getFormat(TextureTarget target, size_t level) const
{
   ASSERT(TextureTargetToType(target) == mState.mType);
   return mState.getImageDesc(target, level).format;
}

GLsizei Texture::getSamples(TextureTarget target, size_t level) const
{
   ASSERT(TextureTargetToType(target) == mState.mType);
   return mState.getImageDesc(target, level).samples;
}

bool Texture::getFixedSampleLocations(TextureTarget target, size_t level) const
{
   ASSERT(TextureTargetToType(target) == mState.mType);
   return mState.getImageDesc(target, level).fixedSampleLocations;
}

GLuint Texture::getMipmapMaxLevel() const
{
   return mState.getMipmapMaxLevel();
}

bool Texture::isMipmapComplete() const
{
   return mState.computeMipmapCompleteness();
}

egl::Surface *Texture::getBoundSurface() const
{
   return mBoundSurface;
}

egl::Stream *Texture::getBoundStream() const
{
   return mBoundStream;
}

GLint Texture::getMemorySize() const
{
   GLint implSize = mTexture->getMemorySize();
   if (implSize > 0)
   {
       return implSize;
   }

   angle::CheckedNumeric<GLint> size = 0;
   for (const ImageDesc &imageDesc : mState.mImageDescs)
   {
       size += imageDesc.getMemorySize();
   }
   return size.ValueOrDefault(std::numeric_limits<GLint>::max());
}

GLint Texture::getLevelMemorySize(TextureTarget target, GLint level) const
{
   GLint implSize = mTexture->getLevelMemorySize(target, level);
   if (implSize > 0)
   {
       return implSize;
   }

   return mState.getImageDesc(target, level).getMemorySize();
}

void Texture::signalDirtyStorage(InitState initState)
{
   mState.mInitState = initState;
   invalidateCompletenessCache();
   mState.mCachedSamplerFormatValid = false;
   onStateChange(angle::SubjectMessage::SubjectChanged);
}

void Texture::signalDirtyState(size_t dirtyBit)
{
   mDirtyBits.set(dirtyBit);
   invalidateCompletenessCache();
   mState.mCachedSamplerFormatValid = false;

   if (dirtyBit == DIRTY_BIT_BASE_LEVEL || dirtyBit == DIRTY_BIT_MAX_LEVEL)
   {
       onStateChange(angle::SubjectMessage::SubjectChanged);
   }
   else
   {
       onStateChange(angle::SubjectMessage::DirtyBitsFlagged);
   }
}

angle::Result Texture::setImage(Context *context,
                               const PixelUnpackState &unpackState,
                               Buffer *unpackBuffer,
                               TextureTarget target,
                               GLint level,
                               GLenum internalFormat,
                               const Extents &size,
                               GLenum format,
                               GLenum type,
                               const uint8_t *pixels)
{
   ASSERT(TextureTargetToType(target) == mState.mType);

   // Release from previous calls to eglBindTexImage, to avoid calling the Impl after
   ANGLE_TRY(releaseTexImageInternal(context));

   egl::RefCountObjectReleaser<egl::Image> releaseImage;
   ANGLE_TRY(orphanImages(context, &releaseImage));

   ImageIndex index = ImageIndex::MakeFromTarget(target, level, size.depth);

   ANGLE_TRY(mTexture->setImage(context, index, internalFormat, size, format, type, unpackState,
                                unpackBuffer, pixels));

   InitState initState = DetermineInitState(context, unpackBuffer, pixels);
   mState.setImageDesc(target, level, ImageDesc(size, Format(internalFormat, type), initState));

   ANGLE_TRY(handleMipmapGenerationHint(context, level));

   signalDirtyStorage(initState);

   return angle::Result::Continue;
}

angle::Result Texture::setSubImage(Context *context,
                                  const PixelUnpackState &unpackState,
                                  Buffer *unpackBuffer,
                                  TextureTarget target,
                                  GLint level,
                                  const Box &area,
                                  GLenum format,
                                  GLenum type,
                                  const uint8_t *pixels)
{
   ASSERT(TextureTargetToType(target) == mState.mType);

   ImageIndex index = ImageIndex::MakeFromTarget(target, level, area.depth);
   ANGLE_TRY(ensureSubImageInitialized(context, index, area));

   ANGLE_TRY(mTexture->setSubImage(context, index, area, format, type, unpackState, unpackBuffer,
                                   pixels));

   ANGLE_TRY(handleMipmapGenerationHint(context, level));

   onStateChange(angle::SubjectMessage::ContentsChanged);

   return angle::Result::Continue;
}

angle::Result Texture::setCompressedImage(Context *context,
                                         const PixelUnpackState &unpackState,
                                         TextureTarget target,
                                         GLint level,
                                         GLenum internalFormat,
                                         const Extents &size,
                                         size_t imageSize,
                                         const uint8_t *pixels)
{
   ASSERT(TextureTargetToType(target) == mState.mType);

   // Release from previous calls to eglBindTexImage, to avoid calling the Impl after
   ANGLE_TRY(releaseTexImageInternal(context));

   egl::RefCountObjectReleaser<egl::Image> releaseImage;
   ANGLE_TRY(orphanImages(context, &releaseImage));

   ImageIndex index = ImageIndex::MakeFromTarget(target, level, size.depth);

   ANGLE_TRY(mTexture->setCompressedImage(context, index, internalFormat, size, unpackState,
                                          imageSize, pixels));

   Buffer *unpackBuffer = context->getState().getTargetBuffer(BufferBinding::PixelUnpack);

   InitState initState = DetermineInitState(context, unpackBuffer, pixels);
   mState.setImageDesc(target, level, ImageDesc(size, Format(internalFormat), initState));
   signalDirtyStorage(initState);

   return angle::Result::Continue;
}

angle::Result Texture::setCompressedSubImage(const Context *context,
                                            const PixelUnpackState &unpackState,
                                            TextureTarget target,
                                            GLint level,
                                            const Box &area,
                                            GLenum format,
                                            size_t imageSize,
                                            const uint8_t *pixels)
{
   ASSERT(TextureTargetToType(target) == mState.mType);

   ImageIndex index = ImageIndex::MakeFromTarget(target, level, area.depth);
   ANGLE_TRY(ensureSubImageInitialized(context, index, area));

   ANGLE_TRY(mTexture->setCompressedSubImage(context, index, area, format, unpackState, imageSize,
                                             pixels));

   onStateChange(angle::SubjectMessage::ContentsChanged);

   return angle::Result::Continue;
}

angle::Result Texture::copyImage(Context *context,
                                TextureTarget target,
                                GLint level,
                                const Rectangle &sourceArea,
                                GLenum internalFormat,
                                Framebuffer *source)
{
   ASSERT(TextureTargetToType(target) == mState.mType);

   // Release from previous calls to eglBindTexImage, to avoid calling the Impl after
   ANGLE_TRY(releaseTexImageInternal(context));

   egl::RefCountObjectReleaser<egl::Image> releaseImage;
   ANGLE_TRY(orphanImages(context, &releaseImage));

   ImageIndex index = ImageIndex::MakeFromTarget(target, level, 1);

   const InternalFormat &internalFormatInfo =
       GetInternalFormatInfo(internalFormat, GL_UNSIGNED_BYTE);

   // Most if not all renderers clip these copies to the size of the source framebuffer, leaving
   // other pixels untouched. For safety in robust resource initialization, assume that that
   // clipping is going to occur when computing the region for which to ensure initialization. If
   // the copy lies entirely off the source framebuffer, initialize as though a zero-size box is
   // going to be set during the copy operation.
   Box destBox;
   bool forceCopySubImage = false;
   if (context->isRobustResourceInitEnabled())
   {
       const FramebufferAttachment *sourceReadAttachment = source->getReadColorAttachment();
       Extents fbSize                                    = sourceReadAttachment->getSize();
       // Force using copySubImage when the source area is out of bounds AND
       // we're not copying to and from the same texture
       forceCopySubImage = ((sourceArea.x < 0) || (sourceArea.y < 0) ||
                            ((sourceArea.x + sourceArea.width) > fbSize.width) ||
                            ((sourceArea.y + sourceArea.height) > fbSize.height)) &&
                           (sourceReadAttachment->getResource() != this);
       Rectangle clippedArea;
       if (ClipRectangle(sourceArea, Rectangle(0, 0, fbSize.width, fbSize.height), &clippedArea))
       {
           const Offset clippedOffset(clippedArea.x - sourceArea.x, clippedArea.y - sourceArea.y,
                                      0);
           destBox = Box(clippedOffset.x, clippedOffset.y, clippedOffset.z, clippedArea.width,
                         clippedArea.height, 1);
       }
   }

   InitState initState = DetermineInitState(context, nullptr, nullptr);

   // If we need to initialize the destination texture we split the call into a create call,
   // an initializeContents call, and then a copySubImage call. This ensures the destination
   // texture exists before we try to clear it.
   Extents size(sourceArea.width, sourceArea.height, 1);
   if (forceCopySubImage || doesSubImageNeedInit(context, index, destBox))
   {
       ANGLE_TRY(mTexture->setImage(context, index, internalFormat, size,
                                    internalFormatInfo.format, internalFormatInfo.type,
                                    PixelUnpackState(), nullptr, nullptr));
       mState.setImageDesc(target, level, ImageDesc(size, Format(internalFormatInfo), initState));
       ANGLE_TRY(ensureSubImageInitialized(context, index, destBox));
       ANGLE_TRY(mTexture->copySubImage(context, index, Offset(), sourceArea, source));
   }
   else
   {
       ANGLE_TRY(mTexture->copyImage(context, index, sourceArea, internalFormat, source));
   }

   mState.setImageDesc(target, level,
                       ImageDesc(size, Format(internalFormatInfo), InitState::Initialized));

   ANGLE_TRY(handleMipmapGenerationHint(context, level));

   // Because this could affect the texture storage we might need to init other layers/levels.
   signalDirtyStorage(initState);

   return angle::Result::Continue;
}

angle::Result Texture::copySubImage(Context *context,
                                   const ImageIndex &index,
                                   const Offset &destOffset,
                                   const Rectangle &sourceArea,
                                   Framebuffer *source)
{
   ASSERT(TextureTargetToType(index.getTarget()) == mState.mType);

   // Most if not all renderers clip these copies to the size of the source framebuffer, leaving
   // other pixels untouched. For safety in robust resource initialization, assume that that
   // clipping is going to occur when computing the region for which to ensure initialization. If
   // the copy lies entirely off the source framebuffer, initialize as though a zero-size box is
   // going to be set during the copy operation. Note that this assumes that
   // ensureSubImageInitialized ensures initialization of the entire destination texture, and not
   // just a sub-region.
   Box destBox;
   if (context->isRobustResourceInitEnabled())
   {
       Extents fbSize = source->getReadColorAttachment()->getSize();
       Rectangle clippedArea;
       if (ClipRectangle(sourceArea, Rectangle(0, 0, fbSize.width, fbSize.height), &clippedArea))
       {
           const Offset clippedOffset(destOffset.x + clippedArea.x - sourceArea.x,
                                      destOffset.y + clippedArea.y - sourceArea.y, 0);
           destBox = Box(clippedOffset.x, clippedOffset.y, clippedOffset.z, clippedArea.width,
                         clippedArea.height, 1);
       }
   }

   ANGLE_TRY(ensureSubImageInitialized(context, index, destBox));

   ANGLE_TRY(mTexture->copySubImage(context, index, destOffset, sourceArea, source));
   ANGLE_TRY(handleMipmapGenerationHint(context, index.getLevelIndex()));

   onStateChange(angle::SubjectMessage::ContentsChanged);

   return angle::Result::Continue;
}

angle::Result Texture::copyRenderbufferSubData(Context *context,
                                              const gl::Renderbuffer *srcBuffer,
                                              GLint srcLevel,
                                              GLint srcX,
                                              GLint srcY,
                                              GLint srcZ,
                                              GLint dstLevel,
                                              GLint dstX,
                                              GLint dstY,
                                              GLint dstZ,
                                              GLsizei srcWidth,
                                              GLsizei srcHeight,
                                              GLsizei srcDepth)
{
   ANGLE_TRY(mTexture->copyRenderbufferSubData(context, srcBuffer, srcLevel, srcX, srcY, srcZ,
                                               dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight,
                                               srcDepth));

   signalDirtyStorage(InitState::Initialized);

   return angle::Result::Continue;
}

angle::Result Texture::copyTextureSubData(Context *context,
                                         const gl::Texture *srcTexture,
                                         GLint srcLevel,
                                         GLint srcX,
                                         GLint srcY,
                                         GLint srcZ,
                                         GLint dstLevel,
                                         GLint dstX,
                                         GLint dstY,
                                         GLint dstZ,
                                         GLsizei srcWidth,
                                         GLsizei srcHeight,
                                         GLsizei srcDepth)
{
   ANGLE_TRY(mTexture->copyTextureSubData(context, srcTexture, srcLevel, srcX, srcY, srcZ,
                                          dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight,
                                          srcDepth));

   signalDirtyStorage(InitState::Initialized);

   return angle::Result::Continue;
}

angle::Result Texture::copyTexture(Context *context,
                                  TextureTarget target,
                                  GLint level,
                                  GLenum internalFormat,
                                  GLenum type,
                                  GLint sourceLevel,
                                  bool unpackFlipY,
                                  bool unpackPremultiplyAlpha,
                                  bool unpackUnmultiplyAlpha,
                                  Texture *source)
{
   ASSERT(TextureTargetToType(target) == mState.mType);
   ASSERT(source->getType() != TextureType::CubeMap);

   // Release from previous calls to eglBindTexImage, to avoid calling the Impl after
   ANGLE_TRY(releaseTexImageInternal(context));

   egl::RefCountObjectReleaser<egl::Image> releaseImage;
   ANGLE_TRY(orphanImages(context, &releaseImage));

   // Initialize source texture.
   // Note: we don't have a way to notify which portions of the image changed currently.
   ANGLE_TRY(source->ensureInitialized(context));

   ImageIndex index = ImageIndex::MakeFromTarget(target, level, ImageIndex::kEntireLevel);

   ANGLE_TRY(mTexture->copyTexture(context, index, internalFormat, type, sourceLevel, unpackFlipY,
                                   unpackPremultiplyAlpha, unpackUnmultiplyAlpha, source));

   const auto &sourceDesc =
       source->mState.getImageDesc(NonCubeTextureTypeToTarget(source->getType()), sourceLevel);
   const InternalFormat &internalFormatInfo = GetInternalFormatInfo(internalFormat, type);
   mState.setImageDesc(
       target, level,
       ImageDesc(sourceDesc.size, Format(internalFormatInfo), InitState::Initialized));

   signalDirtyStorage(InitState::Initialized);

   return angle::Result::Continue;
}

angle::Result Texture::copySubTexture(const Context *context,
                                     TextureTarget target,
                                     GLint level,
                                     const Offset &destOffset,
                                     GLint sourceLevel,
                                     const Box &sourceBox,
                                     bool unpackFlipY,
                                     bool unpackPremultiplyAlpha,
                                     bool unpackUnmultiplyAlpha,
                                     Texture *source)
{
   ASSERT(TextureTargetToType(target) == mState.mType);

   // Ensure source is initialized.
   ANGLE_TRY(source->ensureInitialized(context));

   Box destBox(destOffset.x, destOffset.y, destOffset.z, sourceBox.width, sourceBox.height,
               sourceBox.depth);
   ImageIndex index = ImageIndex::MakeFromTarget(target, level, sourceBox.depth);
   ANGLE_TRY(ensureSubImageInitialized(context, index, destBox));

   ANGLE_TRY(mTexture->copySubTexture(context, index, destOffset, sourceLevel, sourceBox,
                                      unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha,
                                      source));

   onStateChange(angle::SubjectMessage::ContentsChanged);

   return angle::Result::Continue;
}

angle::Result Texture::copyCompressedTexture(Context *context, const Texture *source)
{
   // Release from previous calls to eglBindTexImage, to avoid calling the Impl after
   ANGLE_TRY(releaseTexImageInternal(context));

   egl::RefCountObjectReleaser<egl::Image> releaseImage;
   ANGLE_TRY(orphanImages(context, &releaseImage));

   ANGLE_TRY(mTexture->copyCompressedTexture(context, source));

   ASSERT(source->getType() != TextureType::CubeMap && getType() != TextureType::CubeMap);
   const auto &sourceDesc =
       source->mState.getImageDesc(NonCubeTextureTypeToTarget(source->getType()), 0);
   mState.setImageDesc(NonCubeTextureTypeToTarget(getType()), 0, sourceDesc);

   return angle::Result::Continue;
}

angle::Result Texture::setStorage(Context *context,
                                 TextureType type,
                                 GLsizei levels,
                                 GLenum internalFormat,
                                 const Extents &size)
{
   ASSERT(type == mState.mType);

   // Release from previous calls to eglBindTexImage, to avoid calling the Impl after
   ANGLE_TRY(releaseTexImageInternal(context));

   egl::RefCountObjectReleaser<egl::Image> releaseImage;
   ANGLE_TRY(orphanImages(context, &releaseImage));

   mState.mImmutableFormat = true;
   mState.mImmutableLevels = static_cast<GLuint>(levels);
   mState.clearImageDescs();
   InitState initState = DetermineInitState(context, nullptr, nullptr);
   mState.setImageDescChain(0, static_cast<GLuint>(levels - 1), size, Format(internalFormat),
                            initState);

   ANGLE_TRY(mTexture->setStorage(context, type, levels, internalFormat, size));

   // Changing the texture to immutable can trigger a change in the base and max levels:
   // GLES 3.0.4 section 3.8.10 pg 158:
   // "For immutable-format textures, levelbase is clamped to the range[0;levels],levelmax is then
   // clamped to the range[levelbase;levels].
   mDirtyBits.set(DIRTY_BIT_BASE_LEVEL);
   mDirtyBits.set(DIRTY_BIT_MAX_LEVEL);

   signalDirtyStorage(initState);

   return angle::Result::Continue;
}

angle::Result Texture::setImageExternal(Context *context,
                                       TextureTarget target,
                                       GLint level,
                                       GLenum internalFormat,
                                       const Extents &size,
                                       GLenum format,
                                       GLenum type)
{
   ASSERT(TextureTargetToType(target) == mState.mType);

   // Release from previous calls to eglBindTexImage, to avoid calling the Impl after
   ANGLE_TRY(releaseTexImageInternal(context));

   egl::RefCountObjectReleaser<egl::Image> releaseImage;
   ANGLE_TRY(orphanImages(context, &releaseImage));

   ImageIndex index = ImageIndex::MakeFromTarget(target, level, size.depth);

   ANGLE_TRY(mTexture->setImageExternal(context, index, internalFormat, size, format, type));

   InitState initState = InitState::Initialized;
   mState.setImageDesc(target, level, ImageDesc(size, Format(internalFormat, type), initState));

   ANGLE_TRY(handleMipmapGenerationHint(context, level));

   signalDirtyStorage(initState);

   return angle::Result::Continue;
}

angle::Result Texture::setStorageMultisample(Context *context,
                                            TextureType type,
                                            GLsizei samplesIn,
                                            GLint internalFormat,
                                            const Extents &size,
                                            bool fixedSampleLocations)
{
   ASSERT(type == mState.mType);

   // Release from previous calls to eglBindTexImage, to avoid calling the Impl after
   ANGLE_TRY(releaseTexImageInternal(context));

   egl::RefCountObjectReleaser<egl::Image> releaseImage;
   ANGLE_TRY(orphanImages(context, &releaseImage));

   // Potentially adjust "samples" to a supported value
   const TextureCaps &formatCaps = context->getTextureCaps().get(internalFormat);
   GLsizei samples               = formatCaps.getNearestSamples(samplesIn);

   mState.mImmutableFormat = true;
   mState.mImmutableLevels = static_cast<GLuint>(1);
   mState.clearImageDescs();
   InitState initState = DetermineInitState(context, nullptr, nullptr);
   mState.setImageDescChainMultisample(size, Format(internalFormat), samples, fixedSampleLocations,
                                       initState);

   ANGLE_TRY(mTexture->setStorageMultisample(context, type, samples, internalFormat, size,
                                             fixedSampleLocations));
   signalDirtyStorage(initState);

   return angle::Result::Continue;
}

angle::Result Texture::setStorageExternalMemory(Context *context,
                                               TextureType type,
                                               GLsizei levels,
                                               GLenum internalFormat,
                                               const Extents &size,
                                               MemoryObject *memoryObject,
                                               GLuint64 offset,
                                               GLbitfield createFlags,
                                               GLbitfield usageFlags,
                                               const void *imageCreateInfoPNext)
{
   ASSERT(type == mState.mType);

   // Release from previous calls to eglBindTexImage, to avoid calling the Impl after
   ANGLE_TRY(releaseTexImageInternal(context));

   egl::RefCountObjectReleaser<egl::Image> releaseImage;
   ANGLE_TRY(orphanImages(context, &releaseImage));

   ANGLE_TRY(mTexture->setStorageExternalMemory(context, type, levels, internalFormat, size,
                                                memoryObject, offset, createFlags, usageFlags,
                                                imageCreateInfoPNext));

   mState.mImmutableFormat = true;
   mState.mImmutableLevels = static_cast<GLuint>(levels);
   mState.clearImageDescs();
   mState.setImageDescChain(0, static_cast<GLuint>(levels - 1), size, Format(internalFormat),
                            InitState::Initialized);

   // Changing the texture to immutable can trigger a change in the base and max levels:
   // GLES 3.0.4 section 3.8.10 pg 158:
   // "For immutable-format textures, levelbase is clamped to the range[0;levels],levelmax is then
   // clamped to the range[levelbase;levels].
   mDirtyBits.set(DIRTY_BIT_BASE_LEVEL);
   mDirtyBits.set(DIRTY_BIT_MAX_LEVEL);

   signalDirtyStorage(InitState::Initialized);

   return angle::Result::Continue;
}

angle::Result Texture::generateMipmap(Context *context)
{
   // Release from previous calls to eglBindTexImage, to avoid calling the Impl after
   ANGLE_TRY(releaseTexImageInternal(context));

   // EGL_KHR_gl_image states that images are only orphaned when generating mipmaps if the texture
   // is not mip complete.
   egl::RefCountObjectReleaser<egl::Image> releaseImage;
   if (!isMipmapComplete())
   {
       ANGLE_TRY(orphanImages(context, &releaseImage));
   }

   const GLuint baseLevel = mState.getEffectiveBaseLevel();
   const GLuint maxLevel  = mState.getMipmapMaxLevel();

   if (maxLevel <= baseLevel)
   {
       return angle::Result::Continue;
   }

   // If any dimension is zero, this is a no-op:
   //
   // > Otherwise, if level_base is not defined, or if any dimension is zero, all mipmap levels are
   // > left unchanged. This is not an error.
   const ImageDesc &baseImageInfo = mState.getImageDesc(mState.getBaseImageTarget(), baseLevel);
   if (baseImageInfo.size.empty())
   {
       return angle::Result::Continue;
   }

   // Clear the base image(s) immediately if needed
   if (context->isRobustResourceInitEnabled())
   {
       ImageIndexIterator it =
           ImageIndexIterator::MakeGeneric(mState.mType, baseLevel, baseLevel + 1,
                                           ImageIndex::kEntireLevel, ImageIndex::kEntireLevel);
       while (it.hasNext())
       {
           const ImageIndex index = it.next();
           const ImageDesc &desc  = mState.getImageDesc(index.getTarget(), index.getLevelIndex());

           if (desc.initState == InitState::MayNeedInit)
           {
               ANGLE_TRY(initializeContents(context, GL_NONE, index));
           }
       }
   }

   ANGLE_TRY(syncState(context, Command::GenerateMipmap));
   ANGLE_TRY(mTexture->generateMipmap(context));

   // Propagate the format and size of the base mip to the smaller ones. Cube maps are guaranteed
   // to have faces of the same size and format so any faces can be picked.
   mState.setImageDescChain(baseLevel, maxLevel, baseImageInfo.size, baseImageInfo.format,
                            InitState::Initialized);

   signalDirtyStorage(InitState::Initialized);

   return angle::Result::Continue;
}

angle::Result Texture::bindTexImageFromSurface(Context *context, egl::Surface *surface)
{
   ASSERT(surface);

   if (mBoundSurface)
   {
       ANGLE_TRY(releaseTexImageFromSurface(context));
   }

   mBoundSurface = surface;

   // Set the image info to the size and format of the surface
   ASSERT(mState.mType == TextureType::_2D || mState.mType == TextureType::Rectangle);
   Extents size(surface->getWidth(), surface->getHeight(), 1);
   ImageDesc desc(size, surface->getBindTexImageFormat(), InitState::Initialized);
   mState.setImageDesc(NonCubeTextureTypeToTarget(mState.mType), 0, desc);
   mState.mHasProtectedContent = surface->hasProtectedContent();

   ANGLE_TRY(mTexture->bindTexImage(context, surface));

   signalDirtyStorage(InitState::Initialized);
   return angle::Result::Continue;
}

angle::Result Texture::releaseTexImageFromSurface(const Context *context)
{
   ASSERT(mBoundSurface);
   mBoundSurface = nullptr;
   ANGLE_TRY(mTexture->releaseTexImage(context));

   // Erase the image info for level 0
   ASSERT(mState.mType == TextureType::_2D || mState.mType == TextureType::Rectangle);
   mState.clearImageDesc(NonCubeTextureTypeToTarget(mState.mType), 0);
   mState.mHasProtectedContent = false;
   signalDirtyStorage(InitState::Initialized);
   return angle::Result::Continue;
}

void Texture::bindStream(egl::Stream *stream)
{
   ASSERT(stream);

   // It should not be possible to bind a texture already bound to another stream
   ASSERT(mBoundStream == nullptr);

   mBoundStream = stream;

   ASSERT(mState.mType == TextureType::External);
}

void Texture::releaseStream()
{
   ASSERT(mBoundStream);
   mBoundStream = nullptr;
}

angle::Result Texture::acquireImageFromStream(const Context *context,
                                             const egl::Stream::GLTextureDescription &desc)
{
   ASSERT(mBoundStream != nullptr);
   ANGLE_TRY(mTexture->setImageExternal(context, mState.mType, mBoundStream, desc));

   Extents size(desc.width, desc.height, 1);
   mState.setImageDesc(NonCubeTextureTypeToTarget(mState.mType), 0,
                       ImageDesc(size, Format(desc.internalFormat), InitState::Initialized));
   signalDirtyStorage(InitState::Initialized);
   return angle::Result::Continue;
}

angle::Result Texture::releaseImageFromStream(const Context *context)
{
   ASSERT(mBoundStream != nullptr);
   ANGLE_TRY(mTexture->setImageExternal(context, mState.mType, nullptr,
                                        egl::Stream::GLTextureDescription()));

   // Set to incomplete
   mState.clearImageDesc(NonCubeTextureTypeToTarget(mState.mType), 0);
   signalDirtyStorage(InitState::Initialized);
   return angle::Result::Continue;
}

angle::Result Texture::releaseTexImageInternal(Context *context)
{
   if (mBoundSurface)
   {
       // Notify the surface
       egl::Error eglErr = mBoundSurface->releaseTexImageFromTexture(context);
       // TODO(jmadill): Remove this once refactor is complete. http://anglebug.com/3041
       if (eglErr.isError())
       {
           context->handleError(GL_INVALID_OPERATION, "Error releasing tex image from texture",
                                __FILE__, ANGLE_FUNCTION, __LINE__);
       }

       // Then, call the same method as from the surface
       ANGLE_TRY(releaseTexImageFromSurface(context));
   }
   return angle::Result::Continue;
}

angle::Result Texture::setEGLImageTargetImpl(Context *context,
                                            TextureType type,
                                            GLuint levels,
                                            egl::Image *imageTarget)
{
   ASSERT(type == mState.mType);

   // Release from previous calls to eglBindTexImage, to avoid calling the Impl after
   ANGLE_TRY(releaseTexImageInternal(context));

   egl::RefCountObjectReleaser<egl::Image> releaseImage;
   ANGLE_TRY(orphanImages(context, &releaseImage));

   setTargetImage(context, imageTarget);

   auto initState = imageTarget->sourceInitState();

   mState.clearImageDescs();
   mState.setImageDescChain(0, levels - 1, imageTarget->getExtents(), imageTarget->getFormat(),
                            initState);
   mState.mHasProtectedContent = imageTarget->hasProtectedContent();

   ANGLE_TRY(mTexture->setEGLImageTarget(context, type, imageTarget));

   signalDirtyStorage(initState);

   return angle::Result::Continue;
}

angle::Result Texture::setEGLImageTarget(Context *context,
                                        TextureType type,
                                        egl::Image *imageTarget)
{
   ASSERT(type == TextureType::_2D || type == TextureType::External ||
          type == TextureType::_2DArray);

   return setEGLImageTargetImpl(context, type, 1u, imageTarget);
}

angle::Result Texture::setStorageEGLImageTarget(Context *context,
                                               TextureType type,
                                               egl::Image *imageTarget,
                                               const GLint *attrib_list)
{
   ASSERT(type == TextureType::External || type == TextureType::_3D || type == TextureType::_2D ||
          type == TextureType::_2DArray || type == TextureType::CubeMap ||
          type == TextureType::CubeMapArray);

   ANGLE_TRY(setEGLImageTargetImpl(context, type, imageTarget->getLevelCount(), imageTarget));

   mState.mImmutableLevels = imageTarget->getLevelCount();
   mState.mImmutableFormat = true;

   // Changing the texture to immutable can trigger a change in the base and max levels:
   // GLES 3.0.4 section 3.8.10 pg 158:
   // "For immutable-format textures, levelbase is clamped to the range[0;levels],levelmax is then
   // clamped to the range[levelbase;levels].
   mDirtyBits.set(DIRTY_BIT_BASE_LEVEL);
   mDirtyBits.set(DIRTY_BIT_MAX_LEVEL);

   return angle::Result::Continue;
}

Extents Texture::getAttachmentSize(const ImageIndex &imageIndex) const
{
   // As an ImageIndex that represents an entire level of a cube map corresponds to 6 ImageDescs,
   // we only allow querying ImageDesc on a complete cube map, and this ImageDesc is exactly the
   // one that belongs to the first face of the cube map.
   if (imageIndex.isEntireLevelCubeMap())
   {
       // A cube map texture is cube complete if the following conditions all hold true:
       // - The levelbase arrays of each of the six texture images making up the cube map have
       //   identical, positive, and square dimensions.
       if (!mState.isCubeComplete())
       {
           return Extents();
       }
   }

   return mState.getImageDesc(imageIndex).size;
}

Format Texture::getAttachmentFormat(GLenum /*binding*/, const ImageIndex &imageIndex) const
{
   // As an ImageIndex that represents an entire level of a cube map corresponds to 6 ImageDescs,
   // we only allow querying ImageDesc on a complete cube map, and this ImageDesc is exactly the
   // one that belongs to the first face of the cube map.
   if (imageIndex.isEntireLevelCubeMap())
   {
       // A cube map texture is cube complete if the following conditions all hold true:
       // - The levelbase arrays were each specified with the same effective internal format.
       if (!mState.isCubeComplete())
       {
           return Format::Invalid();
       }
   }
   return mState.getImageDesc(imageIndex).format;
}

GLsizei Texture::getAttachmentSamples(const ImageIndex &imageIndex) const
{
   // We do not allow querying TextureTarget by an ImageIndex that represents an entire level of a
   // cube map (See comments in function TextureTypeToTarget() in ImageIndex.cpp).
   if (imageIndex.isEntireLevelCubeMap())
   {
       return 0;
   }

   return getSamples(imageIndex.getTarget(), imageIndex.getLevelIndex());
}

bool Texture::isRenderable(const Context *context,
                          GLenum binding,
                          const ImageIndex &imageIndex) const
{
   if (isEGLImageTarget())
   {
       return ImageSibling::isRenderable(context, binding, imageIndex);
   }

   // Surfaces bound to textures are always renderable. This avoids issues with surfaces with ES3+
   // formats not being renderable when bound to textures in ES2 contexts.
   if (mBoundSurface)
   {
       return true;
   }

   return getAttachmentFormat(binding, imageIndex)
       .info->textureAttachmentSupport(context->getClientVersion(), context->getExtensions());
}

bool Texture::getAttachmentFixedSampleLocations(const ImageIndex &imageIndex) const
{
   // We do not allow querying TextureTarget by an ImageIndex that represents an entire level of a
   // cube map (See comments in function TextureTypeToTarget() in ImageIndex.cpp).
   if (imageIndex.isEntireLevelCubeMap())
   {
       return true;
   }

   // ES3.1 (section 9.4) requires that the value of TEXTURE_FIXED_SAMPLE_LOCATIONS should be
   // the same for all attached textures.
   return getFixedSampleLocations(imageIndex.getTarget(), imageIndex.getLevelIndex());
}

void Texture::setBorderColor(const Context *context, const ColorGeneric &color)
{
   mState.mSamplerState.setBorderColor(color);
   signalDirtyState(DIRTY_BIT_BORDER_COLOR);
}

const ColorGeneric &Texture::getBorderColor() const
{
   return mState.mSamplerState.getBorderColor();
}

GLint Texture::getRequiredTextureImageUnits(const Context *context) const
{
   // Only external texture types can return non-1.
   if (mState.mType != TextureType::External)
   {
       return 1;
   }

   return mTexture->getRequiredExternalTextureImageUnits(context);
}

void Texture::setCrop(const Rectangle &rect)
{
   mState.setCrop(rect);
}

const Rectangle &Texture::getCrop() const
{
   return mState.getCrop();
}

void Texture::setGenerateMipmapHint(GLenum hint)
{
   mState.setGenerateMipmapHint(hint);
}

GLenum Texture::getGenerateMipmapHint() const
{
   return mState.getGenerateMipmapHint();
}

angle::Result Texture::setBuffer(const gl::Context *context,
                                gl::Buffer *buffer,
                                GLenum internalFormat)
{
   // Use 0 to indicate that the size is taken from whatever size the buffer has when the texture
   // buffer is used.
   return setBufferRange(context, buffer, internalFormat, 0, 0);
}

angle::Result Texture::setBufferRange(const gl::Context *context,
                                     gl::Buffer *buffer,
                                     GLenum internalFormat,
                                     GLintptr offset,
                                     GLsizeiptr size)
{
   mState.mImmutableFormat = true;
   mState.mBuffer.set(context, buffer, offset, size);
   ANGLE_TRY(mTexture->setBuffer(context, internalFormat));

   mState.clearImageDescs();
   if (buffer == nullptr)
   {
       mBufferObserver.reset();
       InitState initState = DetermineInitState(context, nullptr, nullptr);
       signalDirtyStorage(initState);
       return angle::Result::Continue;
   }

   size = GetBoundBufferAvailableSize(mState.mBuffer);

   mState.mImmutableLevels           = static_cast<GLuint>(1);
   InternalFormat internalFormatInfo = GetSizedInternalFormatInfo(internalFormat);
   Format format(internalFormat);
   Extents extents(static_cast<GLuint>(size / internalFormatInfo.pixelBytes), 1, 1);
   InitState initState = buffer->initState();
   mState.setImageDesc(TextureTarget::Buffer, 0, ImageDesc(extents, format, initState));

   signalDirtyStorage(initState);

   // Observe modifications to the buffer, so that extents can be updated.
   mBufferObserver.bind(buffer);

   return angle::Result::Continue;
}

const OffsetBindingPointer<Buffer> &Texture::getBuffer() const
{
   return mState.mBuffer;
}

void Texture::onAttach(const Context *context, rx::Serial framebufferSerial)
{
   addRef();

   // Duplicates allowed for multiple attachment points. See the comment in the header.
   mBoundFramebufferSerials.push_back(framebufferSerial);

   if (!mState.mHasBeenBoundAsAttachment)
   {
       mDirtyBits.set(DIRTY_BIT_BOUND_AS_ATTACHMENT);
       mState.mHasBeenBoundAsAttachment = true;
   }
}

void Texture::onDetach(const Context *context, rx::Serial framebufferSerial)
{
   // Erase first instance. If there are multiple bindings, leave the others.
   ASSERT(isBoundToFramebuffer(framebufferSerial));
   mBoundFramebufferSerials.remove_and_permute(framebufferSerial);

   release(context);
}

GLuint Texture::getId() const
{
   return id().value;
}

GLuint Texture::getNativeID() const
{
   return mTexture->getNativeID();
}

angle::Result Texture::syncState(const Context *context, Command source)
{
   ASSERT(hasAnyDirtyBit() || source == Command::GenerateMipmap);
   ANGLE_TRY(mTexture->syncState(context, mDirtyBits, source));
   mDirtyBits.reset();
   mState.mInitState = InitState::Initialized;
   return angle::Result::Continue;
}

rx::FramebufferAttachmentObjectImpl *Texture::getAttachmentImpl() const
{
   return mTexture;
}

bool Texture::isSamplerComplete(const Context *context, const Sampler *optionalSampler)
{
   const auto &samplerState =
       optionalSampler ? optionalSampler->getSamplerState() : mState.mSamplerState;
   const auto &contextState = context->getState();

   if (contextState.getContextID() != mCompletenessCache.context ||
       !mCompletenessCache.samplerState.sameCompleteness(samplerState))
   {
       mCompletenessCache.context      = context->getState().getContextID();
       mCompletenessCache.samplerState = samplerState;
       mCompletenessCache.samplerComplete =
           mState.computeSamplerCompleteness(samplerState, contextState);
   }

   return mCompletenessCache.samplerComplete;
}

// CopyImageSubData requires that we ignore format-based completeness rules
bool Texture::isSamplerCompleteForCopyImage(const Context *context,
                                           const Sampler *optionalSampler) const
{
   const gl::SamplerState &samplerState =
       optionalSampler ? optionalSampler->getSamplerState() : mState.mSamplerState;
   const gl::State &contextState = context->getState();
   return mState.computeSamplerCompletenessForCopyImage(samplerState, contextState);
}

Texture::SamplerCompletenessCache::SamplerCompletenessCache()
   : context({0}), samplerState(), samplerComplete(false)
{}

void Texture::invalidateCompletenessCache() const
{
   mCompletenessCache.context = {0};
}

angle::Result Texture::ensureInitialized(const Context *context)
{
   if (!context->isRobustResourceInitEnabled() || mState.mInitState == InitState::Initialized)
   {
       return angle::Result::Continue;
   }

   bool anyDirty = false;

   ImageIndexIterator it =
       ImageIndexIterator::MakeGeneric(mState.mType, 0, IMPLEMENTATION_MAX_TEXTURE_LEVELS + 1,
                                       ImageIndex::kEntireLevel, ImageIndex::kEntireLevel);
   while (it.hasNext())
   {
       const ImageIndex index = it.next();
       ImageDesc &desc =
           mState.mImageDescs[GetImageDescIndex(index.getTarget(), index.getLevelIndex())];
       if (desc.initState == InitState::MayNeedInit && !desc.size.empty())
       {
           ASSERT(mState.mInitState == InitState::MayNeedInit);
           ANGLE_TRY(initializeContents(context, GL_NONE, index));
           desc.initState = InitState::Initialized;
           anyDirty       = true;
       }
   }
   if (anyDirty)
   {
       signalDirtyStorage(InitState::Initialized);
   }
   mState.mInitState = InitState::Initialized;

   return angle::Result::Continue;
}

InitState Texture::initState(GLenum /*binding*/, const ImageIndex &imageIndex) const
{
   // As an ImageIndex that represents an entire level of a cube map corresponds to 6 ImageDescs,
   // we need to check all the related ImageDescs.
   if (imageIndex.isEntireLevelCubeMap())
   {
       const GLint levelIndex = imageIndex.getLevelIndex();
       for (TextureTarget cubeFaceTarget : AllCubeFaceTextureTargets())
       {
           if (mState.getImageDesc(cubeFaceTarget, levelIndex).initState == InitState::MayNeedInit)
           {
               return InitState::MayNeedInit;
           }
       }
       return InitState::Initialized;
   }

   return mState.getImageDesc(imageIndex).initState;
}

void Texture::setInitState(GLenum binding, const ImageIndex &imageIndex, InitState initState)
{
   // As an ImageIndex that represents an entire level of a cube map corresponds to 6 ImageDescs,
   // we need to update all the related ImageDescs.
   if (imageIndex.isEntireLevelCubeMap())
   {
       const GLint levelIndex = imageIndex.getLevelIndex();
       for (TextureTarget cubeFaceTarget : AllCubeFaceTextureTargets())
       {
           setInitState(binding, ImageIndex::MakeCubeMapFace(cubeFaceTarget, levelIndex),
                        initState);
       }
   }
   else
   {
       ImageDesc newDesc = mState.getImageDesc(imageIndex);
       newDesc.initState = initState;
       mState.setImageDesc(imageIndex.getTarget(), imageIndex.getLevelIndex(), newDesc);
   }
}

void Texture::setInitState(InitState initState)
{
   for (ImageDesc &imageDesc : mState.mImageDescs)
   {
       // Only modify defined images, undefined images will remain in the initialized state
       if (!imageDesc.size.empty())
       {
           imageDesc.initState = initState;
       }
   }
   mState.mInitState = initState;
}

bool Texture::doesSubImageNeedInit(const Context *context,
                                  const ImageIndex &imageIndex,
                                  const Box &area) const
{
   if (!context->isRobustResourceInitEnabled() || mState.mInitState == InitState::Initialized)
   {
       return false;
   }

   // Pre-initialize the texture contents if necessary.
   const ImageDesc &desc = mState.getImageDesc(imageIndex);
   if (desc.initState != InitState::MayNeedInit)
   {
       return false;
   }

   ASSERT(mState.mInitState == InitState::MayNeedInit);
   return !area.coversSameExtent(desc.size);
}

angle::Result Texture::ensureSubImageInitialized(const Context *context,
                                                const ImageIndex &imageIndex,
                                                const Box &area)
{
   if (doesSubImageNeedInit(context, imageIndex, area))
   {
       // NOTE: do not optimize this to only initialize the passed area of the texture, or the
       // initialization logic in copySubImage will be incorrect.
       ANGLE_TRY(initializeContents(context, GL_NONE, imageIndex));
   }
   // Note: binding is ignored for textures.
   setInitState(GL_NONE, imageIndex, InitState::Initialized);
   return angle::Result::Continue;
}

angle::Result Texture::handleMipmapGenerationHint(Context *context, int level)
{
   if (getGenerateMipmapHint() == GL_TRUE && level == 0)
   {
       ANGLE_TRY(generateMipmap(context));
   }

   return angle::Result::Continue;
}

void Texture::onSubjectStateChange(angle::SubjectIndex index, angle::SubjectMessage message)
{
   switch (message)
   {
       case angle::SubjectMessage::ContentsChanged:
           if (index != kBufferSubjectIndex)
           {
               // ContentsChange originates from TextureStorage11::resolveAndReleaseTexture
               // which resolves the underlying multisampled texture if it exists and so
               // Texture will signal dirty storage to invalidate its own cache and the
               // attached framebuffer's cache.
               signalDirtyStorage(InitState::Initialized);
           }
           break;
       case angle::SubjectMessage::DirtyBitsFlagged:
           signalDirtyState(DIRTY_BIT_IMPLEMENTATION);

           // Notify siblings that we are dirty.
           if (index == rx::kTextureImageImplObserverMessageIndex)
           {
               notifySiblings(message);
           }
           break;
       case angle::SubjectMessage::SubjectChanged:
           mState.mInitState = InitState::MayNeedInit;
           signalDirtyState(DIRTY_BIT_IMPLEMENTATION);
           onStateChange(angle::SubjectMessage::ContentsChanged);

           // Notify siblings that we are dirty.
           if (index == rx::kTextureImageImplObserverMessageIndex)
           {
               notifySiblings(message);
           }
           else if (index == kBufferSubjectIndex)
           {
               const gl::Buffer *buffer = mState.mBuffer.get();
               ASSERT(buffer != nullptr);

               // Update cached image desc based on buffer size.
               GLsizeiptr size = GetBoundBufferAvailableSize(mState.mBuffer);

               ImageDesc desc          = mState.getImageDesc(TextureTarget::Buffer, 0);
               const GLuint pixelBytes = desc.format.info->pixelBytes;
               desc.size.width         = static_cast<GLuint>(size / pixelBytes);

               mState.setImageDesc(TextureTarget::Buffer, 0, desc);
           }
           break;
       case angle::SubjectMessage::StorageReleased:
           // When the TextureStorage is released, it needs to update the
           // RenderTargetCache of the Framebuffer attaching this Texture.
           // This is currently only for D3D back-end. See http://crbug.com/1234829
           if (index == rx::kTextureImageImplObserverMessageIndex)
           {
               onStateChange(angle::SubjectMessage::StorageReleased);
           }
           break;
       case angle::SubjectMessage::SubjectMapped:
       case angle::SubjectMessage::SubjectUnmapped:
       case angle::SubjectMessage::BindingChanged:
           ASSERT(index == kBufferSubjectIndex);
           break;
       case angle::SubjectMessage::InitializationComplete:
           ASSERT(index == rx::kTextureImageImplObserverMessageIndex);
           setInitState(InitState::Initialized);
           break;
       case angle::SubjectMessage::InternalMemoryAllocationChanged:
           // Need to mark the texture dirty to give the back end a chance to handle the new
           // buffer. For example, the Vulkan back end needs to create a new buffer view that
           // points to the newly allocated buffer and update the texture descriptor set.
           signalDirtyState(DIRTY_BIT_IMPLEMENTATION);
           break;
       default:
           UNREACHABLE();
           break;
   }
}

GLenum Texture::getImplementationColorReadFormat(const Context *context) const
{
   return mTexture->getColorReadFormat(context);
}

GLenum Texture::getImplementationColorReadType(const Context *context) const
{
   return mTexture->getColorReadType(context);
}

bool Texture::isCompressedFormatEmulated(const Context *context,
                                        TextureTarget target,
                                        GLint level) const
{
   if (!getFormat(target, level).info->compressed)
   {
       // If it isn't compressed, the remaining logic won't work
       return false;
   }

   GLenum implFormat = getImplementationColorReadFormat(context);

   // Check against the list of formats used to emulate compressed textures
   return IsEmulatedCompressedFormat(implFormat);
}

angle::Result Texture::getTexImage(const Context *context,
                                  const PixelPackState &packState,
                                  Buffer *packBuffer,
                                  TextureTarget target,
                                  GLint level,
                                  GLenum format,
                                  GLenum type,
                                  void *pixels)
{
   // No-op if the image level is empty.
   if (getExtents(target, level).empty())
   {
       return angle::Result::Continue;
   }

   return mTexture->getTexImage(context, packState, packBuffer, target, level, format, type,
                                pixels);
}

angle::Result Texture::getCompressedTexImage(const Context *context,
                                            const PixelPackState &packState,
                                            Buffer *packBuffer,
                                            TextureTarget target,
                                            GLint level,
                                            void *pixels)
{
   // No-op if the image level is empty.
   if (getExtents(target, level).empty())
   {
       return angle::Result::Continue;
   }

   return mTexture->getCompressedTexImage(context, packState, packBuffer, target, level, pixels);
}

void Texture::onBindAsImageTexture()
{
   if (!mState.mHasBeenBoundAsImage)
   {
       mDirtyBits.set(DIRTY_BIT_BOUND_AS_IMAGE);
       mState.mHasBeenBoundAsImage = true;
   }
}

void Texture::onBind3DTextureAs2DImage()
{
   if (!mState.mIs3DAndHasBeenBoundAs2DImage)
   {
       mDirtyBits.set(DIRTY_BIT_BOUND_AS_IMAGE);
       mState.mIs3DAndHasBeenBoundAs2DImage = true;
   }
}

}  // namespace gl