gpu/command_buffer/service/feature_info_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "gpu/command_buffer/service/feature_info.h"
   6
   7 #include "base/command_line.h"
   8 #include "base/memory/scoped_ptr.h"
   9 #include "base/strings/string_number_conversions.h"
  10 #include "gpu/command_buffer/service/gpu_service_test.h"
  11 #include "gpu/command_buffer/service/test_helper.h"
  12 #include "gpu/command_buffer/service/texture_manager.h"
  13 #include "gpu/config/gpu_driver_bug_workaround_type.h"
  14 #include "gpu/config/gpu_switches.h"
  15 #include "testing/gtest/include/gtest/gtest.h"
  16 #include "ui/gl/gl_fence.h"
  17 #include "ui/gl/gl_implementation.h"
  18 #include "ui/gl/gl_mock.h"
  19
  20 using ::testing::_;
  21 using ::testing::DoAll;
  22 using ::testing::HasSubstr;
  23 using ::testing::InSequence;
  24 using ::testing::MatcherCast;
  25 using ::testing::Not;
  26 using ::testing::Pointee;
  27 using ::testing::Return;
  28 using ::testing::SetArrayArgument;
  29 using ::testing::SetArgumentPointee;
  30 using ::testing::StrEq;
  31
  32 namespace gpu {
  33 namespace gles2 {
  34
  35 namespace {
  36 const char kGLRendererStringANGLE[] = "ANGLE (some renderer)";
  37 }  // anonymous namespace
  38
  39 enum MockedGLVersionKind {
  40   Version3_0,
  41   Version3_2Compatibility
  42 };
  43
  44 class FeatureInfoTest
  45     : public GpuServiceTest,
  46       public ::testing::WithParamInterface<MockedGLVersionKind> {
  47  public:
  48   FeatureInfoTest() {
  49   }
  50
  51   void SetupInitExpectations(const char* extensions) {
  52     std::string extensions_str = extensions;
  53     // Most of the tests' expectations currently assume the desktop
  54     // OpenGL compatibility profile.
  55     switch (GetParam()) {
  56       case Version3_0:
  57         SetupInitExpectationsWithGLVersion(extensions_str.c_str(), "", "3.0");
  58         break;
  59       case Version3_2Compatibility:
  60         if (extensions_str.find("GL_ARB_compatibility") == std::string::npos) {
  61           extensions_str += " GL_ARB_compatibility";
  62         }
  63         SetupInitExpectationsWithGLVersion(extensions_str.c_str(), "", "3.2");
  64         break;
  65       default:
  66         NOTREACHED();
  67         break;
  68     }
  69   }
  70
  71   void SetupInitExpectationsWithGLVersion(
  72       const char* extensions, const char* renderer, const char* version) {
  73     GpuServiceTest::SetUpWithGLVersion(version, extensions);
  74     TestHelper::SetupFeatureInfoInitExpectationsWithGLVersion(
  75         gl_.get(), extensions, renderer, version);
  76     info_ = new FeatureInfo();
  77     info_->Initialize();
  78   }
  79
  80   void SetupWithCommandLine(const base::CommandLine& command_line) {
  81     GpuServiceTest::SetUp();
  82     info_ = new FeatureInfo(command_line);
  83   }
  84
  85   void SetupInitExpectationsWithCommandLine(
  86       const char* extensions,
  87       const base::CommandLine& command_line) {
  88     GpuServiceTest::SetUpWithGLVersion("2.0", extensions);
  89     TestHelper::SetupFeatureInfoInitExpectationsWithGLVersion(
  90         gl_.get(), extensions, "", "");
  91     info_ = new FeatureInfo(command_line);
  92     info_->Initialize();
  93   }
  94
  95   void SetupWithoutInit() {
  96     GpuServiceTest::SetUp();
  97     info_ = new FeatureInfo();
  98   }
  99
 100  protected:
 101   void SetUp() override {
 102     // Do nothing here, since we are using the explicit Setup*() functions.
 103   }
 104
 105   void TearDown() override {
 106     info_ = NULL;
 107     GpuServiceTest::TearDown();
 108   }
 109
 110   scoped_refptr<FeatureInfo> info_;
 111 };
 112
 113 namespace {
 114
 115 struct FormatInfo {
 116    GLenum format;
 117    const GLenum* types;
 118    size_t count;
 119 };
 120
 121 }  // anonymous namespace.
 122
 123 static const MockedGLVersionKind kGLVersionKinds[] = {
 124   Version3_0,
 125   Version3_2Compatibility
 126 };
 127
 128 INSTANTIATE_TEST_CASE_P(Service,
 129                         FeatureInfoTest,
 130                         ::testing::ValuesIn(kGLVersionKinds));
 131
 132 TEST_P(FeatureInfoTest, Basic) {
 133   SetupWithoutInit();
 134   // Test it starts off uninitialized.
 135   EXPECT_FALSE(info_->feature_flags().chromium_framebuffer_multisample);
 136   EXPECT_FALSE(info_->feature_flags().use_core_framebuffer_multisample);
 137   EXPECT_FALSE(info_->feature_flags().multisampled_render_to_texture);
 138   EXPECT_FALSE(info_->feature_flags(
 139       ).use_img_for_multisampled_render_to_texture);
 140   EXPECT_FALSE(info_->feature_flags().oes_standard_derivatives);
 141   EXPECT_FALSE(info_->feature_flags().npot_ok);
 142   EXPECT_FALSE(info_->feature_flags().enable_texture_float_linear);
 143   EXPECT_FALSE(info_->feature_flags().enable_texture_half_float_linear);
 144   EXPECT_FALSE(info_->feature_flags().oes_egl_image_external);
 145   EXPECT_FALSE(info_->feature_flags().oes_depth24);
 146   EXPECT_FALSE(info_->feature_flags().packed_depth24_stencil8);
 147   EXPECT_FALSE(info_->feature_flags().angle_translated_shader_source);
 148   EXPECT_FALSE(info_->feature_flags().angle_pack_reverse_row_order);
 149   EXPECT_FALSE(info_->feature_flags().arb_texture_rectangle);
 150   EXPECT_FALSE(info_->feature_flags().angle_instanced_arrays);
 151   EXPECT_FALSE(info_->feature_flags().occlusion_query_boolean);
 152   EXPECT_FALSE(info_->feature_flags(
 153       ).use_arb_occlusion_query2_for_occlusion_query_boolean);
 154   EXPECT_FALSE(info_->feature_flags(
 155       ).use_arb_occlusion_query_for_occlusion_query_boolean);
 156   EXPECT_FALSE(info_->feature_flags().native_vertex_array_object);
 157   EXPECT_FALSE(info_->feature_flags().map_buffer_range);
 158   EXPECT_FALSE(info_->feature_flags().use_async_readpixels);
 159   EXPECT_FALSE(info_->feature_flags().ext_draw_buffers);
 160   EXPECT_FALSE(info_->feature_flags().nv_draw_buffers);
 161   EXPECT_FALSE(info_->feature_flags().ext_discard_framebuffer);
 162   EXPECT_FALSE(info_->feature_flags().angle_depth_texture);
 163
 164 #define GPU_OP(type, name) EXPECT_FALSE(info_->workarounds().name);
 165   GPU_DRIVER_BUG_WORKAROUNDS(GPU_OP)
 166 #undef GPU_OP
 167   EXPECT_EQ(0, info_->workarounds().max_texture_size);
 168   EXPECT_EQ(0, info_->workarounds().max_cube_map_texture_size);
 169   EXPECT_FALSE(info_->workarounds().gl_clear_broken);
 170
 171   // Test good types.
 172   {
 173     static const GLenum kAlphaTypes[] = {
 174         GL_UNSIGNED_BYTE,
 175     };
 176     static const GLenum kRGBTypes[] = {
 177         GL_UNSIGNED_BYTE,
 178         GL_UNSIGNED_SHORT_5_6_5,
 179     };
 180     static const GLenum kRGBATypes[] = {
 181         GL_UNSIGNED_BYTE,
 182         GL_UNSIGNED_SHORT_4_4_4_4,
 183         GL_UNSIGNED_SHORT_5_5_5_1,
 184     };
 185     static const GLenum kLuminanceTypes[] = {
 186         GL_UNSIGNED_BYTE,
 187     };
 188     static const GLenum kLuminanceAlphaTypes[] = {
 189         GL_UNSIGNED_BYTE,
 190     };
 191     static const FormatInfo kFormatTypes[] = {
 192       { GL_ALPHA, kAlphaTypes, arraysize(kAlphaTypes), },
 193       { GL_RGB, kRGBTypes, arraysize(kRGBTypes), },
 194       { GL_RGBA, kRGBATypes, arraysize(kRGBATypes), },
 195       { GL_LUMINANCE, kLuminanceTypes, arraysize(kLuminanceTypes), },
 196       { GL_LUMINANCE_ALPHA, kLuminanceAlphaTypes,
 197         arraysize(kLuminanceAlphaTypes), } ,
 198     };
 199     for (size_t ii = 0; ii < arraysize(kFormatTypes); ++ii) {
 200       const FormatInfo& info = kFormatTypes[ii];
 201       const ValueValidator<GLenum>& validator =
 202           info_->GetTextureFormatValidator(info.format);
 203       for (size_t jj = 0; jj < info.count; ++jj) {
 204         EXPECT_TRUE(validator.IsValid(info.types[jj]));
 205       }
 206     }
 207   }
 208
 209   // Test some bad types
 210   {
 211     static const GLenum kAlphaTypes[] = {
 212         GL_UNSIGNED_SHORT_5_5_5_1,
 213         GL_FLOAT,
 214     };
 215     static const GLenum kRGBTypes[] = {
 216         GL_UNSIGNED_SHORT_4_4_4_4,
 217         GL_FLOAT,
 218     };
 219     static const GLenum kRGBATypes[] = {
 220         GL_UNSIGNED_SHORT_5_6_5,
 221         GL_FLOAT,
 222     };
 223     static const GLenum kLuminanceTypes[] = {
 224         GL_UNSIGNED_SHORT_4_4_4_4,
 225         GL_FLOAT,
 226     };
 227     static const GLenum kLuminanceAlphaTypes[] = {
 228         GL_UNSIGNED_SHORT_5_5_5_1,
 229         GL_FLOAT,
 230     };
 231     static const GLenum kBGRATypes[] = {
 232         GL_UNSIGNED_BYTE,
 233         GL_UNSIGNED_SHORT_5_6_5,
 234         GL_FLOAT,
 235     };
 236     static const GLenum kDepthTypes[] = {
 237         GL_UNSIGNED_BYTE,
 238         GL_UNSIGNED_SHORT,
 239         GL_UNSIGNED_INT,
 240         GL_FLOAT,
 241     };
 242     static const FormatInfo kFormatTypes[] = {
 243       { GL_ALPHA, kAlphaTypes, arraysize(kAlphaTypes), },
 244       { GL_RGB, kRGBTypes, arraysize(kRGBTypes), },
 245       { GL_RGBA, kRGBATypes, arraysize(kRGBATypes), },
 246       { GL_LUMINANCE, kLuminanceTypes, arraysize(kLuminanceTypes), },
 247       { GL_LUMINANCE_ALPHA, kLuminanceAlphaTypes,
 248         arraysize(kLuminanceAlphaTypes), } ,
 249       { GL_BGRA_EXT, kBGRATypes, arraysize(kBGRATypes), },
 250       { GL_DEPTH_COMPONENT, kDepthTypes, arraysize(kDepthTypes), },
 251     };
 252     for (size_t ii = 0; ii < arraysize(kFormatTypes); ++ii) {
 253       const FormatInfo& info = kFormatTypes[ii];
 254       const ValueValidator<GLenum>& validator =
 255           info_->GetTextureFormatValidator(info.format);
 256       for (size_t jj = 0; jj < info.count; ++jj) {
 257         EXPECT_FALSE(validator.IsValid(info.types[jj]));
 258       }
 259     }
 260   }
 261 }
 262
 263 TEST_P(FeatureInfoTest, InitializeNoExtensions) {
 264   SetupInitExpectations("");
 265   // Check default extensions are there
 266   EXPECT_THAT(info_->extensions(), HasSubstr("GL_CHROMIUM_resource_safe"));
 267   EXPECT_THAT(info_->extensions(), HasSubstr("GL_CHROMIUM_strict_attribs"));
 268   EXPECT_THAT(info_->extensions(),
 269               HasSubstr("GL_ANGLE_translated_shader_source"));
 270   EXPECT_THAT(info_->extensions(), HasSubstr("GL_CHROMIUM_trace_marker"));
 271
 272   // Check a couple of random extensions that should not be there.
 273   EXPECT_THAT(info_->extensions(), Not(HasSubstr("GL_OES_texture_npot")));
 274   EXPECT_THAT(info_->extensions(),
 275               Not(HasSubstr("GL_EXT_texture_compression_dxt1")));
 276   EXPECT_THAT(info_->extensions(),
 277               Not(HasSubstr("GL_CHROMIUM_texture_compression_dxt3")));
 278   EXPECT_THAT(info_->extensions(),
 279               Not(HasSubstr("GL_CHROMIUM_texture_compression_dxt5")));
 280   EXPECT_THAT(info_->extensions(),
 281               Not(HasSubstr("GL_ANGLE_texture_usage")));
 282   EXPECT_THAT(info_->extensions(),
 283               Not(HasSubstr("GL_EXT_texture_storage")));
 284   EXPECT_THAT(info_->extensions(),
 285               Not(HasSubstr("GL_OES_compressed_ETC1_RGB8_texture")));
 286   EXPECT_THAT(info_->extensions(),
 287               Not(HasSubstr("GL_AMD_compressed_ATC_texture")));
 288   EXPECT_THAT(info_->extensions(),
 289               Not(HasSubstr("GL_IMG_texture_compression_pvrtc")));
 290   EXPECT_THAT(info_->extensions(),
 291               Not(HasSubstr("GL_EXT_sRGB")));
 292   EXPECT_FALSE(info_->feature_flags().npot_ok);
 293   EXPECT_FALSE(info_->validators()->compressed_texture_format.IsValid(
 294       GL_COMPRESSED_RGB_S3TC_DXT1_EXT));
 295   EXPECT_FALSE(info_->validators()->compressed_texture_format.IsValid(
 296       GL_COMPRESSED_RGBA_S3TC_DXT1_EXT));
 297   EXPECT_FALSE(info_->validators()->compressed_texture_format.IsValid(
 298       GL_COMPRESSED_RGBA_S3TC_DXT3_EXT));
 299   EXPECT_FALSE(info_->validators()->compressed_texture_format.IsValid(
 300       GL_COMPRESSED_RGBA_S3TC_DXT5_EXT));
 301   EXPECT_FALSE(info_->validators()->compressed_texture_format.IsValid(
 302       GL_ETC1_RGB8_OES));
 303   EXPECT_FALSE(info_->validators()->compressed_texture_format.IsValid(
 304       GL_ATC_RGB_AMD));
 305   EXPECT_FALSE(info_->validators()->compressed_texture_format.IsValid(
 306       GL_ATC_RGBA_EXPLICIT_ALPHA_AMD));
 307   EXPECT_FALSE(info_->validators()->compressed_texture_format.IsValid(
 308       GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD));
 309   EXPECT_FALSE(info_->validators()->compressed_texture_format.IsValid(
 310       GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG));
 311   EXPECT_FALSE(info_->validators()->compressed_texture_format.IsValid(
 312       GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG));
 313   EXPECT_FALSE(info_->validators()->compressed_texture_format.IsValid(
 314       GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG));
 315   EXPECT_FALSE(info_->validators()->compressed_texture_format.IsValid(
 316       GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG));
 317   EXPECT_FALSE(info_->validators()->read_pixel_format.IsValid(
 318       GL_BGRA_EXT));
 319   EXPECT_FALSE(info_->validators()->texture_parameter.IsValid(
 320       GL_TEXTURE_MAX_ANISOTROPY_EXT));
 321   EXPECT_FALSE(info_->validators()->g_l_state.IsValid(
 322       GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT));
 323   EXPECT_FALSE(info_->validators()->frame_buffer_target.IsValid(
 324       GL_READ_FRAMEBUFFER_EXT));
 325   EXPECT_FALSE(info_->validators()->frame_buffer_target.IsValid(
 326       GL_DRAW_FRAMEBUFFER_EXT));
 327   EXPECT_FALSE(info_->validators()->g_l_state.IsValid(
 328       GL_READ_FRAMEBUFFER_BINDING_EXT));
 329   EXPECT_FALSE(info_->validators()->render_buffer_parameter.IsValid(
 330       GL_MAX_SAMPLES_EXT));
 331   EXPECT_FALSE(info_->validators()->texture_internal_format.IsValid(
 332       GL_DEPTH_COMPONENT));
 333   EXPECT_FALSE(info_->validators()->texture_format.IsValid(GL_DEPTH_COMPONENT));
 334   EXPECT_FALSE(info_->validators()->pixel_type.IsValid(GL_UNSIGNED_SHORT));
 335   EXPECT_FALSE(info_->validators()->pixel_type.IsValid(GL_UNSIGNED_INT));
 336   EXPECT_FALSE(info_->validators()->render_buffer_format.IsValid(
 337       GL_DEPTH24_STENCIL8));
 338   EXPECT_FALSE(info_->validators()->texture_internal_format.IsValid(
 339       GL_DEPTH_STENCIL));
 340   EXPECT_FALSE(info_->validators()->texture_internal_format.IsValid(
 341       GL_RGBA32F));
 342   EXPECT_FALSE(info_->validators()->texture_internal_format.IsValid(
 343       GL_RGB32F));
 344   EXPECT_FALSE(info_->validators()->texture_format.IsValid(
 345       GL_DEPTH_STENCIL));
 346   EXPECT_FALSE(info_->validators()->pixel_type.IsValid(
 347       GL_UNSIGNED_INT_24_8));
 348   EXPECT_FALSE(info_->validators()->render_buffer_format.IsValid(
 349       GL_DEPTH_COMPONENT24));
 350   EXPECT_FALSE(info_->validators()->texture_parameter.IsValid(
 351       GL_TEXTURE_USAGE_ANGLE));
 352   EXPECT_FALSE(info_->validators()->texture_internal_format_storage.IsValid(
 353       GL_DEPTH_COMPONENT16));
 354   EXPECT_FALSE(info_->validators()->texture_internal_format_storage.IsValid(
 355       GL_DEPTH_COMPONENT32_OES));
 356   EXPECT_FALSE(info_->validators()->texture_internal_format_storage.IsValid(
 357       GL_DEPTH24_STENCIL8_OES));
 358   EXPECT_FALSE(info_->validators()->equation.IsValid(GL_MIN_EXT));
 359   EXPECT_FALSE(info_->validators()->equation.IsValid(GL_MAX_EXT));
 360   EXPECT_FALSE(info_->feature_flags().chromium_sync_query);
 361   EXPECT_FALSE(info_->GetTextureFormatValidator(GL_SRGB_EXT).IsValid(
 362       GL_UNSIGNED_BYTE));
 363   EXPECT_FALSE(info_->GetTextureFormatValidator(GL_SRGB_ALPHA_EXT).IsValid(
 364       GL_UNSIGNED_BYTE));
 365   EXPECT_FALSE(info_->validators()->texture_format.IsValid(
 366       GL_SRGB_EXT));
 367   EXPECT_FALSE(info_->validators()->texture_format.IsValid(
 368       GL_SRGB_ALPHA_EXT));
 369   EXPECT_FALSE(info_->validators()->texture_internal_format.IsValid(
 370       GL_SRGB_EXT));
 371   EXPECT_FALSE(info_->validators()->texture_internal_format.IsValid(
 372       GL_SRGB_ALPHA_EXT));
 373   EXPECT_FALSE(info_->validators()->render_buffer_format.IsValid(
 374       GL_SRGB8_ALPHA8_EXT));
 375   EXPECT_FALSE(info_->validators()->frame_buffer_parameter.IsValid(
 376       GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT));
 377 }
 378
 379 TEST_P(FeatureInfoTest, InitializeWithANGLE) {
 380   SetupInitExpectationsWithGLVersion("", kGLRendererStringANGLE, "");
 381   EXPECT_TRUE(info_->gl_version_info().is_angle);
 382 }
 383
 384 TEST_P(FeatureInfoTest, InitializeNPOTExtensionGLES) {
 385   SetupInitExpectations("GL_OES_texture_npot");
 386   EXPECT_THAT(info_->extensions(), HasSubstr("GL_OES_texture_npot"));
 387   EXPECT_TRUE(info_->feature_flags().npot_ok);
 388 }
 389
 390 TEST_P(FeatureInfoTest, InitializeNPOTExtensionGL) {
 391   SetupInitExpectations("GL_ARB_texture_non_power_of_two");
 392   EXPECT_THAT(info_->extensions(), HasSubstr("GL_OES_texture_npot"));
 393   EXPECT_TRUE(info_->feature_flags().npot_ok);
 394 }
 395
 396 TEST_P(FeatureInfoTest, InitializeDXTExtensionGLES2) {
 397   SetupInitExpectations("GL_EXT_texture_compression_dxt1");
 398   EXPECT_THAT(info_->extensions(),
 399               HasSubstr("GL_EXT_texture_compression_dxt1"));
 400   EXPECT_TRUE(info_->validators()->compressed_texture_format.IsValid(
 401       GL_COMPRESSED_RGB_S3TC_DXT1_EXT));
 402   EXPECT_TRUE(info_->validators()->compressed_texture_format.IsValid(
 403       GL_COMPRESSED_RGBA_S3TC_DXT1_EXT));
 404   EXPECT_FALSE(info_->validators()->compressed_texture_format.IsValid(
 405       GL_COMPRESSED_RGBA_S3TC_DXT3_EXT));
 406   EXPECT_FALSE(info_->validators()->compressed_texture_format.IsValid(
 407       GL_COMPRESSED_RGBA_S3TC_DXT5_EXT));
 408 }
 409
 410 TEST_P(FeatureInfoTest, InitializeDXTExtensionGL) {
 411   SetupInitExpectations("GL_EXT_texture_compression_s3tc");
 412   EXPECT_THAT(info_->extensions(),
 413               HasSubstr("GL_EXT_texture_compression_dxt1"));
 414   EXPECT_THAT(info_->extensions(),
 415               HasSubstr("GL_CHROMIUM_texture_compression_dxt3"));
 416   EXPECT_THAT(info_->extensions(),
 417               HasSubstr("GL_CHROMIUM_texture_compression_dxt5"));
 418   EXPECT_TRUE(info_->validators()->compressed_texture_format.IsValid(
 419       GL_COMPRESSED_RGB_S3TC_DXT1_EXT));
 420   EXPECT_TRUE(info_->validators()->compressed_texture_format.IsValid(
 421       GL_COMPRESSED_RGBA_S3TC_DXT1_EXT));
 422   EXPECT_TRUE(info_->validators()->compressed_texture_format.IsValid(
 423       GL_COMPRESSED_RGBA_S3TC_DXT3_EXT));
 424   EXPECT_TRUE(info_->validators()->compressed_texture_format.IsValid(
 425       GL_COMPRESSED_RGBA_S3TC_DXT5_EXT));
 426 }
 427
 428 TEST_P(FeatureInfoTest, InitializeEXT_texture_format_BGRA8888GLES2) {
 429   SetupInitExpectations("GL_EXT_texture_format_BGRA8888");
 430   EXPECT_THAT(info_->extensions(),
 431               HasSubstr("GL_EXT_texture_format_BGRA8888"));
 432   EXPECT_TRUE(info_->validators()->texture_format.IsValid(
 433       GL_BGRA_EXT));
 434   EXPECT_TRUE(info_->validators()->texture_internal_format.IsValid(
 435       GL_BGRA_EXT));
 436   EXPECT_TRUE(info_->GetTextureFormatValidator(GL_BGRA_EXT).IsValid(
 437       GL_UNSIGNED_BYTE));
 438   EXPECT_FALSE(info_->validators()->render_buffer_format.IsValid(
 439       GL_BGRA8_EXT));
 440 }
 441
 442 TEST_P(FeatureInfoTest, InitializeEXT_texture_format_BGRA8888GL) {
 443   SetupInitExpectations("GL_EXT_bgra");
 444   EXPECT_THAT(info_->extensions(),
 445               HasSubstr("GL_EXT_texture_format_BGRA8888"));
 446   EXPECT_THAT(info_->extensions(),
 447               HasSubstr("GL_EXT_read_format_bgra"));
 448   EXPECT_THAT(info_->extensions(),
 449               HasSubstr("GL_CHROMIUM_renderbuffer_format_BGRA8888"));
 450   EXPECT_TRUE(info_->validators()->texture_format.IsValid(
 451       GL_BGRA_EXT));
 452   EXPECT_TRUE(info_->validators()->texture_internal_format.IsValid(
 453       GL_BGRA_EXT));
 454   EXPECT_TRUE(info_->validators()->read_pixel_format.IsValid(
 455       GL_BGRA_EXT));
 456   EXPECT_TRUE(info_->GetTextureFormatValidator(GL_BGRA_EXT).IsValid(
 457       GL_UNSIGNED_BYTE));
 458   EXPECT_TRUE(info_->validators()->render_buffer_format.IsValid(
 459       GL_BGRA8_EXT));
 460 }
 461
 462 TEST_P(FeatureInfoTest, InitializeEXT_texture_format_BGRA8888Apple) {
 463   SetupInitExpectations("GL_APPLE_texture_format_BGRA8888");
 464   EXPECT_THAT(info_->extensions(),
 465               HasSubstr("GL_EXT_texture_format_BGRA8888"));
 466   EXPECT_TRUE(info_->validators()->texture_format.IsValid(
 467       GL_BGRA_EXT));
 468   EXPECT_TRUE(info_->validators()->texture_internal_format.IsValid(
 469       GL_BGRA_EXT));
 470   EXPECT_TRUE(info_->GetTextureFormatValidator(GL_BGRA_EXT).IsValid(
 471       GL_UNSIGNED_BYTE));
 472   EXPECT_FALSE(info_->validators()->render_buffer_format.IsValid(
 473       GL_BGRA8_EXT));
 474 }
 475
 476 TEST_P(FeatureInfoTest, InitializeEXT_read_format_bgra) {
 477   SetupInitExpectations("GL_EXT_read_format_bgra");
 478   EXPECT_THAT(info_->extensions(),
 479               HasSubstr("GL_EXT_read_format_bgra"));
 480   EXPECT_FALSE(info_->validators()->texture_format.IsValid(
 481       GL_BGRA_EXT));
 482   EXPECT_FALSE(info_->validators()->texture_internal_format.IsValid(
 483       GL_BGRA_EXT));
 484   EXPECT_TRUE(info_->validators()->read_pixel_format.IsValid(
 485       GL_BGRA_EXT));
 486   EXPECT_FALSE(info_->validators()->render_buffer_format.IsValid(
 487       GL_BGRA8_EXT));
 488 }
 489
 490 TEST_P(FeatureInfoTest, InitializeEXT_sRGB) {
 491   SetupInitExpectations("GL_EXT_sRGB GL_OES_rgb8_rgba8");
 492   EXPECT_THAT(info_->extensions(),
 493               HasSubstr("GL_EXT_sRGB"));
 494   EXPECT_TRUE(info_->GetTextureFormatValidator(GL_SRGB_EXT).IsValid(
 495       GL_UNSIGNED_BYTE));
 496   EXPECT_TRUE(info_->GetTextureFormatValidator(GL_SRGB_ALPHA_EXT).IsValid(
 497       GL_UNSIGNED_BYTE));
 498   EXPECT_TRUE(info_->validators()->texture_format.IsValid(
 499       GL_SRGB_EXT));
 500   EXPECT_TRUE(info_->validators()->texture_format.IsValid(
 501       GL_SRGB_ALPHA_EXT));
 502   EXPECT_TRUE(info_->validators()->texture_internal_format.IsValid(
 503       GL_SRGB_EXT));
 504   EXPECT_TRUE(info_->validators()->texture_internal_format.IsValid(
 505       GL_SRGB_ALPHA_EXT));
 506   EXPECT_TRUE(info_->validators()->render_buffer_format.IsValid(
 507       GL_SRGB8_ALPHA8_EXT));
 508   EXPECT_TRUE(info_->validators()->frame_buffer_parameter.IsValid(
 509       GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT));
 510 }
 511
 512 TEST_P(FeatureInfoTest, InitializeEXT_texture_storage) {
 513   SetupInitExpectations("GL_EXT_texture_storage");
 514   EXPECT_TRUE(info_->feature_flags().ext_texture_storage);
 515   EXPECT_THAT(info_->extensions(), HasSubstr("GL_EXT_texture_storage"));
 516   EXPECT_TRUE(info_->validators()->texture_parameter.IsValid(
 517       GL_TEXTURE_IMMUTABLE_FORMAT_EXT));
 518   EXPECT_FALSE(info_->validators()->texture_internal_format_storage.IsValid(
 519       GL_BGRA8_EXT));
 520   EXPECT_FALSE(info_->validators()->texture_internal_format_storage.IsValid(
 521       GL_RGBA32F_EXT));
 522   EXPECT_FALSE(info_->validators()->texture_internal_format_storage.IsValid(
 523       GL_RGB32F_EXT));
 524   EXPECT_FALSE(info_->validators()->texture_internal_format_storage.IsValid(
 525       GL_ALPHA32F_EXT));
 526   EXPECT_FALSE(info_->validators()->texture_internal_format_storage.IsValid(
 527       GL_LUMINANCE32F_EXT));
 528   EXPECT_FALSE(info_->validators()->texture_internal_format_storage.IsValid(
 529       GL_LUMINANCE_ALPHA32F_EXT));
 530   EXPECT_FALSE(info_->validators()->texture_internal_format_storage.IsValid(
 531       GL_RGBA16F_EXT));
 532   EXPECT_FALSE(info_->validators()->texture_internal_format_storage.IsValid(
 533       GL_RGB16F_EXT));
 534   EXPECT_FALSE(info_->validators()->texture_internal_format_storage.IsValid(
 535       GL_ALPHA16F_EXT));
 536   EXPECT_FALSE(info_->validators()->texture_internal_format_storage.IsValid(
 537       GL_LUMINANCE16F_EXT));
 538   EXPECT_FALSE(info_->validators()->texture_internal_format_storage.IsValid(
 539       GL_LUMINANCE_ALPHA16F_EXT));
 540 }
 541
 542 TEST_P(FeatureInfoTest, InitializeARB_texture_storage) {
 543   SetupInitExpectations("GL_ARB_texture_storage");
 544   EXPECT_TRUE(info_->feature_flags().ext_texture_storage);
 545   EXPECT_THAT(info_->extensions(), HasSubstr("GL_EXT_texture_storage"));
 546   EXPECT_TRUE(info_->validators()->texture_parameter.IsValid(
 547       GL_TEXTURE_IMMUTABLE_FORMAT_EXT));
 548 }
 549
 550 TEST_P(FeatureInfoTest, InitializeEXT_texture_storage_BGRA) {
 551   SetupInitExpectations("GL_EXT_texture_storage GL_EXT_bgra");
 552   EXPECT_TRUE(info_->feature_flags().ext_texture_storage);
 553   EXPECT_THAT(info_->extensions(), HasSubstr("GL_EXT_texture_storage"));
 554   EXPECT_TRUE(info_->validators()->texture_internal_format_storage.IsValid(
 555       GL_BGRA8_EXT));
 556   EXPECT_THAT(info_->extensions(), HasSubstr("GL_EXT_texture_format_BGRA8888"));
 557 }
 558
 559 TEST_P(FeatureInfoTest, InitializeARB_texture_storage_BGRA) {
 560   SetupInitExpectations("GL_ARB_texture_storage GL_EXT_bgra");
 561   EXPECT_TRUE(info_->feature_flags().ext_texture_storage);
 562   EXPECT_THAT(info_->extensions(), HasSubstr("GL_EXT_texture_storage"));
 563   EXPECT_TRUE(info_->validators()->texture_internal_format_storage.IsValid(
 564       GL_BGRA8_EXT));
 565   EXPECT_THAT(info_->extensions(), HasSubstr("GL_EXT_texture_format_BGRA8888"));
 566 }
 567
 568 TEST_P(FeatureInfoTest, InitializeEXT_texture_storage_BGRA8888) {
 569   SetupInitExpectations(
 570       "GL_EXT_texture_storage GL_EXT_texture_format_BGRA8888");
 571   EXPECT_TRUE(info_->feature_flags().ext_texture_storage);
 572   EXPECT_THAT(info_->extensions(), HasSubstr("GL_EXT_texture_storage"));
 573   EXPECT_THAT(info_->extensions(), HasSubstr("GL_EXT_texture_format_BGRA8888"));
 574   EXPECT_TRUE(info_->validators()->texture_internal_format_storage.IsValid(
 575       GL_BGRA8_EXT));
 576   EXPECT_THAT(info_->extensions(), HasSubstr("GL_EXT_texture_format_BGRA8888"));
 577 }
 578
 579 TEST_P(FeatureInfoTest, InitializeEXT_texture_storage_float) {
 580   SetupInitExpectations("GL_EXT_texture_storage GL_OES_texture_float");
 581   EXPECT_THAT(info_->extensions(), HasSubstr("GL_EXT_texture_storage"));
 582   EXPECT_THAT(info_->extensions(), HasSubstr("GL_OES_texture_float"));
 583   EXPECT_TRUE(info_->validators()->texture_internal_format_storage.IsValid(
 584       GL_RGBA32F_EXT));
 585   EXPECT_TRUE(info_->validators()->texture_internal_format_storage.IsValid(
 586       GL_RGB32F_EXT));
 587   EXPECT_TRUE(info_->validators()->texture_internal_format_storage.IsValid(
 588       GL_ALPHA32F_EXT));
 589   EXPECT_TRUE(info_->validators()->texture_internal_format_storage.IsValid(
 590       GL_LUMINANCE32F_EXT));
 591   EXPECT_TRUE(info_->validators()->texture_internal_format_storage.IsValid(
 592       GL_LUMINANCE_ALPHA32F_EXT));
 593 }
 594
 595 TEST_P(FeatureInfoTest, InitializeEXT_texture_storage_half_float) {
 596   SetupInitExpectations("GL_EXT_texture_storage GL_OES_texture_half_float");
 597   EXPECT_THAT(info_->extensions(), HasSubstr("GL_EXT_texture_storage"));
 598   EXPECT_THAT(info_->extensions(), HasSubstr("GL_OES_texture_half_float"));
 599   EXPECT_TRUE(info_->validators()->texture_internal_format_storage.IsValid(
 600       GL_RGBA16F_EXT));
 601   EXPECT_TRUE(info_->validators()->texture_internal_format_storage.IsValid(
 602       GL_RGB16F_EXT));
 603   EXPECT_TRUE(info_->validators()->texture_internal_format_storage.IsValid(
 604       GL_ALPHA16F_EXT));
 605   EXPECT_TRUE(info_->validators()->texture_internal_format_storage.IsValid(
 606       GL_LUMINANCE16F_EXT));
 607   EXPECT_TRUE(info_->validators()->texture_internal_format_storage.IsValid(
 608       GL_LUMINANCE_ALPHA16F_EXT));
 609 }
 610
 611 // Check how to handle ES, texture_storage and BGRA combination; 10 tests.
 612
 613 // 1- ES2 + GL_EXT_texture_storage -> GL_EXT_texture_storage (and no
 614 // GL_EXT_texture_format_BGRA8888 - we don't claim to handle GL_BGRA8 in
 615 // glTexStorage2DEXT)
 616 TEST_P(FeatureInfoTest, InitializeGLES2_texture_storage) {
 617   SetupInitExpectationsWithGLVersion(
 618       "GL_EXT_texture_storage", "", "OpenGL ES 2.0");
 619   EXPECT_THAT(info_->extensions(), HasSubstr("GL_EXT_texture_storage"));
 620   EXPECT_THAT(info_->extensions(),
 621               Not(HasSubstr("GL_EXT_texture_format_BGRA8888")));
 622 }
 623
 624 // 2- ES2 + GL_EXT_texture_storage + (GL_EXT_texture_format_BGRA8888 or
 625 // GL_APPLE_texture_format_bgra8888)
 626 TEST_P(FeatureInfoTest, InitializeGLES2_texture_storage_BGRA) {
 627   SetupInitExpectationsWithGLVersion(
 628       "GL_EXT_texture_storage GL_EXT_texture_format_BGRA8888",
 629       "",
 630       "OpenGL ES 2.0");
 631   EXPECT_THAT(info_->extensions(), HasSubstr("GL_EXT_texture_storage"));
 632   EXPECT_THAT(info_->extensions(), HasSubstr("GL_EXT_texture_format_BGRA8888"));
 633 }
 634
 635 // 3- ES2 + GL_EXT_texture_format_BGRA8888 or GL_APPLE_texture_format_bgra8888
 636 TEST_P(FeatureInfoTest, InitializeGLES2_texture_format_BGRA) {
 637   SetupInitExpectationsWithGLVersion(
 638       "GL_EXT_texture_format_BGRA8888", "", "OpenGL ES 2.0");
 639   EXPECT_THAT(info_->extensions(), Not(HasSubstr("GL_EXT_texture_storage")));
 640   EXPECT_THAT(info_->extensions(), HasSubstr("GL_EXT_texture_format_BGRA8888"));
 641 }
 642
 643 // 4- ES2 (neither GL_EXT_texture_storage nor GL_EXT_texture_format_BGRA8888) ->
 644 // nothing
 645 TEST_P(FeatureInfoTest, InitializeGLES2_neither_texture_storage_nor_BGRA) {
 646   SetupInitExpectationsWithGLVersion("", "", "OpenGL ES 2.0");
 647   EXPECT_THAT(info_->extensions(), Not(HasSubstr("GL_EXT_texture_storage")));
 648   EXPECT_THAT(info_->extensions(),
 649               Not(HasSubstr("GL_EXT_texture_format_BGRA8888")));
 650 }
 651
 652 // 5- ES3 + GL_EXT_texture_format_BGRA8888 -> GL_EXT_texture_format_BGRA8888
 653 // (we can't expose GL_EXT_texture_storage because we fail the GL_BGRA8
 654 // requirement)
 655 TEST_P(FeatureInfoTest, InitializeGLES3_texture_storage_EXT_BGRA) {
 656   SetupInitExpectationsWithGLVersion(
 657       "GL_EXT_texture_format_BGRA8888", "", "OpenGL ES 3.0");
 658   EXPECT_THAT(info_->extensions(), Not(HasSubstr("GL_EXT_texture_storage")));
 659   EXPECT_THAT(info_->extensions(), HasSubstr("GL_EXT_texture_format_BGRA8888"));
 660 }
 661
 662 // 6- ES3 + GL_APPLE_texture_format_bgra8888 -> GL_EXT_texture_storage +
 663 // GL_EXT_texture_format_BGRA8888 (driver promises to handle GL_BGRA8 by
 664 // exposing GL_APPLE_texture_format_bgra8888)
 665 TEST_P(FeatureInfoTest, InitializeGLES3_texture_storage_APPLE_BGRA) {
 666   SetupInitExpectationsWithGLVersion(
 667       "GL_APPLE_texture_format_BGRA8888", "", "OpenGL ES 3.0");
 668   EXPECT_THAT(info_->extensions(), HasSubstr("GL_EXT_texture_storage"));
 669   EXPECT_THAT(info_->extensions(), HasSubstr("GL_EXT_texture_format_BGRA8888"));
 670 }
 671
 672 // 7- ES3 + GL_EXT_texture_storage + GL_EXT_texture_format_BGRA8888 ->
 673 // GL_EXT_texture_storage + GL_EXT_texture_format_BGRA8888  (driver promises to
 674 // handle GL_BGRA8 by exposing GL_EXT_texture_storage)
 675 TEST_P(FeatureInfoTest, InitializeGLES3_EXT_texture_storage_EXT_BGRA) {
 676   SetupInitExpectationsWithGLVersion(
 677       "GL_EXT_texture_storage GL_EXT_texture_format_BGRA8888",
 678       "",
 679       "OpenGL ES 3.0");
 680   EXPECT_THAT(info_->extensions(), HasSubstr("GL_EXT_texture_storage"));
 681   EXPECT_THAT(info_->extensions(), HasSubstr("GL_EXT_texture_format_BGRA8888"));
 682 }
 683
 684 // 8- ES3 + none of the above -> GL_EXT_texture_storage (and no
 685 // GL_EXT_texture_format_BGRA8888 - we don't claim to handle GL_BGRA8)
 686 TEST_P(FeatureInfoTest, InitializeGLES3_texture_storage) {
 687   SetupInitExpectationsWithGLVersion("", "", "OpenGL ES 3.0");
 688   EXPECT_THAT(info_->extensions(), HasSubstr("GL_EXT_texture_storage"));
 689   EXPECT_THAT(info_->extensions(),
 690               Not(HasSubstr("GL_EXT_texture_format_BGRA8888")));
 691 }
 692
 693 // 9- ANGLE will add the GL_CHROMIUM_renderbuffer_format_BGRA8888 extension and
 694 // the GL_BGRA8_EXT render buffer format.
 695 TEST_P(FeatureInfoTest, InitializeWithANGLE_BGRA8) {
 696   SetupInitExpectationsWithGLVersion("", kGLRendererStringANGLE, "");
 697   EXPECT_TRUE(info_->gl_version_info().is_angle);
 698   EXPECT_THAT(info_->extensions(),
 699               HasSubstr("GL_CHROMIUM_renderbuffer_format_BGRA8888"));
 700   EXPECT_TRUE(info_->validators()->render_buffer_format.IsValid(GL_BGRA8_EXT));
 701 }
 702
 703 // 10- vanilla opengl es means no GL_CHROMIUM_renderbuffer_format_BGRA8888
 704 TEST_P(FeatureInfoTest,
 705        InitializeGLES2_no_CHROMIUM_renderbuffer_format_BGRA8888) {
 706   SetupInitExpectationsWithGLVersion("", "", "OpenGL ES 2.0");
 707   EXPECT_THAT(info_->extensions(),
 708               Not(HasSubstr("GL_CHROMIUM_renderbuffer_format_BGRA8888")));
 709 }
 710
 711 TEST_P(FeatureInfoTest, InitializeARB_texture_float) {
 712   SetupInitExpectations("GL_ARB_texture_float");
 713   EXPECT_TRUE(info_->feature_flags().chromium_color_buffer_float_rgba);
 714   EXPECT_TRUE(info_->feature_flags().chromium_color_buffer_float_rgb);
 715   std::string extensions = info_->extensions() + " ";
 716   EXPECT_THAT(extensions, HasSubstr("GL_CHROMIUM_color_buffer_float_rgb "));
 717   EXPECT_THAT(extensions, HasSubstr("GL_CHROMIUM_color_buffer_float_rgba"));
 718   EXPECT_TRUE(info_->validators()->texture_internal_format.IsValid(
 719       GL_RGBA32F));
 720   EXPECT_TRUE(info_->validators()->texture_internal_format.IsValid(
 721       GL_RGB32F));
 722 }
 723
 724 TEST_P(FeatureInfoTest, Initialize_texture_floatGLES3) {
 725   SetupInitExpectationsWithGLVersion("", "", "OpenGL ES 3.0");
 726   EXPECT_THAT(info_->extensions(), Not(HasSubstr("GL_OES_texture_float")));
 727   EXPECT_THAT(info_->extensions(), Not(HasSubstr("GL_OES_texture_half_float")));
 728   EXPECT_THAT(info_->extensions(),
 729               Not(HasSubstr("GL_OES_texture_float_linear")));
 730   EXPECT_THAT(info_->extensions(),
 731               Not(HasSubstr("GL_OES_texture_half_float_linear")));
 732   EXPECT_FALSE(info_->GetTextureFormatValidator(GL_RGB).IsValid(
 733       GL_FLOAT));
 734   EXPECT_FALSE(info_->GetTextureFormatValidator(GL_RGBA).IsValid(
 735       GL_FLOAT));
 736   EXPECT_FALSE(info_->GetTextureFormatValidator(GL_LUMINANCE).IsValid(
 737       GL_FLOAT));
 738   EXPECT_FALSE(info_->GetTextureFormatValidator(GL_LUMINANCE_ALPHA).IsValid(
 739       GL_FLOAT));
 740   EXPECT_FALSE(info_->GetTextureFormatValidator(GL_ALPHA).IsValid(
 741       GL_FLOAT));
 742 }
 743
 744 TEST_P(FeatureInfoTest, Initialize_sRGBGLES3) {
 745   SetupInitExpectationsWithGLVersion("", "", "OpenGL ES 3.0");
 746   EXPECT_THAT(info_->extensions(), Not(HasSubstr("GL_EXT_sRGB")));
 747   EXPECT_FALSE(info_->GetTextureFormatValidator(GL_SRGB_EXT).IsValid(
 748       GL_UNSIGNED_BYTE));
 749   EXPECT_FALSE(info_->GetTextureFormatValidator(GL_SRGB_ALPHA_EXT).IsValid(
 750       GL_UNSIGNED_BYTE));
 751   EXPECT_FALSE(info_->validators()->texture_format.IsValid(
 752       GL_SRGB_EXT));
 753   EXPECT_FALSE(info_->validators()->texture_format.IsValid(
 754       GL_SRGB_ALPHA_EXT));
 755   EXPECT_FALSE(info_->validators()->texture_internal_format.IsValid(
 756       GL_SRGB_EXT));
 757   EXPECT_FALSE(info_->validators()->texture_internal_format.IsValid(
 758       GL_SRGB_ALPHA_EXT));
 759   EXPECT_FALSE(info_->validators()->render_buffer_format.IsValid(
 760       GL_SRGB8_ALPHA8_EXT));
 761   EXPECT_FALSE(info_->validators()->frame_buffer_parameter.IsValid(
 762       GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT));
 763 }
 764
 765 TEST_P(FeatureInfoTest, InitializeOES_texture_floatGLES2) {
 766   SetupInitExpectations("GL_OES_texture_float");
 767   EXPECT_FALSE(info_->feature_flags().enable_texture_float_linear);
 768   EXPECT_FALSE(info_->feature_flags().enable_texture_half_float_linear);
 769   EXPECT_THAT(info_->extensions(), HasSubstr("GL_OES_texture_float"));
 770   EXPECT_THAT(info_->extensions(), Not(HasSubstr("GL_OES_texture_half_float")));
 771   EXPECT_THAT(info_->extensions(),
 772               Not(HasSubstr("GL_OES_texture_float_linear")));
 773   EXPECT_THAT(info_->extensions(),
 774               Not(HasSubstr("GL_OES_texture_half_float_linear")));
 775   EXPECT_TRUE(info_->validators()->pixel_type.IsValid(GL_FLOAT));
 776   EXPECT_FALSE(info_->validators()->pixel_type.IsValid(GL_HALF_FLOAT_OES));
 777   EXPECT_TRUE(info_->GetTextureFormatValidator(GL_ALPHA).IsValid(
 778       GL_FLOAT));
 779   EXPECT_TRUE(info_->GetTextureFormatValidator(GL_RGB).IsValid(
 780       GL_FLOAT));
 781   EXPECT_TRUE(info_->GetTextureFormatValidator(GL_RGBA).IsValid(
 782       GL_FLOAT));
 783   EXPECT_TRUE(info_->GetTextureFormatValidator(GL_LUMINANCE).IsValid(
 784       GL_FLOAT));
 785   EXPECT_TRUE(info_->GetTextureFormatValidator(GL_LUMINANCE_ALPHA).IsValid(
 786       GL_FLOAT));
 787   EXPECT_FALSE(info_->GetTextureFormatValidator(GL_ALPHA).IsValid(
 788       GL_HALF_FLOAT_OES));
 789   EXPECT_FALSE(info_->GetTextureFormatValidator(GL_RGB).IsValid(
 790       GL_HALF_FLOAT_OES));
 791   EXPECT_FALSE(info_->GetTextureFormatValidator(GL_RGBA).IsValid(
 792       GL_HALF_FLOAT_OES));
 793   EXPECT_FALSE(info_->GetTextureFormatValidator(GL_LUMINANCE).IsValid(
 794       GL_HALF_FLOAT_OES));
 795   EXPECT_FALSE(info_->GetTextureFormatValidator(GL_LUMINANCE_ALPHA).IsValid(
 796       GL_HALF_FLOAT_OES));
 797 }
 798
 799 TEST_P(FeatureInfoTest, InitializeOES_texture_float_linearGLES2) {
 800   SetupInitExpectations("GL_OES_texture_float GL_OES_texture_float_linear");
 801   EXPECT_TRUE(info_->feature_flags().enable_texture_float_linear);
 802   EXPECT_FALSE(info_->feature_flags().enable_texture_half_float_linear);
 803   EXPECT_THAT(info_->extensions(), HasSubstr("GL_OES_texture_float"));
 804   EXPECT_THAT(info_->extensions(), Not(HasSubstr("GL_OES_texture_half_float")));
 805   EXPECT_THAT(info_->extensions(), HasSubstr("GL_OES_texture_float_linear"));
 806   EXPECT_THAT(info_->extensions(),
 807               Not(HasSubstr("GL_OES_texture_half_float_linear")));
 808   EXPECT_TRUE(info_->validators()->pixel_type.IsValid(GL_FLOAT));
 809   EXPECT_FALSE(info_->validators()->pixel_type.IsValid(GL_HALF_FLOAT_OES));
 810   EXPECT_TRUE(info_->GetTextureFormatValidator(GL_ALPHA).IsValid(
 811       GL_FLOAT));
 812   EXPECT_TRUE(info_->GetTextureFormatValidator(GL_RGB).IsValid(
 813       GL_FLOAT));
 814   EXPECT_TRUE(info_->GetTextureFormatValidator(GL_RGBA).IsValid(
 815       GL_FLOAT));
 816   EXPECT_TRUE(info_->GetTextureFormatValidator(GL_LUMINANCE).IsValid(
 817       GL_FLOAT));
 818   EXPECT_TRUE(info_->GetTextureFormatValidator(GL_LUMINANCE_ALPHA).IsValid(
 819       GL_FLOAT));
 820   EXPECT_FALSE(info_->GetTextureFormatValidator(GL_ALPHA).IsValid(
 821       GL_HALF_FLOAT_OES));
 822   EXPECT_FALSE(info_->GetTextureFormatValidator(GL_RGB).IsValid(
 823       GL_HALF_FLOAT_OES));
 824   EXPECT_FALSE(info_->GetTextureFormatValidator(GL_RGBA).IsValid(
 825       GL_HALF_FLOAT_OES));
 826   EXPECT_FALSE(info_->GetTextureFormatValidator(GL_LUMINANCE).IsValid(
 827       GL_HALF_FLOAT_OES));
 828   EXPECT_FALSE(info_->GetTextureFormatValidator(GL_LUMINANCE_ALPHA).IsValid(
 829       GL_HALF_FLOAT_OES));
 830 }
 831
 832 TEST_P(FeatureInfoTest, InitializeOES_texture_half_floatGLES2) {
 833   SetupInitExpectations("GL_OES_texture_half_float");
 834   EXPECT_FALSE(info_->feature_flags().enable_texture_float_linear);
 835   EXPECT_FALSE(info_->feature_flags().enable_texture_half_float_linear);
 836   EXPECT_THAT(info_->extensions(), Not(HasSubstr("GL_OES_texture_float")));
 837   EXPECT_THAT(info_->extensions(), HasSubstr("GL_OES_texture_half_float"));
 838   EXPECT_THAT(info_->extensions(),
 839               Not(HasSubstr("GL_OES_texture_float_linear")));
 840   EXPECT_THAT(info_->extensions(),
 841               Not(HasSubstr("GL_OES_texture_half_float_linear")));
 842   EXPECT_FALSE(info_->validators()->pixel_type.IsValid(GL_FLOAT));
 843   EXPECT_TRUE(info_->validators()->pixel_type.IsValid(GL_HALF_FLOAT_OES));
 844   EXPECT_FALSE(info_->GetTextureFormatValidator(GL_ALPHA).IsValid(
 845       GL_FLOAT));
 846   EXPECT_FALSE(info_->GetTextureFormatValidator(GL_RGB).IsValid(
 847       GL_FLOAT));
 848   EXPECT_FALSE(info_->GetTextureFormatValidator(GL_RGBA).IsValid(
 849       GL_FLOAT));
 850   EXPECT_FALSE(info_->GetTextureFormatValidator(GL_LUMINANCE).IsValid(
 851       GL_FLOAT));
 852   EXPECT_FALSE(info_->GetTextureFormatValidator(GL_LUMINANCE_ALPHA).IsValid(
 853       GL_FLOAT));
 854   EXPECT_TRUE(info_->GetTextureFormatValidator(GL_ALPHA).IsValid(
 855       GL_HALF_FLOAT_OES));
 856   EXPECT_TRUE(info_->GetTextureFormatValidator(GL_RGB).IsValid(
 857       GL_HALF_FLOAT_OES));
 858   EXPECT_TRUE(info_->GetTextureFormatValidator(GL_RGBA).IsValid(
 859       GL_HALF_FLOAT_OES));
 860   EXPECT_TRUE(info_->GetTextureFormatValidator(GL_LUMINANCE).IsValid(
 861       GL_HALF_FLOAT_OES));
 862   EXPECT_TRUE(info_->GetTextureFormatValidator(GL_LUMINANCE_ALPHA).IsValid(
 863       GL_HALF_FLOAT_OES));
 864 }
 865
 866 TEST_P(FeatureInfoTest, InitializeOES_texture_half_float_linearGLES2) {
 867   SetupInitExpectations(
 868       "GL_OES_texture_half_float GL_OES_texture_half_float_linear");
 869   EXPECT_FALSE(info_->feature_flags().enable_texture_float_linear);
 870   EXPECT_TRUE(info_->feature_flags().enable_texture_half_float_linear);
 871   EXPECT_THAT(info_->extensions(), Not(HasSubstr("GL_OES_texture_float")));
 872   EXPECT_THAT(info_->extensions(), HasSubstr("GL_OES_texture_half_float"));
 873   EXPECT_THAT(info_->extensions(),
 874               Not(HasSubstr("GL_OES_texture_float_linear")));
 875   EXPECT_THAT(info_->extensions(),
 876               HasSubstr("GL_OES_texture_half_float_linear"));
 877   EXPECT_FALSE(info_->validators()->pixel_type.IsValid(GL_FLOAT));
 878   EXPECT_TRUE(info_->validators()->pixel_type.IsValid(GL_HALF_FLOAT_OES));
 879   EXPECT_FALSE(info_->GetTextureFormatValidator(GL_ALPHA).IsValid(
 880       GL_FLOAT));
 881   EXPECT_FALSE(info_->GetTextureFormatValidator(GL_RGB).IsValid(
 882       GL_FLOAT));
 883   EXPECT_FALSE(info_->GetTextureFormatValidator(GL_RGBA).IsValid(
 884       GL_FLOAT));
 885   EXPECT_FALSE(info_->GetTextureFormatValidator(GL_LUMINANCE).IsValid(
 886       GL_FLOAT));
 887   EXPECT_FALSE(info_->GetTextureFormatValidator(GL_LUMINANCE_ALPHA).IsValid(
 888       GL_FLOAT));
 889   EXPECT_TRUE(info_->GetTextureFormatValidator(GL_ALPHA).IsValid(
 890       GL_HALF_FLOAT_OES));
 891   EXPECT_TRUE(info_->GetTextureFormatValidator(GL_RGB).IsValid(
 892       GL_HALF_FLOAT_OES));
 893   EXPECT_TRUE(info_->GetTextureFormatValidator(GL_RGBA).IsValid(
 894       GL_HALF_FLOAT_OES));
 895   EXPECT_TRUE(info_->GetTextureFormatValidator(GL_LUMINANCE).IsValid(
 896       GL_HALF_FLOAT_OES));
 897   EXPECT_TRUE(info_->GetTextureFormatValidator(GL_LUMINANCE_ALPHA).IsValid(
 898       GL_HALF_FLOAT_OES));
 899 }
 900
 901 TEST_P(FeatureInfoTest, InitializeEXT_framebuffer_multisample) {
 902   SetupInitExpectations("GL_EXT_framebuffer_multisample");
 903   EXPECT_TRUE(info_->feature_flags().chromium_framebuffer_multisample);
 904   EXPECT_THAT(info_->extensions(),
 905               HasSubstr("GL_CHROMIUM_framebuffer_multisample"));
 906   EXPECT_TRUE(info_->validators()->frame_buffer_target.IsValid(
 907       GL_READ_FRAMEBUFFER_EXT));
 908   EXPECT_TRUE(info_->validators()->frame_buffer_target.IsValid(
 909       GL_DRAW_FRAMEBUFFER_EXT));
 910   EXPECT_TRUE(info_->validators()->g_l_state.IsValid(
 911       GL_READ_FRAMEBUFFER_BINDING_EXT));
 912   EXPECT_TRUE(info_->validators()->g_l_state.IsValid(
 913       GL_MAX_SAMPLES_EXT));
 914   EXPECT_TRUE(info_->validators()->render_buffer_parameter.IsValid(
 915       GL_RENDERBUFFER_SAMPLES_EXT));
 916 }
 917
 918 TEST_P(FeatureInfoTest, InitializeANGLE_framebuffer_multisample) {
 919   SetupInitExpectationsWithGLVersion(
 920       "GL_ANGLE_framebuffer_multisample", kGLRendererStringANGLE, "");
 921   EXPECT_TRUE(info_->feature_flags().chromium_framebuffer_multisample);
 922   EXPECT_THAT(info_->extensions(),
 923               HasSubstr("GL_CHROMIUM_framebuffer_multisample"));
 924   EXPECT_TRUE(info_->validators()->frame_buffer_target.IsValid(
 925       GL_READ_FRAMEBUFFER_EXT));
 926   EXPECT_TRUE(info_->validators()->frame_buffer_target.IsValid(
 927       GL_DRAW_FRAMEBUFFER_EXT));
 928   EXPECT_TRUE(info_->validators()->g_l_state.IsValid(
 929       GL_READ_FRAMEBUFFER_BINDING_EXT));
 930   EXPECT_TRUE(info_->validators()->g_l_state.IsValid(
 931       GL_MAX_SAMPLES_EXT));
 932   EXPECT_TRUE(info_->validators()->render_buffer_parameter.IsValid(
 933       GL_RENDERBUFFER_SAMPLES_EXT));
 934 }
 935
 936 // We don't allow ANGLE_framebuffer_multisample on non-ANGLE implementations,
 937 // because we wouldn't be choosing the right driver entry point and because the
 938 // extension was falsely advertised on some Android devices (crbug.com/165736).
 939 TEST_P(FeatureInfoTest, InitializeANGLE_framebuffer_multisampleWithoutANGLE) {
 940   SetupInitExpectations("GL_ANGLE_framebuffer_multisample");
 941   EXPECT_FALSE(info_->feature_flags().chromium_framebuffer_multisample);
 942   EXPECT_THAT(info_->extensions(),
 943               Not(HasSubstr("GL_CHROMIUM_framebuffer_multisample")));
 944   EXPECT_FALSE(info_->validators()->frame_buffer_target.IsValid(
 945       GL_READ_FRAMEBUFFER_EXT));
 946   EXPECT_FALSE(info_->validators()->frame_buffer_target.IsValid(
 947       GL_DRAW_FRAMEBUFFER_EXT));
 948   EXPECT_FALSE(info_->validators()->g_l_state.IsValid(
 949       GL_READ_FRAMEBUFFER_BINDING_EXT));
 950   EXPECT_FALSE(info_->validators()->g_l_state.IsValid(
 951       GL_MAX_SAMPLES_EXT));
 952   EXPECT_FALSE(info_->validators()->render_buffer_parameter.IsValid(
 953       GL_RENDERBUFFER_SAMPLES_EXT));
 954 }
 955
 956 TEST_P(FeatureInfoTest, InitializeEXT_multisampled_render_to_texture) {
 957   SetupInitExpectations("GL_EXT_multisampled_render_to_texture");
 958   EXPECT_TRUE(info_->feature_flags(
 959       ).multisampled_render_to_texture);
 960   EXPECT_FALSE(info_->feature_flags(
 961       ).use_img_for_multisampled_render_to_texture);
 962   EXPECT_THAT(info_->extensions(),
 963               HasSubstr("GL_EXT_multisampled_render_to_texture"));
 964   EXPECT_TRUE(info_->validators()->g_l_state.IsValid(
 965       GL_MAX_SAMPLES_EXT));
 966   EXPECT_TRUE(info_->validators()->render_buffer_parameter.IsValid(
 967       GL_RENDERBUFFER_SAMPLES_EXT));
 968   EXPECT_TRUE(info_->validators()->frame_buffer_parameter.IsValid(
 969       GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_SAMPLES_EXT));
 970 }
 971
 972 TEST_P(FeatureInfoTest, InitializeIMG_multisampled_render_to_texture) {
 973   SetupInitExpectations("GL_IMG_multisampled_render_to_texture");
 974   EXPECT_TRUE(info_->feature_flags(
 975       ).multisampled_render_to_texture);
 976   EXPECT_TRUE(info_->feature_flags(
 977       ).use_img_for_multisampled_render_to_texture);
 978   EXPECT_THAT(info_->extensions(),
 979               HasSubstr("GL_EXT_multisampled_render_to_texture"));
 980   EXPECT_TRUE(info_->validators()->g_l_state.IsValid(
 981       GL_MAX_SAMPLES_EXT));
 982   EXPECT_TRUE(info_->validators()->render_buffer_parameter.IsValid(
 983       GL_RENDERBUFFER_SAMPLES_EXT));
 984   EXPECT_TRUE(info_->validators()->frame_buffer_parameter.IsValid(
 985       GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_SAMPLES_EXT));
 986 }
 987
 988 TEST_P(FeatureInfoTest, InitializeEXT_texture_filter_anisotropic) {
 989   SetupInitExpectations("GL_EXT_texture_filter_anisotropic");
 990   EXPECT_THAT(info_->extensions(),
 991               HasSubstr("GL_EXT_texture_filter_anisotropic"));
 992   EXPECT_TRUE(info_->validators()->texture_parameter.IsValid(
 993       GL_TEXTURE_MAX_ANISOTROPY_EXT));
 994   EXPECT_TRUE(info_->validators()->g_l_state.IsValid(
 995       GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT));
 996 }
 997
 998 TEST_P(FeatureInfoTest, InitializeEXT_ARB_depth_texture) {
 999   SetupInitExpectations("GL_ARB_depth_texture");
1000   EXPECT_THAT(info_->extensions(),
1001               HasSubstr("GL_GOOGLE_depth_texture"));
1002   EXPECT_THAT(info_->extensions(),
1003               HasSubstr("GL_CHROMIUM_depth_texture"));
1004   EXPECT_TRUE(info_->validators()->texture_internal_format.IsValid(
1005       GL_DEPTH_COMPONENT));
1006   EXPECT_TRUE(info_->validators()->texture_format.IsValid(GL_DEPTH_COMPONENT));
1007   EXPECT_FALSE(info_->validators()->texture_format.IsValid(GL_DEPTH_STENCIL));
1008   EXPECT_TRUE(info_->validators()->pixel_type.IsValid(GL_UNSIGNED_SHORT));
1009   EXPECT_TRUE(info_->validators()->pixel_type.IsValid(GL_UNSIGNED_INT));
1010   EXPECT_TRUE(info_->GetTextureFormatValidator(GL_DEPTH_COMPONENT).IsValid(
1011       GL_UNSIGNED_SHORT));
1012   EXPECT_TRUE(info_->GetTextureFormatValidator(GL_DEPTH_COMPONENT).IsValid(
1013       GL_UNSIGNED_INT));
1014   EXPECT_FALSE(info_->GetTextureFormatValidator(GL_DEPTH_STENCIL).IsValid(
1015       GL_UNSIGNED_INT_24_8));
1016 }
1017
1018 TEST_P(FeatureInfoTest, InitializeOES_ARB_depth_texture) {
1019   SetupInitExpectations("GL_OES_depth_texture");
1020   EXPECT_THAT(info_->extensions(),
1021               HasSubstr("GL_GOOGLE_depth_texture"));
1022   EXPECT_THAT(info_->extensions(),
1023               HasSubstr("GL_CHROMIUM_depth_texture"));
1024   EXPECT_TRUE(info_->validators()->texture_internal_format.IsValid(
1025       GL_DEPTH_COMPONENT));
1026   EXPECT_TRUE(info_->validators()->texture_format.IsValid(GL_DEPTH_COMPONENT));
1027   EXPECT_FALSE(info_->validators()->texture_format.IsValid(GL_DEPTH_STENCIL));
1028   EXPECT_TRUE(info_->validators()->pixel_type.IsValid(GL_UNSIGNED_SHORT));
1029   EXPECT_TRUE(info_->validators()->pixel_type.IsValid(GL_UNSIGNED_INT));
1030   EXPECT_TRUE(info_->GetTextureFormatValidator(GL_DEPTH_COMPONENT).IsValid(
1031       GL_UNSIGNED_SHORT));
1032   EXPECT_TRUE(info_->GetTextureFormatValidator(GL_DEPTH_COMPONENT).IsValid(
1033       GL_UNSIGNED_INT));
1034   EXPECT_FALSE(info_->GetTextureFormatValidator(GL_DEPTH_STENCIL).IsValid(
1035       GL_UNSIGNED_INT_24_8));
1036 }
1037
1038 TEST_P(FeatureInfoTest, InitializeANGLE_depth_texture) {
1039   SetupInitExpectations("GL_ANGLE_depth_texture");
1040   EXPECT_THAT(info_->extensions(),
1041               HasSubstr("GL_GOOGLE_depth_texture"));
1042   EXPECT_THAT(info_->extensions(),
1043               HasSubstr("GL_CHROMIUM_depth_texture"));
1044   EXPECT_THAT(info_->extensions(),
1045               Not(HasSubstr("GL_ANGLE_depth_texture")));
1046   EXPECT_TRUE(info_->feature_flags().angle_depth_texture);
1047   EXPECT_TRUE(info_->validators()->texture_internal_format.IsValid(
1048       GL_DEPTH_COMPONENT));
1049   EXPECT_TRUE(info_->validators()->texture_format.IsValid(GL_DEPTH_COMPONENT));
1050   EXPECT_FALSE(info_->validators()->texture_format.IsValid(GL_DEPTH_STENCIL));
1051   EXPECT_TRUE(info_->validators()->pixel_type.IsValid(GL_UNSIGNED_SHORT));
1052   EXPECT_TRUE(info_->validators()->pixel_type.IsValid(GL_UNSIGNED_INT));
1053   EXPECT_FALSE(info_->validators()->texture_internal_format_storage.IsValid(
1054       GL_DEPTH_COMPONENT16));
1055   EXPECT_FALSE(info_->validators()->texture_internal_format_storage.IsValid(
1056       GL_DEPTH_COMPONENT32_OES));
1057   EXPECT_FALSE(info_->validators()->texture_internal_format_storage.IsValid(
1058       GL_DEPTH24_STENCIL8_OES));
1059   EXPECT_TRUE(info_->GetTextureFormatValidator(GL_DEPTH_COMPONENT).IsValid(
1060       GL_UNSIGNED_SHORT));
1061   EXPECT_TRUE(info_->GetTextureFormatValidator(GL_DEPTH_COMPONENT).IsValid(
1062       GL_UNSIGNED_INT));
1063   EXPECT_FALSE(info_->GetTextureFormatValidator(GL_DEPTH_STENCIL).IsValid(
1064       GL_UNSIGNED_INT_24_8));
1065 }
1066
1067 TEST_P(FeatureInfoTest, InitializeEXT_packed_depth_stencil) {
1068   SetupInitExpectations("GL_EXT_packed_depth_stencil");
1069   EXPECT_THAT(info_->extensions(),
1070               HasSubstr("GL_OES_packed_depth_stencil"));
1071   EXPECT_TRUE(info_->validators()->render_buffer_format.IsValid(
1072       GL_DEPTH24_STENCIL8));
1073   EXPECT_FALSE(info_->validators()->texture_internal_format.IsValid(
1074       GL_DEPTH_COMPONENT));
1075   EXPECT_FALSE(info_->validators()->texture_format.IsValid(GL_DEPTH_COMPONENT));
1076   EXPECT_FALSE(info_->validators()->pixel_type.IsValid(GL_UNSIGNED_SHORT));
1077   EXPECT_FALSE(info_->validators()->pixel_type.IsValid(GL_UNSIGNED_INT));
1078 }
1079
1080 TEST_P(FeatureInfoTest, InitializeOES_packed_depth_stencil) {
1081   SetupInitExpectations("GL_OES_packed_depth_stencil");
1082   EXPECT_THAT(info_->extensions(),
1083               HasSubstr("GL_OES_packed_depth_stencil"));
1084   EXPECT_TRUE(info_->validators()->render_buffer_format.IsValid(
1085       GL_DEPTH24_STENCIL8));
1086   EXPECT_FALSE(info_->validators()->texture_internal_format.IsValid(
1087       GL_DEPTH_COMPONENT));
1088   EXPECT_FALSE(info_->validators()->texture_format.IsValid(GL_DEPTH_COMPONENT));
1089   EXPECT_FALSE(info_->validators()->pixel_type.IsValid(GL_UNSIGNED_SHORT));
1090   EXPECT_FALSE(info_->validators()->pixel_type.IsValid(GL_UNSIGNED_INT));
1091 }
1092
1093 TEST_P(FeatureInfoTest,
1094        InitializeOES_packed_depth_stencil_and_GL_ARB_depth_texture) {
1095   SetupInitExpectations("GL_OES_packed_depth_stencil GL_ARB_depth_texture");
1096   EXPECT_THAT(info_->extensions(),
1097               HasSubstr("GL_OES_packed_depth_stencil"));
1098   EXPECT_TRUE(info_->validators()->render_buffer_format.IsValid(
1099       GL_DEPTH24_STENCIL8));
1100   EXPECT_TRUE(info_->validators()->texture_internal_format.IsValid(
1101       GL_DEPTH_STENCIL));
1102   EXPECT_TRUE(info_->validators()->texture_format.IsValid(
1103       GL_DEPTH_STENCIL));
1104   EXPECT_TRUE(info_->validators()->pixel_type.IsValid(
1105       GL_UNSIGNED_INT_24_8));
1106   EXPECT_TRUE(info_->GetTextureFormatValidator(GL_DEPTH_COMPONENT).IsValid(
1107       GL_UNSIGNED_SHORT));
1108   EXPECT_TRUE(info_->GetTextureFormatValidator(GL_DEPTH_COMPONENT).IsValid(
1109       GL_UNSIGNED_INT));
1110   EXPECT_TRUE(info_->GetTextureFormatValidator(GL_DEPTH_STENCIL).IsValid(
1111       GL_UNSIGNED_INT_24_8));
1112 }
1113
1114 TEST_P(FeatureInfoTest, InitializeOES_depth24) {
1115   SetupInitExpectations("GL_OES_depth24");
1116   EXPECT_TRUE(info_->feature_flags().oes_depth24);
1117   EXPECT_THAT(info_->extensions(), HasSubstr("GL_OES_depth24"));
1118   EXPECT_TRUE(info_->validators()->render_buffer_format.IsValid(
1119       GL_DEPTH_COMPONENT24));
1120 }
1121
1122 TEST_P(FeatureInfoTest, InitializeOES_standard_derivatives) {
1123   SetupInitExpectations("GL_OES_standard_derivatives");
1124   EXPECT_THAT(info_->extensions(), HasSubstr("GL_OES_standard_derivatives"));
1125   EXPECT_TRUE(info_->feature_flags().oes_standard_derivatives);
1126   EXPECT_TRUE(info_->validators()->hint_target.IsValid(
1127       GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES));
1128   EXPECT_TRUE(info_->validators()->g_l_state.IsValid(
1129       GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES));
1130 }
1131
1132 TEST_P(FeatureInfoTest, InitializeOES_rgb8_rgba8) {
1133   SetupInitExpectations("GL_OES_rgb8_rgba8");
1134   EXPECT_THAT(info_->extensions(),
1135               HasSubstr("GL_OES_rgb8_rgba8"));
1136   EXPECT_TRUE(info_->validators()->render_buffer_format.IsValid(
1137       GL_RGB8_OES));
1138   EXPECT_TRUE(info_->validators()->render_buffer_format.IsValid(
1139       GL_RGBA8_OES));
1140 }
1141
1142 TEST_P(FeatureInfoTest, InitializeOES_EGL_image_external) {
1143   SetupInitExpectations("GL_OES_EGL_image_external");
1144   EXPECT_THAT(info_->extensions(),
1145               HasSubstr("GL_OES_EGL_image_external"));
1146   EXPECT_TRUE(info_->feature_flags().oes_egl_image_external);
1147   EXPECT_TRUE(info_->validators()->texture_bind_target.IsValid(
1148       GL_TEXTURE_EXTERNAL_OES));
1149   EXPECT_TRUE(info_->validators()->get_tex_param_target.IsValid(
1150       GL_TEXTURE_EXTERNAL_OES));
1151   EXPECT_TRUE(info_->validators()->texture_parameter.IsValid(
1152       GL_REQUIRED_TEXTURE_IMAGE_UNITS_OES));
1153   EXPECT_TRUE(info_->validators()->g_l_state.IsValid(
1154       GL_TEXTURE_BINDING_EXTERNAL_OES));
1155 }
1156
1157 TEST_P(FeatureInfoTest, InitializeOES_compressed_ETC1_RGB8_texture) {
1158   SetupInitExpectations("GL_OES_compressed_ETC1_RGB8_texture");
1159   EXPECT_THAT(info_->extensions(),
1160               HasSubstr("GL_OES_compressed_ETC1_RGB8_texture"));
1161   EXPECT_TRUE(info_->validators()->compressed_texture_format.IsValid(
1162       GL_ETC1_RGB8_OES));
1163   EXPECT_FALSE(info_->validators()->texture_internal_format.IsValid(
1164       GL_ETC1_RGB8_OES));
1165 }
1166
1167 TEST_P(FeatureInfoTest, InitializeAMD_compressed_ATC_texture) {
1168   SetupInitExpectations("GL_AMD_compressed_ATC_texture");
1169   EXPECT_THAT(info_->extensions(),
1170               HasSubstr("GL_AMD_compressed_ATC_texture"));
1171   EXPECT_TRUE(info_->validators()->compressed_texture_format.IsValid(
1172       GL_ATC_RGB_AMD));
1173   EXPECT_TRUE(info_->validators()->compressed_texture_format.IsValid(
1174       GL_ATC_RGBA_EXPLICIT_ALPHA_AMD));
1175   EXPECT_TRUE(info_->validators()->compressed_texture_format.IsValid(
1176       GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD));
1177 }
1178
1179 TEST_P(FeatureInfoTest, InitializeIMG_texture_compression_pvrtc) {
1180   SetupInitExpectations("GL_IMG_texture_compression_pvrtc");
1181   EXPECT_THAT(info_->extensions(),
1182               HasSubstr("GL_IMG_texture_compression_pvrtc"));
1183   EXPECT_TRUE(info_->validators()->compressed_texture_format.IsValid(
1184       GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG));
1185   EXPECT_TRUE(info_->validators()->compressed_texture_format.IsValid(
1186       GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG));
1187   EXPECT_TRUE(info_->validators()->compressed_texture_format.IsValid(
1188       GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG));
1189   EXPECT_TRUE(info_->validators()->compressed_texture_format.IsValid(
1190       GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG));
1191 }
1192
1193 TEST_P(FeatureInfoTest, InitializeEXT_occlusion_query_boolean) {
1194   SetupInitExpectations("GL_EXT_occlusion_query_boolean");
1195   EXPECT_THAT(info_->extensions(),
1196               HasSubstr("GL_EXT_occlusion_query_boolean"));
1197   EXPECT_TRUE(info_->feature_flags().occlusion_query_boolean);
1198   EXPECT_FALSE(info_->feature_flags(
1199       ).use_arb_occlusion_query2_for_occlusion_query_boolean);
1200   EXPECT_FALSE(info_->feature_flags(
1201       ).use_arb_occlusion_query_for_occlusion_query_boolean);
1202 }
1203
1204 TEST_P(FeatureInfoTest, InitializeARB_occlusion_query) {
1205   SetupInitExpectations("GL_ARB_occlusion_query");
1206   EXPECT_THAT(info_->extensions(),
1207               HasSubstr("GL_EXT_occlusion_query_boolean"));
1208   EXPECT_TRUE(info_->feature_flags().occlusion_query_boolean);
1209   EXPECT_FALSE(info_->feature_flags(
1210       ).use_arb_occlusion_query2_for_occlusion_query_boolean);
1211   EXPECT_TRUE(info_->feature_flags(
1212       ).use_arb_occlusion_query_for_occlusion_query_boolean);
1213 }
1214
1215 TEST_P(FeatureInfoTest, InitializeARB_occlusion_query2) {
1216   SetupInitExpectations("GL_ARB_occlusion_query2 GL_ARB_occlusion_query2");
1217   EXPECT_THAT(info_->extensions(),
1218               HasSubstr("GL_EXT_occlusion_query_boolean"));
1219   EXPECT_TRUE(info_->feature_flags().occlusion_query_boolean);
1220   EXPECT_TRUE(info_->feature_flags(
1221       ).use_arb_occlusion_query2_for_occlusion_query_boolean);
1222   EXPECT_FALSE(info_->feature_flags(
1223       ).use_arb_occlusion_query_for_occlusion_query_boolean);
1224 }
1225
1226 TEST_P(FeatureInfoTest, InitializeOES_vertex_array_object) {
1227   SetupInitExpectations("GL_OES_vertex_array_object");
1228   EXPECT_THAT(info_->extensions(),
1229       HasSubstr("GL_OES_vertex_array_object"));
1230   EXPECT_TRUE(info_->feature_flags().native_vertex_array_object);
1231 }
1232
1233 TEST_P(FeatureInfoTest, InitializeARB_vertex_array_object) {
1234   SetupInitExpectations("GL_ARB_vertex_array_object");
1235   EXPECT_THAT(info_->extensions(),
1236       HasSubstr("GL_OES_vertex_array_object"));
1237   EXPECT_TRUE(info_->feature_flags().native_vertex_array_object);
1238 }
1239
1240 TEST_P(FeatureInfoTest, InitializeAPPLE_vertex_array_object) {
1241   SetupInitExpectations("GL_APPLE_vertex_array_object");
1242   EXPECT_THAT(info_->extensions(),
1243       HasSubstr("GL_OES_vertex_array_object"));
1244   EXPECT_TRUE(info_->feature_flags().native_vertex_array_object);
1245 }
1246
1247 TEST_P(FeatureInfoTest, InitializeNo_vertex_array_object) {
1248   SetupInitExpectations("");
1249   // Even if the native extensions are not available the implementation
1250   // may still emulate the GL_OES_vertex_array_object functionality. In this
1251   // scenario native_vertex_array_object must be false.
1252   EXPECT_THAT(info_->extensions(),
1253               HasSubstr("GL_OES_vertex_array_object"));
1254   EXPECT_FALSE(info_->feature_flags().native_vertex_array_object);
1255 }
1256
1257 TEST_P(FeatureInfoTest, InitializeOES_element_index_uint) {
1258   SetupInitExpectations("GL_OES_element_index_uint");
1259   EXPECT_THAT(info_->extensions(),
1260               HasSubstr("GL_OES_element_index_uint"));
1261   EXPECT_TRUE(info_->validators()->index_type.IsValid(GL_UNSIGNED_INT));
1262 }
1263
1264 TEST_P(FeatureInfoTest, InitializeVAOsWithClientSideArrays) {
1265   base::CommandLine command_line(0, NULL);
1266   command_line.AppendSwitchASCII(
1267       switches::kGpuDriverBugWorkarounds,
1268       base::IntToString(gpu::USE_CLIENT_SIDE_ARRAYS_FOR_STREAM_BUFFERS));
1269   SetupInitExpectationsWithCommandLine("GL_OES_vertex_array_object",
1270                                        command_line);
1271   EXPECT_TRUE(info_->workarounds().use_client_side_arrays_for_stream_buffers);
1272   EXPECT_FALSE(info_->feature_flags().native_vertex_array_object);
1273 }
1274
1275 TEST_P(FeatureInfoTest, InitializeEXT_blend_minmax) {
1276   SetupInitExpectations("GL_EXT_blend_minmax");
1277   EXPECT_THAT(info_->extensions(), HasSubstr("GL_EXT_blend_minmax"));
1278   EXPECT_TRUE(info_->validators()->equation.IsValid(GL_MIN_EXT));
1279   EXPECT_TRUE(info_->validators()->equation.IsValid(GL_MAX_EXT));
1280 }
1281
1282 TEST_P(FeatureInfoTest, InitializeEXT_frag_depth) {
1283   SetupInitExpectations("GL_EXT_frag_depth");
1284   EXPECT_TRUE(info_->feature_flags().ext_frag_depth);
1285   EXPECT_THAT(info_->extensions(), HasSubstr("GL_EXT_frag_depth"));
1286 }
1287
1288 TEST_P(FeatureInfoTest, InitializeEXT_shader_texture_lod) {
1289   SetupInitExpectations("GL_EXT_shader_texture_lod");
1290   EXPECT_TRUE(info_->feature_flags().ext_shader_texture_lod);
1291   EXPECT_THAT(info_->extensions(), HasSubstr("GL_EXT_shader_texture_lod"));
1292 }
1293
1294 TEST_P(FeatureInfoTest, InitializeEXT_discard_framebuffer) {
1295   SetupInitExpectations("GL_EXT_discard_framebuffer");
1296   EXPECT_TRUE(info_->feature_flags().ext_discard_framebuffer);
1297   EXPECT_THAT(info_->extensions(), HasSubstr("GL_EXT_discard_framebuffer"));
1298 }
1299
1300 TEST_P(FeatureInfoTest, InitializeSamplersWithARBSamplerObjects) {
1301   SetupInitExpectationsWithGLVersion(
1302       "GL_ARB_sampler_objects", "", "OpenGL 3.0");
1303   EXPECT_TRUE(info_->feature_flags().enable_samplers);
1304 }
1305
1306 TEST_P(FeatureInfoTest, InitializeWithES3) {
1307   SetupInitExpectationsWithGLVersion("", "", "OpenGL ES 3.0");
1308   EXPECT_TRUE(info_->feature_flags().chromium_framebuffer_multisample);
1309   EXPECT_TRUE(info_->feature_flags().use_core_framebuffer_multisample);
1310   EXPECT_THAT(info_->extensions(),
1311               HasSubstr("GL_CHROMIUM_framebuffer_multisample"));
1312   EXPECT_TRUE(info_->feature_flags().use_async_readpixels);
1313   EXPECT_TRUE(info_->feature_flags().oes_standard_derivatives);
1314   EXPECT_TRUE(info_->feature_flags().oes_depth24);
1315   EXPECT_THAT(info_->extensions(), HasSubstr("GL_GOOGLE_depth_texture"));
1316   EXPECT_THAT(info_->extensions(), HasSubstr("GL_CHROMIUM_depth_texture"));
1317   EXPECT_TRUE(
1318       info_->validators()->texture_internal_format.IsValid(GL_DEPTH_COMPONENT));
1319   EXPECT_TRUE(
1320       info_->validators()->texture_internal_format.IsValid(GL_DEPTH_STENCIL));
1321   EXPECT_TRUE(info_->validators()->texture_format.IsValid(GL_DEPTH_COMPONENT));
1322   EXPECT_TRUE(info_->validators()->texture_format.IsValid(GL_DEPTH_STENCIL));
1323   EXPECT_TRUE(info_->validators()->pixel_type.IsValid(GL_UNSIGNED_SHORT));
1324   EXPECT_TRUE(info_->validators()->pixel_type.IsValid(GL_UNSIGNED_INT));
1325   EXPECT_TRUE(info_->validators()->pixel_type.IsValid(GL_UNSIGNED_INT_24_8));
1326   EXPECT_TRUE(info_->GetTextureFormatValidator(GL_DEPTH_COMPONENT)
1327                   .IsValid(GL_UNSIGNED_SHORT));
1328   EXPECT_TRUE(info_->GetTextureFormatValidator(GL_DEPTH_COMPONENT)
1329                   .IsValid(GL_UNSIGNED_INT));
1330   EXPECT_TRUE(info_->GetTextureFormatValidator(GL_DEPTH_STENCIL)
1331                   .IsValid(GL_UNSIGNED_INT_24_8));
1332   EXPECT_TRUE(info_->feature_flags().packed_depth24_stencil8);
1333   EXPECT_THAT(info_->extensions(), HasSubstr("GL_OES_depth24"));
1334   EXPECT_TRUE(
1335       info_->validators()->render_buffer_format.IsValid(GL_DEPTH_COMPONENT24));
1336   EXPECT_TRUE(
1337       info_->validators()->render_buffer_format.IsValid(GL_DEPTH24_STENCIL8));
1338   EXPECT_TRUE(
1339       info_->validators()->texture_internal_format.IsValid(GL_DEPTH_STENCIL));
1340   EXPECT_TRUE(info_->validators()->texture_format.IsValid(GL_DEPTH_STENCIL));
1341   EXPECT_TRUE(info_->feature_flags().npot_ok);
1342   EXPECT_TRUE(info_->feature_flags().native_vertex_array_object);
1343   EXPECT_TRUE(info_->feature_flags().enable_samplers);
1344   EXPECT_TRUE(info_->feature_flags().map_buffer_range);
1345   EXPECT_TRUE(info_->feature_flags().ext_discard_framebuffer);
1346   EXPECT_THAT(info_->extensions(), HasSubstr("GL_EXT_discard_framebuffer"));
1347   EXPECT_TRUE(info_->feature_flags().chromium_sync_query);
1348   EXPECT_TRUE(gfx::GLFence::IsSupported());
1349 }
1350
1351 TEST_P(FeatureInfoTest, InitializeWithoutSamplers) {
1352   SetupInitExpectationsWithGLVersion("", "", "OpenGL GL 3.0");
1353   EXPECT_FALSE(info_->feature_flags().enable_samplers);
1354 }
1355
1356 TEST_P(FeatureInfoTest, ParseDriverBugWorkaroundsSingle) {
1357   base::CommandLine command_line(0, NULL);
1358   command_line.AppendSwitchASCII(
1359       switches::kGpuDriverBugWorkarounds,
1360       base::IntToString(gpu::EXIT_ON_CONTEXT_LOST));
1361   // Workarounds should get parsed without the need for a context.
1362   SetupWithCommandLine(command_line);
1363   EXPECT_TRUE(info_->workarounds().exit_on_context_lost);
1364 }
1365
1366 TEST_P(FeatureInfoTest, ParseDriverBugWorkaroundsMultiple) {
1367   base::CommandLine command_line(0, NULL);
1368   command_line.AppendSwitchASCII(
1369       switches::kGpuDriverBugWorkarounds,
1370       base::IntToString(gpu::EXIT_ON_CONTEXT_LOST) + "," +
1371       base::IntToString(gpu::MAX_CUBE_MAP_TEXTURE_SIZE_LIMIT_1024) + "," +
1372       base::IntToString(gpu::MAX_TEXTURE_SIZE_LIMIT_4096));
1373   // Workarounds should get parsed without the need for a context.
1374   SetupWithCommandLine(command_line);
1375   EXPECT_TRUE(info_->workarounds().exit_on_context_lost);
1376   EXPECT_EQ(1024, info_->workarounds().max_cube_map_texture_size);
1377   EXPECT_EQ(4096, info_->workarounds().max_texture_size);
1378 }
1379
1380 TEST_P(FeatureInfoTest, InitializeWithARBSync) {
1381   SetupInitExpectations("GL_ARB_sync");
1382   EXPECT_TRUE(info_->feature_flags().chromium_sync_query);
1383   EXPECT_TRUE(gfx::GLFence::IsSupported());
1384 }
1385
1386 TEST_P(FeatureInfoTest, InitializeWithNVFence) {
1387   SetupInitExpectations("GL_NV_fence");
1388   EXPECT_TRUE(info_->feature_flags().chromium_sync_query);
1389   EXPECT_TRUE(gfx::GLFence::IsSupported());
1390 }
1391
1392 TEST_P(FeatureInfoTest, InitializeWithNVDrawBuffers) {
1393   SetupInitExpectationsWithGLVersion("GL_NV_draw_buffers", "", "OpenGL ES 3.0");
1394   EXPECT_TRUE(info_->feature_flags().nv_draw_buffers);
1395   EXPECT_TRUE(info_->feature_flags().ext_draw_buffers);
1396 }
1397
1398 TEST_P(FeatureInfoTest, InitializeWithPreferredEXTDrawBuffers) {
1399   SetupInitExpectationsWithGLVersion(
1400       "GL_NV_draw_buffers GL_EXT_draw_buffers", "", "OpenGL ES 3.0");
1401   EXPECT_FALSE(info_->feature_flags().nv_draw_buffers);
1402   EXPECT_TRUE(info_->feature_flags().ext_draw_buffers);
1403 }
1404
1405 TEST_P(FeatureInfoTest, ARBSyncDisabled) {
1406   base::CommandLine command_line(0, NULL);
1407   command_line.AppendSwitchASCII(
1408       switches::kGpuDriverBugWorkarounds,
1409       base::IntToString(gpu::DISABLE_ARB_SYNC));
1410   SetupInitExpectationsWithCommandLine("GL_ARB_sync", command_line);
1411   EXPECT_FALSE(info_->feature_flags().chromium_sync_query);
1412   EXPECT_FALSE(gfx::GLFence::IsSupported());
1413 }
1414
1415 TEST_P(FeatureInfoTest, InitializeCHROMIUM_path_rendering) {
1416   SetupInitExpectationsWithGLVersion(
1417       "GL_ARB_compatibility GL_NV_path_rendering GL_EXT_direct_state_access",
1418       "", "4.3");
1419   EXPECT_TRUE(info_->feature_flags().chromium_path_rendering);
1420   EXPECT_THAT(info_->extensions(), HasSubstr("GL_CHROMIUM_path_rendering"));
1421 }
1422
1423 TEST_P(FeatureInfoTest, InitializeCHROMIUM_path_rendering2) {
1424   SetupInitExpectationsWithGLVersion(
1425       "GL_NV_path_rendering", "", "OpenGL ES 3.1");
1426   EXPECT_TRUE(info_->feature_flags().chromium_path_rendering);
1427   EXPECT_THAT(info_->extensions(), HasSubstr("GL_CHROMIUM_path_rendering"));
1428 }
1429
1430 TEST_P(FeatureInfoTest, InitializeNoCHROMIUM_path_rendering) {
1431   SetupInitExpectationsWithGLVersion("GL_ARB_compatibility", "", "4.3");
1432   EXPECT_FALSE(info_->feature_flags().chromium_path_rendering);
1433   EXPECT_THAT(info_->extensions(),
1434               Not(HasSubstr("GL_CHROMIUM_path_rendering")));
1435 }
1436
1437 TEST_P(FeatureInfoTest, InitializeNoCHROMIUM_path_rendering2) {
1438   SetupInitExpectationsWithGLVersion(
1439       "GL_ARB_compatibility GL_NV_path_rendering", "", "4.3");
1440   EXPECT_FALSE(info_->feature_flags().chromium_path_rendering);
1441   EXPECT_THAT(info_->extensions(),
1442               Not(HasSubstr("GL_CHROMIUM_path_rendering")));
1443 }
1444
1445 TEST_P(FeatureInfoTest, InitializeNoKHR_blend_equation_advanced) {
1446   SetupInitExpectationsWithGLVersion("GL_ARB_compatibility", "", "4.3");
1447   EXPECT_FALSE(info_->feature_flags().blend_equation_advanced);
1448   EXPECT_THAT(info_->extensions(),
1449               Not(HasSubstr("GL_KHR_blend_equation_advanced")));
1450 }
1451
1452 TEST_P(FeatureInfoTest, InitializeKHR_blend_equations_advanced) {
1453   SetupInitExpectations("GL_KHR_blend_equation_advanced");
1454   EXPECT_THAT(info_->extensions(), HasSubstr("GL_KHR_blend_equation_advanced"));
1455   EXPECT_TRUE(info_->feature_flags().blend_equation_advanced);
1456 }
1457
1458 TEST_P(FeatureInfoTest, InitializeNV_blend_equations_advanced) {
1459   SetupInitExpectations("GL_NV_blend_equation_advanced");
1460   EXPECT_THAT(info_->extensions(), HasSubstr("GL_KHR_blend_equation_advanced"));
1461   EXPECT_TRUE(info_->feature_flags().blend_equation_advanced);
1462 }
1463
1464 TEST_P(FeatureInfoTest, InitializeNoKHR_blend_equation_advanced_coherent) {
1465   SetupInitExpectationsWithGLVersion("GL_ARB_compatibility ", "", "4.3");
1466   EXPECT_FALSE(info_->feature_flags().blend_equation_advanced_coherent);
1467   EXPECT_THAT(info_->extensions(),
1468               Not(HasSubstr("GL_KHR_blend_equation_advanced_coherent")));
1469 }
1470
1471 TEST_P(FeatureInfoTest, InitializeKHR_blend_equations_advanced_coherent) {
1472   SetupInitExpectations("GL_KHR_blend_equation_advanced_coherent");
1473   EXPECT_THAT(info_->extensions(),
1474               HasSubstr("GL_KHR_blend_equation_advanced_coherent"));
1475   EXPECT_TRUE(info_->feature_flags().blend_equation_advanced);
1476   EXPECT_TRUE(info_->feature_flags().blend_equation_advanced_coherent);
1477 }
1478
1479 TEST_P(FeatureInfoTest, InitializeEXT_texture_rgWithFloat) {
1480   SetupInitExpectations(
1481       "GL_EXT_texture_rg GL_OES_texture_float GL_OES_texture_half_float");
1482   EXPECT_TRUE(info_->feature_flags().ext_texture_rg);
1483
1484   EXPECT_TRUE(info_->validators()->texture_format.IsValid(GL_RED_EXT));
1485   EXPECT_TRUE(info_->validators()->texture_format.IsValid(GL_RG_EXT));
1486   EXPECT_TRUE(info_->validators()->texture_internal_format.IsValid(GL_RED_EXT));
1487   EXPECT_TRUE(info_->validators()->texture_internal_format.IsValid(GL_RG_EXT));
1488   EXPECT_TRUE(info_->validators()->read_pixel_format.IsValid(GL_RED_EXT));
1489   EXPECT_TRUE(info_->validators()->read_pixel_format.IsValid(GL_RG_EXT));
1490   EXPECT_TRUE(info_->validators()->render_buffer_format.IsValid(GL_R8_EXT));
1491   EXPECT_TRUE(info_->validators()->render_buffer_format.IsValid(GL_RG8_EXT));
1492
1493   EXPECT_TRUE(
1494       info_->GetTextureFormatValidator(GL_RED_EXT).IsValid(GL_HALF_FLOAT_OES));
1495   EXPECT_TRUE(
1496       info_->GetTextureFormatValidator(GL_RG_EXT).IsValid(GL_HALF_FLOAT_OES));
1497   EXPECT_TRUE(
1498       info_->GetTextureFormatValidator(GL_RED_EXT).IsValid(GL_UNSIGNED_BYTE));
1499   EXPECT_TRUE(
1500       info_->GetTextureFormatValidator(GL_RG_EXT).IsValid(GL_UNSIGNED_BYTE));
1501
1502   EXPECT_FALSE(info_->GetTextureFormatValidator(GL_RED_EXT).IsValid(GL_BYTE));
1503   EXPECT_FALSE(info_->GetTextureFormatValidator(GL_RG_EXT).IsValid(GL_BYTE));
1504   EXPECT_FALSE(info_->GetTextureFormatValidator(GL_RED_EXT).IsValid(GL_SHORT));
1505   EXPECT_FALSE(info_->GetTextureFormatValidator(GL_RG_EXT).IsValid(GL_SHORT));
1506 }
1507
1508 TEST_P(FeatureInfoTest, InitializeARB_texture_rgNoFloat) {
1509   SetupInitExpectations("GL_ARB_texture_rg");
1510   EXPECT_TRUE(info_->feature_flags().ext_texture_rg);
1511
1512   EXPECT_TRUE(info_->validators()->texture_format.IsValid(GL_RED_EXT));
1513   EXPECT_TRUE(info_->validators()->texture_format.IsValid(GL_RG_EXT));
1514   EXPECT_TRUE(info_->validators()->texture_internal_format.IsValid(GL_RED_EXT));
1515   EXPECT_TRUE(info_->validators()->texture_internal_format.IsValid(GL_RG_EXT));
1516   EXPECT_TRUE(info_->validators()->read_pixel_format.IsValid(GL_RED_EXT));
1517   EXPECT_TRUE(info_->validators()->read_pixel_format.IsValid(GL_RG_EXT));
1518   EXPECT_TRUE(info_->validators()->render_buffer_format.IsValid(GL_R8_EXT));
1519   EXPECT_TRUE(info_->validators()->render_buffer_format.IsValid(GL_RG8_EXT));
1520
1521   EXPECT_FALSE(
1522       info_->GetTextureFormatValidator(GL_RED_EXT).IsValid(GL_HALF_FLOAT_OES));
1523   EXPECT_FALSE(
1524       info_->GetTextureFormatValidator(GL_RG_EXT).IsValid(GL_HALF_FLOAT_OES));
1525   EXPECT_TRUE(
1526       info_->GetTextureFormatValidator(GL_RED_EXT).IsValid(GL_UNSIGNED_BYTE));
1527   EXPECT_TRUE(
1528       info_->GetTextureFormatValidator(GL_RG_EXT).IsValid(GL_UNSIGNED_BYTE));
1529 }
1530
1531 }  // namespace gles2
1532 }  // namespace gpu