Only allow TexStorage2DEXT if we expose the extension

gpu/command_buffer/service/feature_info_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/feature_info.h"
 
 #include <stddef.h>
 
 #include <memory>
 
@@ skipping 24 matching lines @@
 using ::testing::StrEq;
 
 namespace gpu {
 namespace gles2 {
 
 namespace {
 const char kGLRendererStringANGLE[] = "ANGLE (some renderer)";
 }  // anonymous namespace
 
 enum MockedGLVersionKind {
-  Version3_0,
-  Version3_2Compatibility
+  ES2_on_Version3_0,
+  ES2_on_Version3_2Compatibility,
+  ES3_on_Version3_0,
+  ES3_on_Version3_2Compatibility
 };
 
 class FeatureInfoTest
     : public GpuServiceTest,
       public ::testing::WithParamInterface<MockedGLVersionKind> {
  public:
   FeatureInfoTest() {
   }
 
   void SetupInitExpectations(const char* extensions) {
     std::string extensions_str = extensions;
     // Most of the tests' expectations currently assume the desktop
     // OpenGL compatibility profile.
     switch (GetParam()) {
-      case Version3_0:
+      case ES2_on_Version3_0:
+      case ES3_on_Version3_0:
         SetupInitExpectationsWithGLVersion(extensions_str.c_str(), "", "3.0");
         break;
-      case Version3_2Compatibility:
+      case ES2_on_Version3_2Compatibility:
+      case ES3_on_Version3_2Compatibility:
         if (extensions_str.find("GL_ARB_compatibility") == std::string::npos) {
           extensions_str += " GL_ARB_compatibility";
         }
         SetupInitExpectationsWithGLVersion(extensions_str.c_str(), "", "3.2");
         break;
       default:
         NOTREACHED();
         break;
     }
   }
 
+  ContextType GetContextType() {
+    switch (GetParam()) {
+      case ES2_on_Version3_0:
+      case ES2_on_Version3_2Compatibility:
+        return CONTEXT_TYPE_OPENGLES2;
+      case ES3_on_Version3_0:
+      case ES3_on_Version3_2Compatibility:
+        return CONTEXT_TYPE_OPENGLES3;
+      default:
+        NOTREACHED();
+        return CONTEXT_TYPE_OPENGLES2;
+    }
+  }
+
   void SetupInitExpectationsWithGLVersion(
       const char* extensions, const char* renderer, const char* version) {
     GpuServiceTest::SetUpWithGLVersion(version, extensions);
     TestHelper::SetupFeatureInfoInitExpectationsWithGLVersion(
         gl_.get(), extensions, renderer, version);
     info_ = new FeatureInfo();
-    info_->InitializeForTesting();
+    info_->Initialize(GetContextType(), DisallowedFeatures());
   }
 
   void SetupInitExpectationsWithGLVersionAndDisallowedFeatures(
       const char* extensions,
       const char* renderer,
       const char* version,
       const DisallowedFeatures& disallowed_features) {
     GpuServiceTest::SetUpWithGLVersion(version, extensions);
     TestHelper::SetupFeatureInfoInitExpectationsWithGLVersion(
         gl_.get(), extensions, renderer, version);
     info_ = new FeatureInfo();
-    info_->InitializeForTesting(disallowed_features);
+    info_->Initialize(GetContextType(), disallowed_features);
   }
 
   void SetupInitExpectationsWithGLVersionAndCommandLine(
       const char* extensions,
       const char* renderer,
       const char* version,
       const base::CommandLine& command_line) {
     GpuServiceTest::SetUpWithGLVersion(version, extensions);
     TestHelper::SetupFeatureInfoInitExpectationsWithGLVersion(
         gl_.get(), extensions, renderer, version);
     GpuDriverBugWorkarounds gpu_driver_bug_workaround(&command_line);
     info_ = new FeatureInfo(command_line, gpu_driver_bug_workaround);
-    info_->InitializeForTesting();
+    info_->Initialize(GetContextType(), DisallowedFeatures());
   }
 
   void SetupWithCommandLine(const base::CommandLine& command_line) {
     GpuServiceTest::SetUp();
     GpuDriverBugWorkarounds gpu_driver_bug_workaround(&command_line);
     info_ = new FeatureInfo(command_line, gpu_driver_bug_workaround);
   }
 
   void SetupInitExpectationsWithCommandLine(
       const char* extensions,
       const base::CommandLine& command_line) {
     GpuServiceTest::SetUpWithGLVersion("2.0", extensions);
     TestHelper::SetupFeatureInfoInitExpectationsWithGLVersion(
         gl_.get(), extensions, "", "");
     GpuDriverBugWorkarounds gpu_driver_bug_workaround(&command_line);
     info_ = new FeatureInfo(command_line, gpu_driver_bug_workaround);
-    info_->InitializeForTesting();
+    info_->Initialize(GetContextType(), DisallowedFeatures());
   }
 
   void SetupWithoutInit() {
     GpuServiceTest::SetUp();
     info_ = new FeatureInfo();
   }
 
  protected:
   void SetUp() override {
     // Do nothing here, since we are using the explicit Setup*() functions.
@@ skipping 11 matching lines @@
 
 struct FormatInfo {
    GLenum format;
    const GLenum* types;
    size_t count;
 };
 
 }  // anonymous namespace.
 
 static const MockedGLVersionKind kGLVersionKinds[] = {
-  Version3_0,
-  Version3_2Compatibility
+  ES2_on_Version3_0,
+  ES2_on_Version3_2Compatibility,
+  ES3_on_Version3_0,
+  ES3_on_Version3_2Compatibility
 };
 
 INSTANTIATE_TEST_CASE_P(Service,
                         FeatureInfoTest,
                         ::testing::ValuesIn(kGLVersionKinds));
 
 TEST_P(FeatureInfoTest, Basic) {
   SetupWithoutInit();
   // Test it starts off uninitialized.
   EXPECT_FALSE(info_->feature_flags().chromium_framebuffer_multisample);
@@ skipping 283 matching lines @@
 
 TEST_P(FeatureInfoTest, InitializeGLES_no_EXT_read_format_bgra) {
   SetupInitExpectationsWithGLVersion("", "", "OpenGL ES 2.0");
   EXPECT_THAT(info_->extensions(), Not(HasSubstr("GL_EXT_read_format_bgra")));
   EXPECT_FALSE(info_->feature_flags().ext_read_format_bgra);
   EXPECT_FALSE(info_->validators()->read_pixel_format.IsValid(GL_BGRA_EXT));
 }
 
 TEST_P(FeatureInfoTest, InitializeEXT_sRGB) {
   SetupInitExpectations("GL_EXT_sRGB GL_OES_rgb8_rgba8");
-  EXPECT_THAT(info_->extensions(),
-              HasSubstr("GL_EXT_sRGB"));
-  EXPECT_TRUE(info_->validators()->texture_format.IsValid(
-      GL_SRGB_EXT));
-  EXPECT_TRUE(info_->validators()->texture_format.IsValid(
-      GL_SRGB_ALPHA_EXT));
-  EXPECT_TRUE(info_->validators()->texture_internal_format.IsValid(
-      GL_SRGB_EXT));
-  EXPECT_TRUE(info_->validators()->texture_internal_format.IsValid(
-      GL_SRGB_ALPHA_EXT));
-  EXPECT_TRUE(info_->validators()->render_buffer_format.IsValid(
-      GL_SRGB8_ALPHA8_EXT));
-  EXPECT_TRUE(info_->validators()->frame_buffer_parameter.IsValid(
-      GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT));
+
+  if (GetContextType() == CONTEXT_TYPE_OPENGLES3) {
+    EXPECT_THAT(info_->extensions(), Not(HasSubstr("GL_EXT_sRGB")));
+    EXPECT_FALSE(info_->validators()->texture_format.IsValid(GL_SRGB_EXT));
+    EXPECT_FALSE(
+        info_->validators()->texture_format.IsValid(GL_SRGB_ALPHA_EXT));
+    EXPECT_FALSE(
+        info_->validators()->texture_internal_format.IsValid(GL_SRGB_EXT));
+    EXPECT_FALSE(info_->validators()->texture_internal_format.IsValid(
+        GL_SRGB_ALPHA_EXT));
+    EXPECT_FALSE(
+        info_->validators()->render_buffer_format.IsValid(GL_SRGB8_ALPHA8_EXT));
+    EXPECT_FALSE(info_->validators()->frame_buffer_parameter.IsValid(
+        GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT));
+  } else {
+    EXPECT_THAT(info_->extensions(), HasSubstr("GL_EXT_sRGB"));
+    EXPECT_TRUE(info_->validators()->texture_format.IsValid(GL_SRGB_EXT));
+    EXPECT_TRUE(info_->validators()->texture_format.IsValid(GL_SRGB_ALPHA_EXT));
+    EXPECT_TRUE(
+        info_->validators()->texture_internal_format.IsValid(GL_SRGB_EXT));
+    EXPECT_TRUE(info_->validators()->texture_internal_format.IsValid(
+        GL_SRGB_ALPHA_EXT));
+    EXPECT_TRUE(
+        info_->validators()->render_buffer_format.IsValid(GL_SRGB8_ALPHA8_EXT));
+    EXPECT_TRUE(info_->validators()->frame_buffer_parameter.IsValid(
+        GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT));
+  }
 }
 
 TEST_P(FeatureInfoTest, InitializeGLES2EXT_texture_storage) {
   SetupInitExpectationsWithGLVersion(
       "GL_EXT_texture_storage", "", "OpenGL ES 2.0");
   EXPECT_TRUE(info_->feature_flags().ext_texture_storage);
   EXPECT_THAT(info_->extensions(), HasSubstr("GL_EXT_texture_storage"));
   EXPECT_TRUE(info_->validators()->texture_parameter.IsValid(
       GL_TEXTURE_IMMUTABLE_FORMAT_EXT));
   EXPECT_FALSE(info_->validators()->texture_internal_format_storage.IsValid(
@@ skipping 166 matching lines @@
 
 // 4- ES2 (neither GL_EXT_texture_storage nor GL_EXT_texture_format_BGRA8888) ->
 // nothing
 TEST_P(FeatureInfoTest, InitializeGLES2_neither_texture_storage_nor_BGRA) {
   SetupInitExpectationsWithGLVersion("", "", "OpenGL ES 2.0");
   EXPECT_THAT(info_->extensions(), Not(HasSubstr("GL_EXT_texture_storage")));
   EXPECT_THAT(info_->extensions(),
               Not(HasSubstr("GL_EXT_texture_format_BGRA8888")));
 }
 
-// 5- ES3 + GL_EXT_texture_format_BGRA8888 -> GL_EXT_texture_format_BGRA8888
-// (we can't expose GL_EXT_texture_storage because we fail the GL_BGRA8
+// 5- ES3 + GL_EXT_texture_format_BGRA8888
+// If creating a GLES2 context, expose GL_EXT_texture_format_BGRA8888
+// If creating a GLES3 context, expose GL_EXT_texture_storage
+// (we can't expose both at the same time because we fail the GL_BGRA8
 // requirement)
 TEST_P(FeatureInfoTest, InitializeGLES3_texture_storage_EXT_BGRA) {
   SetupInitExpectationsWithGLVersion(
       "GL_EXT_texture_format_BGRA8888", "", "OpenGL ES 3.0");
-  EXPECT_THAT(info_->extensions(), Not(HasSubstr("GL_EXT_texture_storage")));
-  EXPECT_THAT(info_->extensions(), HasSubstr("GL_EXT_texture_format_BGRA8888"));
+  if (GetContextType() == CONTEXT_TYPE_OPENGLES3) {
+    EXPECT_THAT(info_->extensions(), HasSubstr("GL_EXT_texture_storage"));
+    EXPECT_THAT(info_->extensions(),
+                Not(HasSubstr("GL_EXT_texture_format_BGRA8888")));
+  } else {
+    EXPECT_THAT(info_->extensions(), Not(HasSubstr("GL_EXT_texture_storage")));
+    EXPECT_THAT(info_->extensions(),
+                HasSubstr("GL_EXT_texture_format_BGRA8888"));
+  }
 }
 
 // 6- ES3 + GL_APPLE_texture_format_bgra8888 -> GL_EXT_texture_storage +
 // GL_EXT_texture_format_BGRA8888 (driver promises to handle GL_BGRA8 by
 // exposing GL_APPLE_texture_format_bgra8888)
 TEST_P(FeatureInfoTest, InitializeGLES3_texture_storage_APPLE_BGRA) {
   SetupInitExpectationsWithGLVersion(
       "GL_APPLE_texture_format_BGRA8888", "", "OpenGL ES 3.0");
   EXPECT_THAT(info_->extensions(), HasSubstr("GL_EXT_texture_storage"));
   EXPECT_THAT(info_->extensions(), HasSubstr("GL_EXT_texture_format_BGRA8888"));
@@ skipping 770 matching lines @@
   EXPECT_TRUE(info_->validators()->render_buffer_format.IsValid(GL_RG8_EXT));
 }
 
 TEST_P(FeatureInfoTest, InitializeCHROMIUM_ycbcr_422_imageTrue) {
   SetupInitExpectations("GL_APPLE_ycbcr_422");
   EXPECT_TRUE(info_->feature_flags().chromium_image_ycbcr_422);
 }
 
 }  // namespace gles2
 }  // namespace gpu