change enable_es3 to context_type in SetupFeatureInfo

gpu/command_buffer/service/texture_manager_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "gpu/command_buffer/service/texture_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 63 matching lines @@
 
   ~TextureManagerTest() override {}
 
  protected:
   void SetUp() override {
     GpuServiceTest::SetUp();
     manager_.reset(new TextureManager(
         NULL, feature_info_.get(), kMaxTextureSize, kMaxCubeMapTextureSize,
         kMaxRectangleTextureSize, kMax3DTextureSize, kMaxArrayTextureLayers,
         kUseDefaultTextures, nullptr));
-    SetupFeatureInfo("", "OpenGL ES 2.0", false);
+    SetupFeatureInfo("", "OpenGL ES 2.0", CONTEXT_TYPE_OPENGLES2);
     TestHelper::SetupTextureManagerInitExpectations(
         gl_.get(), false, false, false, "", kUseDefaultTextures);
     manager_->Initialize();
     error_state_.reset(new ::testing::StrictMock<gles2::MockErrorState>());
   }
 
   void TearDown() override {
     manager_->Destroy(false);
     manager_.reset();
     GpuServiceTest::TearDown();
   }
 
   void SetParameter(
       TextureRef* texture_ref, GLenum pname, GLint value, GLenum error) {
     TestHelper::SetTexParameteriWithExpectations(
         gl_.get(), error_state_.get(), manager_.get(),
         texture_ref, pname, value, error);
   }
 
   void SetupFeatureInfo(const char* gl_extensions,
                         const char* gl_version,
-                        bool enable_es3) {
-    ContextType context_type =
-        enable_es3 ? CONTEXT_TYPE_OPENGLES3 : CONTEXT_TYPE_OPENGLES2;
+                        ContextType context_type) {
     TestHelper::SetupFeatureInfoInitExpectationsWithGLVersion(
         gl_.get(), gl_extensions, "", gl_version, context_type);
     feature_info_->InitializeForTesting(context_type);
     ASSERT_TRUE(feature_info_->context_type() == context_type);
     if (feature_info_->IsWebGL2OrES3Context()) {
       EXPECT_CALL(*gl_, GetIntegerv(GL_MAX_COLOR_ATTACHMENTS, _))
           .WillOnce(SetArgPointee<1>(8))
           .RetiresOnSaturation();
       EXPECT_CALL(*gl_, GetIntegerv(GL_MAX_DRAW_BUFFERS, _))
           .WillOnce(SetArgPointee<1>(8))
@@ skipping 149 matching lines @@
   EXPECT_TRUE(manager.GetDefaultTextureInfo(GL_TEXTURE_2D) == NULL);
   EXPECT_TRUE(manager.GetDefaultTextureInfo(GL_TEXTURE_CUBE_MAP) == NULL);
 
   // TODO(vmiura): Test GL_TEXTURE_EXTERNAL_OES & GL_TEXTURE_RECTANGLE_ARB.
 
   manager.Destroy(false);
 }
 
 TEST_F(TextureManagerTest, UseDefaultTexturesTrueES3) {
   bool use_default_textures = true;
-  SetupFeatureInfo("", "OpenGL ES 3.0", true);
+  SetupFeatureInfo("", "OpenGL ES 3.0", CONTEXT_TYPE_OPENGLES3);
   TestHelper::SetupTextureManagerInitExpectations(gl_.get(),
       true, true, false, "", use_default_textures);
   TextureManager manager(nullptr, feature_info_.get(), kMaxTextureSize,
                          kMaxCubeMapTextureSize, kMaxRectangleTextureSize,
                          kMax3DTextureSize, kMaxArrayTextureLayers,
                          use_default_textures, nullptr);
   manager.Initialize();
 
   EXPECT_TRUE(manager.GetDefaultTextureInfo(GL_TEXTURE_3D) != NULL);
   EXPECT_TRUE(manager.GetDefaultTextureInfo(GL_TEXTURE_2D_ARRAY) != NULL);
 
   manager.Destroy(false);
 }
 
 TEST_F(TextureManagerTest, UseDefaultTexturesFalseES3) {
   bool use_default_textures = false;
-  SetupFeatureInfo("", "OpenGL ES 3.0", true);
+  SetupFeatureInfo("", "OpenGL ES 3.0", CONTEXT_TYPE_OPENGLES3);
   TestHelper::SetupTextureManagerInitExpectations(gl_.get(),
       true, true, false, "", use_default_textures);
   TextureManager manager(nullptr, feature_info_.get(), kMaxTextureSize,
                          kMaxCubeMapTextureSize, kMaxRectangleTextureSize,
                          kMax3DTextureSize, kMaxArrayTextureLayers,
                          use_default_textures, nullptr);
   manager.Initialize();
 
   EXPECT_TRUE(manager.GetDefaultTextureInfo(GL_TEXTURE_3D) == NULL);
   EXPECT_TRUE(manager.GetDefaultTextureInfo(GL_TEXTURE_2D_ARRAY) == NULL);
@@ skipping 197 matching lines @@
   EXPECT_TRUE(manager.ValidForTarget(GL_TEXTURE_2D, 1, 5, 2, 1));
   // Check NPOT height on level 1
   EXPECT_TRUE(manager.ValidForTarget(GL_TEXTURE_2D, 1, 2, 5, 1));
   manager.Destroy(false);
 }
 
 TEST_F(TextureManagerTest, AlphaLuminanceCompatibilityProfile) {
   const GLuint kClientId = 1;
   const GLuint kServiceId = 11;
 
-  SetupFeatureInfo("", "2.1", false);
+  SetupFeatureInfo("", "2.1", CONTEXT_TYPE_OPENGLES2);
   TestHelper::SetupTextureManagerInitExpectations(gl_.get(), false, false,
       false, "", kUseDefaultTextures);
   TextureManager manager(nullptr, feature_info_.get(), kMaxTextureSize,
                          kMaxCubeMapTextureSize, kMaxRectangleTextureSize,
                          kMax3DTextureSize, kMaxArrayTextureLayers,
                          kUseDefaultTextures, nullptr);
   manager.Initialize();
 
   // Create a texture.
   manager.CreateTexture(kClientId, kServiceId);
@@ skipping 20 matching lines @@
   EXPECT_CALL(*gl_, DeleteTextures(1, ::testing::Pointee(kServiceId)))
       .Times(1)
       .RetiresOnSaturation();
   manager.RemoveTexture(kClientId);
 }
 
 TEST_F(TextureManagerTest, AlphaLuminanceCoreProfileEmulation) {
   const GLuint kClientId = 1;
   const GLuint kServiceId = 11;
 
-  SetupFeatureInfo("", "4.2", true);
+  SetupFeatureInfo("", "4.2", CONTEXT_TYPE_OPENGLES3);
   TestHelper::SetupTextureManagerInitExpectations(gl_.get(), true, true, true,
       "", kUseDefaultTextures);
   TextureManager manager(nullptr, feature_info_.get(), kMaxTextureSize,
                          kMaxCubeMapTextureSize, kMaxRectangleTextureSize,
                          kMax3DTextureSize, kMaxArrayTextureLayers,
                          kUseDefaultTextures, nullptr);
   manager.Initialize();
 
   // Create a texture.
   manager.CreateTexture(kClientId, kServiceId);
@@ skipping 1605 matching lines @@
                            kUseDefaultTextures, nullptr));
     memory_tracker2_ = new CountingMemoryTracker;
     texture_manager2_.reset(
         new TextureManager(memory_tracker2_.get(), feature_info_.get(),
                            TextureManagerTest::kMaxTextureSize,
                            TextureManagerTest::kMaxCubeMapTextureSize,
                            TextureManagerTest::kMaxRectangleTextureSize,
                            TextureManagerTest::kMax3DTextureSize,
                            TextureManagerTest::kMaxArrayTextureLayers,
                            kUseDefaultTextures, nullptr));
