[Reland] Check if internal_format is valid for GenerateMipmap().

BUG=429053
TEST=gpu_unittests,webgl2_conformance
R=piman@chromium.org
NOPRESUBMIT=true

Review URL: https://codereview.chromium.org/1616043002

Cr-Commit-Position: refs/heads/master@{#370841}

9 files changed, 264 insertions, 34 deletions

diff --git a/gpu/command_buffer/build_gles2_cmd_buffer.py b/gpu/command_buffer/build_gles2_cmd_buffer.py
index efdd2963..9794fc2 100755
--- a/gpu/command_buffer/build_gles2_cmd_buffer.py
+++ b/gpu/command_buffer/build_gles2_cmd_buffer.py
@@ -1933,6 +1933,74 @@ _NAMED_TYPE_INFO = {
       'GL_BGR',
     ],
   },
+  'TextureUnsizedInternalFormat': {
+    'type': 'GLenum',
+    'valid': [
+      'GL_ALPHA',
+      'GL_LUMINANCE',
+      'GL_LUMINANCE_ALPHA',
+      'GL_RGB',
+      'GL_RGBA',
+    ],
+  },
+  'TextureSizedColorRenderableInternalFormat': {
+    'type': 'GLenum',
+    'valid': [
+      'GL_R8',
+      'GL_R8UI',
+      'GL_R8I',
+      'GL_R16UI',
+      'GL_R16I',
+      'GL_R32UI',
+      'GL_R32I',
+      'GL_RG8',
+      'GL_RG8UI',
+      'GL_RG8I',
+      'GL_RG16UI',
+      'GL_RG16I',
+      'GL_RG32UI',
+      'GL_RG32I',
+      'GL_RGB8',
+      'GL_RGB565',
+      'GL_RGBA8',
+      'GL_SRGB8_ALPHA8',
+      'GL_RGB5_A1',
+      'GL_RGBA4',
+      'GL_RGB10_A2',
+      'GL_RGBA8UI',
+      'GL_RGBA8I',
+      'GL_RGB10_A2UI',
+      'GL_RGBA16UI',
+      'GL_RGBA16I',
+      'GL_RGBA32UI',
+      'GL_RGBA32I',
+    ],
+  },
+  'TextureSizedTextureFilterableInternalFormat': {
+    'type': 'GLenum',
+    'valid': [
+      'GL_R8',
+      'GL_R8_SNORM',
+      'GL_R16F',
+      'GL_RG8',
+      'GL_RG8_SNORM',
+      'GL_RG16F',
+      'GL_RGB8',
+      'GL_SRGB8',
+      'GL_RGB565',
+      'GL_RGB8_SNORM',
+      'GL_R11F_G11F_B10F',
+      'GL_RGB9_E5',
+      'GL_RGB16F',
+      'GL_RGBA8',
+      'GL_SRGB8_ALPHA8',
+      'GL_RGBA8_SNORM',
+      'GL_RGB5_A1',
+      'GL_RGBA4',
+      'GL_RGB10_A2',
+      'GL_RGBA16F',
+    ],
+  },
   'TextureInternalFormatStorage': {
     'type': 'GLenum',
     'valid': [
diff --git a/gpu/command_buffer/common/gles2_cmd_utils_autogen.h b/gpu/command_buffer/common/gles2_cmd_utils_autogen.h
index a7167cf..f68b352 100644
--- a/gpu/command_buffer/common/gles2_cmd_utils_autogen.h
+++ b/gpu/command_buffer/common/gles2_cmd_utils_autogen.h
@@ -89,7 +89,12 @@ static std::string GetStringTextureInternalFormatStorage(uint32_t value);
 static std::string GetStringTextureMagFilterMode(uint32_t value);
 static std::string GetStringTextureMinFilterMode(uint32_t value);
 static std::string GetStringTextureParameter(uint32_t value);
+static std::string GetStringTextureSizedColorRenderableInternalFormat(
+    uint32_t value);
+static std::string GetStringTextureSizedTextureFilterableInternalFormat(
+    uint32_t value);
 static std::string GetStringTextureTarget(uint32_t value);
+static std::string GetStringTextureUnsizedInternalFormat(uint32_t value);
 static std::string GetStringTextureUsage(uint32_t value);
 static std::string GetStringTextureWrapMode(uint32_t value);
 static std::string GetStringTransformFeedbackBindTarget(uint32_t value);
diff --git a/gpu/command_buffer/common/gles2_cmd_utils_implementation_autogen.h b/gpu/command_buffer/common/gles2_cmd_utils_implementation_autogen.h
index dcf3983..b501a18 100644
--- a/gpu/command_buffer/common/gles2_cmd_utils_implementation_autogen.h
+++ b/gpu/command_buffer/common/gles2_cmd_utils_implementation_autogen.h
@@ -4771,6 +4771,70 @@ std::string GLES2Util::GetStringTextureParameter(uint32_t value) {
                                            arraysize(string_table), value);
 }
 
+std::string GLES2Util::GetStringTextureSizedColorRenderableInternalFormat(
+    uint32_t value) {
+  static const EnumToString string_table[] = {
+      {GL_R8, "GL_R8"},
+      {GL_R8UI, "GL_R8UI"},
+      {GL_R8I, "GL_R8I"},
+      {GL_R16UI, "GL_R16UI"},
+      {GL_R16I, "GL_R16I"},
+      {GL_R32UI, "GL_R32UI"},
+      {GL_R32I, "GL_R32I"},
+      {GL_RG8, "GL_RG8"},
+      {GL_RG8UI, "GL_RG8UI"},
+      {GL_RG8I, "GL_RG8I"},
+      {GL_RG16UI, "GL_RG16UI"},
+      {GL_RG16I, "GL_RG16I"},
+      {GL_RG32UI, "GL_RG32UI"},
+      {GL_RG32I, "GL_RG32I"},
+      {GL_RGB8, "GL_RGB8"},
+      {GL_RGB565, "GL_RGB565"},
+      {GL_RGBA8, "GL_RGBA8"},
+      {GL_SRGB8_ALPHA8, "GL_SRGB8_ALPHA8"},
+      {GL_RGB5_A1, "GL_RGB5_A1"},
+      {GL_RGBA4, "GL_RGBA4"},
+      {GL_RGB10_A2, "GL_RGB10_A2"},
+      {GL_RGBA8UI, "GL_RGBA8UI"},
+      {GL_RGBA8I, "GL_RGBA8I"},
+      {GL_RGB10_A2UI, "GL_RGB10_A2UI"},
+      {GL_RGBA16UI, "GL_RGBA16UI"},
+      {GL_RGBA16I, "GL_RGBA16I"},
+      {GL_RGBA32UI, "GL_RGBA32UI"},
+      {GL_RGBA32I, "GL_RGBA32I"},
+  };
+  return GLES2Util::GetQualifiedEnumString(string_table,
+                                           arraysize(string_table), value);
+}
+
+std::string GLES2Util::GetStringTextureSizedTextureFilterableInternalFormat(
+    uint32_t value) {
+  static const EnumToString string_table[] = {
+      {GL_R8, "GL_R8"},
+      {GL_R8_SNORM, "GL_R8_SNORM"},
+      {GL_R16F, "GL_R16F"},
+      {GL_RG8, "GL_RG8"},
+      {GL_RG8_SNORM, "GL_RG8_SNORM"},
+      {GL_RG16F, "GL_RG16F"},
+      {GL_RGB8, "GL_RGB8"},
+      {GL_SRGB8, "GL_SRGB8"},
+      {GL_RGB565, "GL_RGB565"},
+      {GL_RGB8_SNORM, "GL_RGB8_SNORM"},
+      {GL_R11F_G11F_B10F, "GL_R11F_G11F_B10F"},
+      {GL_RGB9_E5, "GL_RGB9_E5"},
+      {GL_RGB16F, "GL_RGB16F"},
+      {GL_RGBA8, "GL_RGBA8"},
+      {GL_SRGB8_ALPHA8, "GL_SRGB8_ALPHA8"},
+      {GL_RGBA8_SNORM, "GL_RGBA8_SNORM"},
+      {GL_RGB5_A1, "GL_RGB5_A1"},
+      {GL_RGBA4, "GL_RGBA4"},
+      {GL_RGB10_A2, "GL_RGB10_A2"},
+      {GL_RGBA16F, "GL_RGBA16F"},
+  };
+  return GLES2Util::GetQualifiedEnumString(string_table,
+                                           arraysize(string_table), value);
+}
+
 std::string GLES2Util::GetStringTextureTarget(uint32_t value) {
   static const EnumToString string_table[] = {
       {GL_TEXTURE_2D, "GL_TEXTURE_2D"},
@@ -4785,6 +4849,18 @@ std::string GLES2Util::GetStringTextureTarget(uint32_t value) {
                                            arraysize(string_table), value);
 }
 
+std::string GLES2Util::GetStringTextureUnsizedInternalFormat(uint32_t value) {
+  static const EnumToString string_table[] = {
+      {GL_ALPHA, "GL_ALPHA"},
+      {GL_LUMINANCE, "GL_LUMINANCE"},
+      {GL_LUMINANCE_ALPHA, "GL_LUMINANCE_ALPHA"},
+      {GL_RGB, "GL_RGB"},
+      {GL_RGBA, "GL_RGBA"},
+  };
+  return GLES2Util::GetQualifiedEnumString(string_table,
+                                           arraysize(string_table), value);
+}
+
 std::string GLES2Util::GetStringTextureUsage(uint32_t value) {
   static const EnumToString string_table[] = {
       {GL_NONE, "GL_NONE"},
diff --git a/gpu/command_buffer/service/feature_info.cc b/gpu/command_buffer/service/feature_info.cc
index 1b51948..849f2ef 100644
--- a/gpu/command_buffer/service/feature_info.cc
+++ b/gpu/command_buffer/service/feature_info.cc
@@ -528,6 +528,7 @@ void FeatureInfo::InitializeFeatures() {
     validators_.render_buffer_format.AddValue(GL_SRGB8_ALPHA8_EXT);
     validators_.frame_buffer_parameter.AddValue(
         GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT);
+    validators_.texture_unsized_internal_format.AddValue(GL_SRGB_ALPHA_EXT);
   }
 
   bool enable_texture_format_bgra8888 = false;
@@ -559,6 +560,7 @@ void FeatureInfo::InitializeFeatures() {
     AddExtensionString("GL_EXT_texture_format_BGRA8888");
     validators_.texture_internal_format.AddValue(GL_BGRA_EXT);
     validators_.texture_format.AddValue(GL_BGRA_EXT);
+    validators_.texture_unsized_internal_format.AddValue(GL_BGRA_EXT);
   }
 
   if (enable_read_format_bgra) {
@@ -650,6 +652,14 @@ void FeatureInfo::InitializeFeatures() {
     AddExtensionString("GL_OES_texture_float");
     if (enable_texture_float_linear) {
       AddExtensionString("GL_OES_texture_float_linear");
+      validators_.texture_sized_texture_filterable_internal_format.AddValue(
+          GL_R32F);
+      validators_.texture_sized_texture_filterable_internal_format.AddValue(
+          GL_RG32F);
+      validators_.texture_sized_texture_filterable_internal_format.AddValue(
+          GL_RGB32F);
+      validators_.texture_sized_texture_filterable_internal_format.AddValue(
+          GL_RGBA32F);
     }
   }
 
@@ -694,14 +704,14 @@ void FeatureInfo::InitializeFeatures() {
     glBindFramebufferEXT(GL_FRAMEBUFFER, fb_id);
     glFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
                               GL_TEXTURE_2D, tex_id, 0);
-    GLenum statusRGBA = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER);
+    GLenum status_rgba = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER);
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB32F, width, width, 0, GL_RGB,
                  GL_FLOAT, NULL);
-    GLenum statusRGB = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER);
+    GLenum status_rgb = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER);
 
     // For desktop systems, check to see if we support rendering to the full
     // range of formats supported by EXT_color_buffer_float
