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