-    SetupFeatureInfo("", "OpenGL ES 2.0", false);
+    SetupFeatureInfo("", "OpenGL ES 2.0", CONTEXT_TYPE_OPENGLES2);
     TestHelper::SetupTextureManagerInitExpectations(
         gl_.get(), false, false, false, "", kUseDefaultTextures);
     texture_manager1_->Initialize();
     TestHelper::SetupTextureManagerInitExpectations(
         gl_.get(), false, false, false, "", kUseDefaultTextures);
     texture_manager2_->Initialize();
   }
 
   void TearDown() override {
     texture_manager2_->Destroy(false);
     texture_manager2_.reset();
     texture_manager1_->Destroy(false);
     texture_manager1_.reset();
     GpuServiceTest::TearDown();
   }
 
  protected:
   void SetupFeatureInfo(const char* gl_extensions,
                         const char* gl_version,
-                        bool enable_es3) {
-    ContextType context_type =
-        enable_es3 ? CONTEXT_TYPE_OPENGLES3 : CONTEXT_TYPE_OPENGLES2;
+                        ContextType context_type) {
     TestHelper::SetupFeatureInfoInitExpectationsWithGLVersion(
         gl_.get(), gl_extensions, "", gl_version, context_type);
     feature_info_->InitializeForTesting(context_type);
     ASSERT_TRUE(feature_info_->context_type() == context_type);
     if (feature_info_->IsWebGL2OrES3Context()) {
       EXPECT_CALL(*gl_, GetIntegerv(GL_MAX_COLOR_ATTACHMENTS, _))
           .WillOnce(SetArgPointee<1>(8))
           .RetiresOnSaturation();
       EXPECT_CALL(*gl_, GetIntegerv(GL_MAX_DRAW_BUFFERS, _))
           .WillOnce(SetArgPointee<1>(8))
@@ skipping 254 matching lines @@
                 SetGLErrorInvalidEnum(_, _, _, _, _))
         .Times(1)
         .RetiresOnSaturation();
     EXPECT_FALSE(manager_->ValidateTextureParameters(
         error_state_.get(), "", tex_image_call,
         format, type, internal_format, 0));
   }
 };
 
 TEST_F(TextureFormatTypeValidationTest, ES2Basic) {
-  SetupFeatureInfo("", "OpenGL ES 2.0", false);
+  SetupFeatureInfo("", "OpenGL ES 2.0", CONTEXT_TYPE_OPENGLES2);
 
   ExpectValid(true, GL_ALPHA, GL_UNSIGNED_BYTE, GL_ALPHA);
   ExpectValid(true, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, GL_RGB);
   ExpectValid(true, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4, GL_RGBA);
   ExpectValid(true, GL_LUMINANCE, GL_UNSIGNED_BYTE, GL_LUMINANCE);
   ExpectValid(true, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, GL_LUMINANCE_ALPHA);
 
   ExpectInvalid(true, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, GL_ALPHA);
 
   // float / half_float.
@@ skipping 12 matching lines @@
   // SRGB
   ExpectInvalidEnum(true, GL_SRGB_EXT, GL_UNSIGNED_BYTE, GL_SRGB_EXT);
   ExpectInvalidEnum(
       true, GL_SRGB_ALPHA_EXT, GL_UNSIGNED_BYTE, GL_SRGB_ALPHA_EXT);
 
   // ES3
   ExpectInvalid(true, GL_RGB, GL_UNSIGNED_BYTE, GL_RGB8);
 }
 
 TEST_F(TextureFormatTypeValidationTest, ES2WithExtTextureFormatBGRA8888) {
-  SetupFeatureInfo("GL_EXT_texture_format_BGRA8888", "OpenGL ES 2.0", false);
+  SetupFeatureInfo("GL_EXT_texture_format_BGRA8888", "OpenGL ES 2.0",
+                   CONTEXT_TYPE_OPENGLES2);
 
   ExpectValid(true, GL_BGRA_EXT, GL_UNSIGNED_BYTE, GL_BGRA_EXT);
 }
 
 TEST_F(TextureFormatTypeValidationTest, ES2WithAppleTextureFormatBGRA8888) {
-  SetupFeatureInfo("GL_APPLE_texture_format_BGRA8888", "OpenGL ES 2.0", false);
+  SetupFeatureInfo("GL_APPLE_texture_format_BGRA8888", "OpenGL ES 2.0",
+                   CONTEXT_TYPE_OPENGLES2);
 
   ExpectValid(true, GL_BGRA_EXT, GL_UNSIGNED_BYTE, GL_BGRA_EXT);
 }
 
 TEST_F(TextureFormatTypeValidationTest, ES2WithArbDepth) {
-  SetupFeatureInfo("GL_ARB_depth_texture", "OpenGL ES 2.0", false);
+  SetupFeatureInfo("GL_ARB_depth_texture", "OpenGL ES 2.0",
+                   CONTEXT_TYPE_OPENGLES2);
 
   ExpectValid(true, GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT, GL_DEPTH_COMPONENT);
   ExpectValid(true, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, GL_DEPTH_COMPONENT);
   ExpectInvalidEnum(
       true, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, GL_DEPTH_STENCIL);
 }
 
 TEST_F(TextureFormatTypeValidationTest, ES2WithOesDepth) {
-  SetupFeatureInfo("GL_OES_depth_texture", "OpenGL ES 2.0", false);
+  SetupFeatureInfo("GL_OES_depth_texture", "OpenGL ES 2.0",
+                   CONTEXT_TYPE_OPENGLES2);
 
   ExpectValid(true, GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT, GL_DEPTH_COMPONENT);
   ExpectValid(true, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, GL_DEPTH_COMPONENT);
   ExpectInvalidEnum(
       true, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, GL_DEPTH_STENCIL);
 }
 
 TEST_F(TextureFormatTypeValidationTest, ES2WithAngleDepth) {
-  SetupFeatureInfo("GL_ANGLE_depth_texture", "OpenGL ES 2.0", false);
+  SetupFeatureInfo("GL_ANGLE_depth_texture", "OpenGL ES 2.0",
+                   CONTEXT_TYPE_OPENGLES2);
 
   ExpectValid(true, GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT, GL_DEPTH_COMPONENT);
   ExpectValid(true, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, GL_DEPTH_COMPONENT);
   ExpectInvalidEnum(
       true, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, GL_DEPTH_STENCIL);
 }
 
 TEST_F(TextureFormatTypeValidationTest, ES2WithExtPackedDepthStencil) {
-  SetupFeatureInfo(
-      "GL_EXT_packed_depth_stencil GL_ARB_depth_texture",
-      "OpenGL ES 2.0",
-      false);
+  SetupFeatureInfo("GL_EXT_packed_depth_stencil GL_ARB_depth_texture",
+                   "OpenGL ES 2.0", CONTEXT_TYPE_OPENGLES2);
 
   ExpectValid(true, GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT, GL_DEPTH_COMPONENT);
   ExpectValid(true, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, GL_DEPTH_COMPONENT);
   ExpectValid(true, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, GL_DEPTH_STENCIL);
 }
 
 TEST_F(TextureFormatTypeValidationTest, ES2WithRGWithFloat) {
   SetupFeatureInfo(
       "GL_EXT_texture_rg GL_OES_texture_float GL_OES_texture_half_float",
-      "OpenGL ES 2.0",
-      false);
+      "OpenGL ES 2.0", CONTEXT_TYPE_OPENGLES2);
 
   ExpectValid(true, GL_RED_EXT, GL_HALF_FLOAT_OES, GL_RED_EXT);
   ExpectValid(true, GL_RG_EXT, GL_HALF_FLOAT_OES, GL_RG_EXT);
   ExpectValid(true, GL_RED_EXT, GL_UNSIGNED_BYTE, GL_RED_EXT);
   ExpectValid(true, GL_RG_EXT, GL_UNSIGNED_BYTE, GL_RG_EXT);
 
   ExpectInvalidEnum(true, GL_RED_EXT, GL_BYTE, GL_RED_EXT);
   ExpectInvalidEnum(true, GL_RG_EXT, GL_BYTE, GL_RG_EXT);
   ExpectInvalidEnum(true, GL_RED_EXT, GL_SHORT, GL_RED_EXT);
   ExpectInvalidEnum(true, GL_RG_EXT, GL_SHORT, GL_RG_EXT);
 }
 
 TEST_F(TextureFormatTypeValidationTest, ES2WithRGNoFloat) {
-  SetupFeatureInfo("GL_ARB_texture_rg", "OpenGL ES 2.0", false);
+  SetupFeatureInfo("GL_ARB_texture_rg", "OpenGL ES 2.0",
+                   CONTEXT_TYPE_OPENGLES2);
 
   ExpectValid(true, GL_RED_EXT, GL_UNSIGNED_BYTE, GL_RED_EXT);
   ExpectValid(true, GL_RG_EXT, GL_UNSIGNED_BYTE, GL_RG_EXT);
 
   ExpectInvalidEnum(true, GL_RED_EXT, GL_HALF_FLOAT_OES, GL_RED_EXT);
   ExpectInvalidEnum(true, GL_RG_EXT, GL_HALF_FLOAT_OES, GL_RG_EXT);
 }
 
 TEST_F(TextureFormatTypeValidationTest, ES2OnTopOfES3) {
-  SetupFeatureInfo("", "OpenGL ES 3.0", false);
+  SetupFeatureInfo("", "OpenGL ES 3.0", CONTEXT_TYPE_OPENGLES2);
 
   ExpectInvalidEnum(true, GL_RGB, GL_FLOAT, GL_RGB);
   ExpectInvalidEnum(true, GL_RGBA, GL_FLOAT, GL_RGBA);
   ExpectInvalidEnum(true, GL_LUMINANCE, GL_FLOAT, GL_LUMINANCE);
   ExpectInvalidEnum(true, GL_LUMINANCE_ALPHA, GL_FLOAT, GL_LUMINANCE_ALPHA);
   ExpectInvalidEnum(true, GL_ALPHA, GL_FLOAT, GL_ALPHA);
 
   ExpectInvalidEnum(true, GL_SRGB_EXT, GL_UNSIGNED_BYTE, GL_SRGB_EXT);
   ExpectInvalidEnum(
       true, GL_SRGB_ALPHA_EXT, GL_UNSIGNED_BYTE, GL_SRGB_ALPHA_EXT);
 }
 
 TEST_F(TextureFormatTypeValidationTest, ES2WithOesTextureFloat) {
-  SetupFeatureInfo("GL_OES_texture_float", "OpenGL ES 2.0", false);
+  SetupFeatureInfo("GL_OES_texture_float", "OpenGL ES 2.0",
+                   CONTEXT_TYPE_OPENGLES2);
 
   ExpectValid(true, GL_RGB, GL_FLOAT, GL_RGB);
   ExpectValid(true, GL_RGBA, GL_FLOAT, GL_RGBA);
   ExpectValid(true, GL_LUMINANCE, GL_FLOAT, GL_LUMINANCE);
   ExpectValid(true, GL_LUMINANCE_ALPHA, GL_FLOAT, GL_LUMINANCE_ALPHA);
   ExpectValid(true, GL_ALPHA, GL_FLOAT, GL_ALPHA);
 
   ExpectInvalidEnum(true, GL_RGB, GL_HALF_FLOAT_OES, GL_RGB);
   ExpectInvalidEnum(true, GL_RGBA, GL_HALF_FLOAT_OES, GL_RGBA);
   ExpectInvalidEnum(true, GL_LUMINANCE, GL_HALF_FLOAT_OES, GL_LUMINANCE);
   ExpectInvalidEnum(
       true, GL_LUMINANCE_ALPHA, GL_HALF_FLOAT_OES, GL_LUMINANCE_ALPHA);
   ExpectInvalidEnum(true, GL_ALPHA, GL_HALF_FLOAT_OES, GL_ALPHA);
 }
 
 TEST_F(TextureFormatTypeValidationTest, ES2WithOesTextureFloatLinear) {
-  SetupFeatureInfo(
-      "GL_OES_texture_float GL_OES_texture_float_linear",
-      "OpenGL ES 2.0",
-      false);
+  SetupFeatureInfo("GL_OES_texture_float GL_OES_texture_float_linear",
+                   "OpenGL ES 2.0", CONTEXT_TYPE_OPENGLES2);
 
   ExpectValid(true, GL_RGB, GL_FLOAT, GL_RGB);
   ExpectValid(true, GL_RGBA, GL_FLOAT, GL_RGBA);
   ExpectValid(true, GL_LUMINANCE, GL_FLOAT, GL_LUMINANCE);
   ExpectValid(true, GL_LUMINANCE_ALPHA, GL_FLOAT, GL_LUMINANCE_ALPHA);
   ExpectValid(true, GL_ALPHA, GL_FLOAT, GL_ALPHA);
 
   ExpectInvalidEnum(true, GL_RGB, GL_HALF_FLOAT_OES, GL_RGB);
   ExpectInvalidEnum(true, GL_RGBA, GL_HALF_FLOAT_OES, GL_RGBA);
   ExpectInvalidEnum(true, GL_LUMINANCE, GL_HALF_FLOAT_OES, GL_LUMINANCE);
   ExpectInvalidEnum(
       true, GL_LUMINANCE_ALPHA, GL_HALF_FLOAT_OES, GL_LUMINANCE_ALPHA);
   ExpectInvalidEnum(true, GL_ALPHA, GL_HALF_FLOAT_OES, GL_ALPHA);
 }
 
 TEST_F(TextureFormatTypeValidationTest, ES2WithOesTextureHalfFloat) {
-  SetupFeatureInfo("GL_OES_texture_half_float", "OpenGL ES 2.0", false);
+  SetupFeatureInfo("GL_OES_texture_half_float", "OpenGL ES 2.0",
+                   CONTEXT_TYPE_OPENGLES2);
 
   ExpectValid(true, GL_RGB, GL_HALF_FLOAT_OES, GL_RGB);
   ExpectValid(true, GL_RGBA, GL_HALF_FLOAT_OES, GL_RGBA);
   ExpectValid(true, GL_LUMINANCE, GL_HALF_FLOAT_OES, GL_LUMINANCE);
   ExpectValid(true, GL_LUMINANCE_ALPHA, GL_HALF_FLOAT_OES, GL_LUMINANCE_ALPHA);
   ExpectValid(true, GL_ALPHA, GL_HALF_FLOAT_OES, GL_ALPHA);
 
   ExpectInvalidEnum(true, GL_RGB, GL_FLOAT, GL_RGB);
   ExpectInvalidEnum(true, GL_RGBA, GL_FLOAT, GL_RGBA);
   ExpectInvalidEnum(true, GL_LUMINANCE, GL_FLOAT, GL_LUMINANCE);
   ExpectInvalidEnum(true, GL_LUMINANCE_ALPHA, GL_FLOAT, GL_LUMINANCE_ALPHA);
   ExpectInvalidEnum(true, GL_ALPHA, GL_FLOAT, GL_ALPHA);
 }
 
 TEST_F(TextureFormatTypeValidationTest, ES2WithOesTextureHalfFloatLinear) {
-  SetupFeatureInfo(
-      "GL_OES_texture_half_float GL_OES_texture_half_float_linear",
-      "OpenGL ES 2.0",
-      false);
+  SetupFeatureInfo("GL_OES_texture_half_float GL_OES_texture_half_float_linear",
+                   "OpenGL ES 2.0", CONTEXT_TYPE_OPENGLES2);
 
   ExpectValid(true, GL_RGB, GL_HALF_FLOAT_OES, GL_RGB);
   ExpectValid(true, GL_RGBA, GL_HALF_FLOAT_OES, GL_RGBA);
   ExpectValid(true, GL_LUMINANCE, GL_HALF_FLOAT_OES, GL_LUMINANCE);
   ExpectValid(true, GL_LUMINANCE_ALPHA, GL_HALF_FLOAT_OES, GL_LUMINANCE_ALPHA);
   ExpectValid(true, GL_ALPHA, GL_HALF_FLOAT_OES, GL_ALPHA);
 
   ExpectInvalidEnum(true, GL_RGB, GL_FLOAT, GL_RGB);
   ExpectInvalidEnum(true, GL_RGBA, GL_FLOAT, GL_RGBA);
   ExpectInvalidEnum(true, GL_LUMINANCE, GL_FLOAT, GL_LUMINANCE);
   ExpectInvalidEnum(true, GL_LUMINANCE_ALPHA, GL_FLOAT, GL_LUMINANCE_ALPHA);
   ExpectInvalidEnum(true, GL_ALPHA, GL_FLOAT, GL_ALPHA);
 }
 
 TEST_F(TextureFormatTypeValidationTest, ES3Basic) {
-  SetupFeatureInfo("", "OpenGL ES 3.0", true);
+  SetupFeatureInfo("", "OpenGL ES 3.0", CONTEXT_TYPE_OPENGLES3);
 
   ExpectValid(true, GL_ALPHA, GL_UNSIGNED_BYTE, GL_ALPHA);
   ExpectValid(true, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, GL_RGB);
   ExpectValid(true, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4, GL_RGBA);
   ExpectValid(true, GL_LUMINANCE, GL_UNSIGNED_BYTE, GL_LUMINANCE);
   ExpectValid(true, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, GL_LUMINANCE_ALPHA);
 
   ExpectValid(true, GL_RG, GL_BYTE, GL_RG8_SNORM);
   ExpectValid(true, GL_RG_INTEGER, GL_UNSIGNED_INT, GL_RG32UI);
   ExpectValid(true, GL_RG_INTEGER, GL_SHORT, GL_RG16I);
   ExpectValid(true, GL_RGB, GL_UNSIGNED_BYTE, GL_SRGB8);
   ExpectValid(true, GL_RGBA, GL_HALF_FLOAT, GL_RGBA16F);
   ExpectValid(true, GL_RGBA, GL_FLOAT, GL_RGBA16F);
   ExpectValid(true, GL_RGBA, GL_FLOAT, GL_RGBA32F);
 
   ExpectValid(
       true, GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT, GL_DEPTH_COMPONENT16);
   ExpectValid(true, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, GL_DEPTH_COMPONENT24);
   ExpectValid(true, GL_DEPTH_COMPONENT, GL_FLOAT, GL_DEPTH_COMPONENT32F);
   ExpectValid(
       true, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, GL_DEPTH24_STENCIL8);
   ExpectValid(true, GL_DEPTH_STENCIL, GL_FLOAT_32_UNSIGNED_INT_24_8_REV,
               GL_DEPTH32F_STENCIL8);
 
   ExpectInvalid(true, GL_RGB_INTEGER, GL_INT, GL_RGBA8);
 }
 
 }  // namespace gles2
 }  // namespace gpu