-    if (statusRGBA == GL_FRAMEBUFFER_COMPLETE && IsES3Capable()) {
+    if (status_rgba == GL_FRAMEBUFFER_COMPLETE && IsES3Capable()) {
       bool full_float_support = true;
 
       glTexImage2D(GL_TEXTURE_2D, 0, GL_R16F, width, width, 0, GL_RED,
@@ -740,13 +750,17 @@ void FeatureInfo::InitializeFeatures() {
 
     DCHECK(glGetError() == GL_NO_ERROR);
 
-    if (statusRGBA == GL_FRAMEBUFFER_COMPLETE) {
+    if (status_rgba == GL_FRAMEBUFFER_COMPLETE) {
       validators_.texture_internal_format.AddValue(GL_RGBA32F);
+      validators_.texture_sized_color_renderable_internal_format.AddValue(
+          GL_RGBA32F);
       feature_flags_.chromium_color_buffer_float_rgba = true;
       AddExtensionString("GL_CHROMIUM_color_buffer_float_rgba");
     }
-    if (statusRGB == GL_FRAMEBUFFER_COMPLETE) {
+    if (status_rgb == GL_FRAMEBUFFER_COMPLETE) {
       validators_.texture_internal_format.AddValue(GL_RGB32F);
+      validators_.texture_sized_color_renderable_internal_format.AddValue(
+          GL_RGB32F);
       feature_flags_.chromium_color_buffer_float_rgb = true;
       AddExtensionString("GL_CHROMIUM_color_buffer_float_rgb");
     }
@@ -762,6 +776,20 @@ void FeatureInfo::InitializeFeatures() {
     validators_.render_buffer_format.AddValue(GL_RG32F);
     validators_.render_buffer_format.AddValue(GL_RGBA32F);
     validators_.render_buffer_format.AddValue(GL_R11F_G11F_B10F);
+    validators_.texture_sized_color_renderable_internal_format.AddValue(
+        GL_R16F);
+    validators_.texture_sized_color_renderable_internal_format.AddValue(
+        GL_RG16F);
+    validators_.texture_sized_color_renderable_internal_format.AddValue(
+        GL_RGBA16F);
+    validators_.texture_sized_color_renderable_internal_format.AddValue(
+        GL_R32F);
+    validators_.texture_sized_color_renderable_internal_format.AddValue(
+        GL_RG32F);
+    validators_.texture_sized_color_renderable_internal_format.AddValue(
+        GL_RGBA32F);
+    validators_.texture_sized_color_renderable_internal_format.AddValue(
+        GL_R11F_G11F_B10F);
   }
 
   // Check for multisample support
@@ -1197,6 +1225,8 @@ void FeatureInfo::InitializeFeatures() {
     validators_.read_pixel_format.AddValue(GL_RG_EXT);
     validators_.render_buffer_format.AddValue(GL_R8_EXT);
     validators_.render_buffer_format.AddValue(GL_RG8_EXT);
+    validators_.texture_unsized_internal_format.AddValue(GL_RED_EXT);
+    validators_.texture_unsized_internal_format.AddValue(GL_RG_EXT);
   }
   UMA_HISTOGRAM_BOOLEAN("GPU.TextureRG", feature_flags_.ext_texture_rg);
 
diff --git a/gpu/command_buffer/service/gles2_cmd_validation_autogen.h b/gpu/command_buffer/service/gles2_cmd_validation_autogen.h
index e98aa2c..c3a7b39 100644
--- a/gpu/command_buffer/service/gles2_cmd_validation_autogen.h
+++ b/gpu/command_buffer/service/gles2_cmd_validation_autogen.h
@@ -346,7 +346,10 @@ class TextureMinFilterModeValidator {
 TextureMinFilterModeValidator texture_min_filter_mode;
 
 ValueValidator<GLenum> texture_parameter;
+ValueValidator<GLenum> texture_sized_color_renderable_internal_format;
+ValueValidator<GLenum> texture_sized_texture_filterable_internal_format;
 ValueValidator<GLenum> texture_target;
+ValueValidator<GLenum> texture_unsized_internal_format;
 class TextureUsageValidator {
  public:
   bool IsValid(const GLenum value) const;
diff --git a/gpu/command_buffer/service/gles2_cmd_validation_implementation_autogen.h b/gpu/command_buffer/service/gles2_cmd_validation_implementation_autogen.h
index aeaecd0..2d0091f 100644
--- a/gpu/command_buffer/service/gles2_cmd_validation_implementation_autogen.h
+++ b/gpu/command_buffer/service/gles2_cmd_validation_implementation_autogen.h
@@ -1192,6 +1192,25 @@ static const GLenum valid_texture_parameter_table_es3[] = {
     GL_TEXTURE_WRAP_R,
 };
 
+static const GLenum
+    valid_texture_sized_color_renderable_internal_format_table[] = {
+        GL_R8,       GL_R8UI,     GL_R8I,          GL_R16UI,      GL_R16I,
+        GL_R32UI,    GL_R32I,     GL_RG8,          GL_RG8UI,      GL_RG8I,
+        GL_RG16UI,   GL_RG16I,    GL_RG32UI,       GL_RG32I,      GL_RGB8,
+        GL_RGB565,   GL_RGBA8,    GL_SRGB8_ALPHA8, GL_RGB5_A1,    GL_RGBA4,
+        GL_RGB10_A2, GL_RGBA8UI,  GL_RGBA8I,       GL_RGB10_A2UI, GL_RGBA16UI,
+        GL_RGBA16I,  GL_RGBA32UI, GL_RGBA32I,
+};
+
+static const GLenum
+    valid_texture_sized_texture_filterable_internal_format_table[] = {
+        GL_R8,        GL_R8_SNORM,   GL_R16F,           GL_RG8,
+        GL_RG8_SNORM, GL_RG16F,      GL_RGB8,           GL_SRGB8,
+        GL_RGB565,    GL_RGB8_SNORM, GL_R11F_G11F_B10F, GL_RGB9_E5,
+        GL_RGB16F,    GL_RGBA8,      GL_SRGB8_ALPHA8,   GL_RGBA8_SNORM,
+        GL_RGB5_A1,   GL_RGBA4,      GL_RGB10_A2,       GL_RGBA16F,
+};
+
 static const GLenum valid_texture_target_table[] = {
     GL_TEXTURE_2D,
     GL_TEXTURE_CUBE_MAP_POSITIVE_X,
@@ -1202,6 +1221,10 @@ static const GLenum valid_texture_target_table[] = {
     GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
 };
 
+static const GLenum valid_texture_unsized_internal_format_table[] = {
+    GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_RGBA,
+};
+
 bool Validators::TextureUsageValidator::IsValid(const GLenum value) const {
   switch (value) {
     case GL_NONE:
@@ -1366,8 +1389,19 @@ Validators::Validators()
           arraysize(valid_texture_internal_format_storage_table)),
       texture_parameter(valid_texture_parameter_table,
                         arraysize(valid_texture_parameter_table)),
+      texture_sized_color_renderable_internal_format(
+          valid_texture_sized_color_renderable_internal_format_table,
+          arraysize(
+              valid_texture_sized_color_renderable_internal_format_table)),
+      texture_sized_texture_filterable_internal_format(
+          valid_texture_sized_texture_filterable_internal_format_table,
+          arraysize(
+              valid_texture_sized_texture_filterable_internal_format_table)),
       texture_target(valid_texture_target_table,
                      arraysize(valid_texture_target_table)),
+      texture_unsized_internal_format(
+          valid_texture_unsized_internal_format_table,
+          arraysize(valid_texture_unsized_internal_format_table)),
       transform_feedback_bind_target(
           valid_transform_feedback_bind_target_table,
           arraysize(valid_transform_feedback_bind_target_table)),
diff --git a/gpu/command_buffer/service/texture_manager.cc b/gpu/command_buffer/service/texture_manager.cc
index 212daf3..d428c37 100644
--- a/gpu/command_buffer/service/texture_manager.cc
+++ b/gpu/command_buffer/service/texture_manager.cc
@@ -529,11 +529,9 @@ void Texture::SetMailboxManager(MailboxManager* mailbox_manager) {
   mailbox_manager_ = mailbox_manager;
 }
 
-bool Texture::MarkMipmapsGenerated(
+void Texture::MarkMipmapsGenerated(
     const FeatureInfo* feature_info) {
-  if (!CanGenerateMipmaps(feature_info)) {
-    return false;
-  }
+  DCHECK(CanGenerateMipmaps(feature_info));
   for (size_t ii = 0; ii < face_infos_.size(); ++ii) {
     const Texture::FaceInfo& face_info = face_infos_[ii];
     const Texture::LevelInfo& level0_info = face_info.level_infos[base_level_];
@@ -554,8 +552,6 @@ bool Texture::MarkMipmapsGenerated(
                    level0_info.type, gfx::Rect(width, height));
     }
   }
-
-  return true;
 }
 
 void Texture::SetTarget(
@@ -600,20 +596,33 @@ bool Texture::CanGenerateMipmaps(
     return false;
   }
 
-  // TODO(gman): Check internal_format, format and type.
+  bool valid_internal_format = false;
+  if (feature_info->validators()->texture_unsized_internal_format.IsValid(
+      base.internal_format)) {
+    valid_internal_format = true;
+  } else if (feature_info->validators()->
+      texture_sized_color_renderable_internal_format.IsValid(
+          base.internal_format) && feature_info->validators()->
+      texture_sized_texture_filterable_internal_format.IsValid(
+          base.internal_format)) {
+    valid_internal_format = true;
+  }
+  if (!valid_internal_format) {
+    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) || (info.width != base.width) ||
-        (info.height != base.height) || (info.depth != base.depth) ||
-        (info.format != base.format) ||
-        (info.internal_format != base.internal_format) ||
-        (info.type != base.type) ||
+    if ((info.target == 0) ||
         feature_info->validators()->compressed_texture_format.IsValid(
             info.internal_format) ||
         info.image.get()) {
       return false;
     }
   }
+  if (face_infos_.size() == 6 && !cube_complete_) {
+    return false;
+  }
   return true;
 }
 
@@ -1112,7 +1121,8 @@ void Texture::Update(const FeatureInfo* feature_info) {
   texture_complete_ =
       max_level_set_ >= (levels_needed - 1) && max_level_set_ >= 0;
   cube_complete_ = (face_infos_.size() == 6) &&
-                   (first_level.width == first_level.height);
+                   (first_level.width == first_level.height) &&
+                   (first_level.width > 0);
 
   if (first_level.width == 0 || first_level.height == 0) {
     texture_complete_ = false;
@@ -1695,13 +1705,12 @@ void TextureManager::SetParameterf(
   }
 }
 
-bool TextureManager::MarkMipmapsGenerated(TextureRef* ref) {
+void TextureManager::MarkMipmapsGenerated(TextureRef* ref) {
   DCHECK(ref);
   Texture* texture = ref->texture();
   texture->GetMemTracker()->TrackMemFree(texture->estimated_size());
-  bool result = texture->MarkMipmapsGenerated(feature_info_.get());
+  texture->MarkMipmapsGenerated(feature_info_.get());
   texture->GetMemTracker()->TrackMemAlloc(texture->estimated_size());
-  return result;
 }
 
 TextureRef* TextureManager::CreateTexture(
diff --git a/gpu/command_buffer/service/texture_manager.h b/gpu/command_buffer/service/texture_manager.h
index e106b73..e33df330 100644
--- a/gpu/command_buffer/service/texture_manager.h
+++ b/gpu/command_buffer/service/texture_manager.h
@@ -344,7 +344,7 @@ class GPU_EXPORT Texture {
       const FeatureInfo* feature_info, GLenum pname, GLfloat param);
 
   // Makes each of the mip levels as though they were generated.
-  bool MarkMipmapsGenerated(const FeatureInfo* feature_info);
+  void MarkMipmapsGenerated(const FeatureInfo* feature_info);
 
   bool NeedsMips() const {
     return min_filter_ != GL_NEAREST && min_filter_ != GL_LINEAR;
@@ -756,8 +756,7 @@ class GPU_EXPORT TextureManager : public base::trace_event::MemoryDumpProvider {
       TextureRef* ref, GLenum pname, GLfloat param);
 
   // Makes each of the mip levels as though they were generated.
-  // Returns false if that's not allowed for the given texture.
-  bool MarkMipmapsGenerated(TextureRef* ref);
+  void MarkMipmapsGenerated(TextureRef* ref);
 
   // Clears any uncleared renderable levels.
   bool ClearRenderableLevels(GLES2Decoder* decoder, TextureRef* ref);
diff --git a/gpu/command_buffer/service/texture_manager_unittest.cc b/gpu/command_buffer/service/texture_manager_unittest.cc
index e1ed65646..c8eeddc 100644
--- a/gpu/command_buffer/service/texture_manager_unittest.cc
+++ b/gpu/command_buffer/service/texture_manager_unittest.cc
@@ -710,7 +710,7 @@ TEST_F(TextureTest, POT2D) {
 
   EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_ref_.get()));
   // Make mips.
-  EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_ref_.get()));
+  manager_->MarkMipmapsGenerated(texture_ref_.get());
   EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
   EXPECT_TRUE(manager_->CanRender(texture_ref_.get()));
   EXPECT_FALSE(manager_->HaveUnrenderableTextures());
@@ -727,7 +727,7 @@ TEST_F(TextureTest, POT2D) {
                          0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect(4, 4));
   EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_ref_.get()));
   // Make mips.
-  EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_ref_.get()));
+  manager_->MarkMipmapsGenerated(texture_ref_.get());
   EXPECT_TRUE(manager_->CanRender(texture_ref_.get()));
   EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
   EXPECT_FALSE(manager_->HaveUnrenderableTextures());
@@ -789,7 +789,8 @@ TEST_F(TextureMemoryTrackerTest, MarkMipmapsGenerated) {
                          0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect(4, 4));
   EXPECT_MEMORY_ALLOCATION_CHANGE(64, 0);
   EXPECT_MEMORY_ALLOCATION_CHANGE(0, 84);
-  EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_ref_.get()));
+  EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_ref_.get()));
+  manager_->MarkMipmapsGenerated(texture_ref_.get());
   EXPECT_MEMORY_ALLOCATION_CHANGE(84, 0);
   EXPECT_MEMORY_ALLOCATION_CHANGE(0, 0);
 }
@@ -801,7 +802,8 @@ TEST_F(TextureTest, UnusedMips) {
   // Set level zero to large size.
   manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 1,
                          0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect(4, 4));
-  EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_ref_.get()));
+  EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_ref_.get()));
+  manager_->MarkMipmapsGenerated(texture_ref_.get());
   EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
   EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
   EXPECT_TRUE(manager_->CanRender(texture_ref_.get()));
@@ -809,7 +811,8 @@ TEST_F(TextureTest, UnusedMips) {
   // Set level zero to large smaller (levels unused mips)
   manager_->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 1,
                          0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect(2, 2));
-  EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_ref_.get()));
+  EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_ref_.get()));
+  manager_->MarkMipmapsGenerated(texture_ref_.get());
   EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
   EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
   EXPECT_TRUE(manager_->CanRender(texture_ref_.get()));
@@ -883,7 +886,7 @@ TEST_F(TextureTest, NPOT2DNPOTOK) {
   EXPECT_TRUE(manager.CanGenerateMipmaps(texture_ref));
   EXPECT_FALSE(manager.CanRender(texture_ref));
   EXPECT_TRUE(manager.HaveUnrenderableTextures());
-  EXPECT_TRUE(manager.MarkMipmapsGenerated(texture_ref));
+  manager.MarkMipmapsGenerated(texture_ref);
   EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
   EXPECT_TRUE(manager.CanRender(texture_ref));
   EXPECT_FALSE(manager.HaveUnrenderableTextures());
@@ -951,7 +954,7 @@ TEST_F(TextureTest, POTCubeMap) {
   EXPECT_TRUE(manager_->HaveUnrenderableTextures());
 
   // Make mips.
-  EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_ref_.get()));
+  manager_->MarkMipmapsGenerated(texture_ref_.get());
   EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
   EXPECT_TRUE(TextureTestHelper::IsCubeComplete(texture));
   EXPECT_TRUE(manager_->CanRender(texture_ref_.get()));
@@ -971,7 +974,7 @@ TEST_F(TextureTest, POTCubeMap) {
                          gfx::Rect(4, 4));
   EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_ref_.get()));
   // Make mips.
-  EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_ref_.get()));
+  manager_->MarkMipmapsGenerated(texture_ref_.get());
   EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
   EXPECT_TRUE(TextureTestHelper::IsCubeComplete(texture));
 }
@@ -1337,6 +1340,7 @@ TEST_F(TextureTest, SafeUnsafe) {
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
   EXPECT_TRUE(manager_->HaveUnclearedMips());
   EXPECT_EQ(1, texture->num_uncleared_mips());
+  EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_ref_.get()));
   manager_->MarkMipmapsGenerated(texture_ref_.get());
   EXPECT_TRUE(texture->SafeToRenderFrom());
   EXPECT_FALSE(manager_->HaveUnsafeTextures());
@@ -1747,7 +1751,8 @@ TEST_F(ProduceConsumeTextureTest, ProduceConsume2D) {
   LevelInfo level0(GL_TEXTURE_2D, GL_RGBA, 4, 4, 1, 0, GL_UNSIGNED_BYTE,
                    gfx::Rect(4, 4));
   SetLevelInfo(texture_ref_.get(), 0, level0);
-  EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_ref_.get()));
+  EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_ref_.get()));
+  manager_->MarkMipmapsGenerated(texture_ref_.get());
   EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
   LevelInfo level1 = GetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 1);
   LevelInfo level2 = GetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 2);
@@ -1759,7 +1764,8 @@ TEST_F(ProduceConsumeTextureTest, ProduceConsume2D) {
   manager_->SetTarget(texture2_.get(), GL_TEXTURE_2D);
   SetLevelInfo(texture2_.get(), 0, LevelInfo(GL_TEXTURE_2D, GL_RGBA, 16, 16, 1,
                                              0, GL_UNSIGNED_BYTE, gfx::Rect()));
-  EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture2_.get()));
+  EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_ref_.get()));
+  manager_->MarkMipmapsGenerated(texture2_.get());
   texture = texture2_->texture();
   EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
   EXPECT_EQ(1024U + 256U + 64U + 16U + 4U, texture->estimated_size());