Create correct GLES3 context for GLES3 unittest

gpu/command_buffer/service/gles2_cmd_decoder_unittest_textures.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/command_line.h"
@@ skipping 61 matching lines @@
   GenerateMipmap cmd;
   cmd.Init(GL_TEXTURE_2D);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
 TEST_P(GLES2DecoderTest, GenerateMipmapHandlesOutOfMemory) {
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   TextureManager* manager = group().texture_manager();
   TextureRef* texture_ref = manager->GetTexture(client_texture_id_);
-  ASSERT_TRUE(texture_ref != NULL);
+  ASSERT_TRUE(texture_ref != nullptr);
   Texture* texture = texture_ref->texture();
   GLint width = 0;
   GLint height = 0;
   EXPECT_FALSE(
       texture->GetLevelSize(GL_TEXTURE_2D, 2, &width, &height, nullptr));
   DoTexImage2D(GL_TEXTURE_2D,
                0,
                GL_RGBA,
                16,
                16,
@@ skipping 58 matching lines @@
       .RetiresOnSaturation();
   GenerateMipmap cmd;
   cmd.Init(GL_TEXTURE_2D);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 // Same as GenerateMipmapClearsUnclearedTexture, but with workaround
 // |set_texture_filters_before_generating_mipmap|.
 TEST_P(GLES2DecoderManualInitTest, SetTextureFiltersBeforeGenerateMipmap) {
-  base::CommandLine command_line(0, NULL);
+  base::CommandLine command_line(0, nullptr);
   command_line.AppendSwitchASCII(
       switches::kGpuDriverBugWorkarounds,
       base::IntToString(gpu::SET_TEXTURE_FILTER_BEFORE_GENERATING_MIPMAP));
   InitState init;
   init.bind_generates_resource = true;
   InitDecoderWithCommandLine(init, &command_line);
 
   EXPECT_CALL(*gl_, GenerateMipmapEXT(_)).Times(0);
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   DoTexImage2D(
@@ skipping 494 matching lines @@
   GLint level = 0;
   GLenum internal_format = GL_RGBA;
   GLsizei width = 2;
   GLsizei height = 4;
   GLint border = 0;
   GLenum format = GL_RGBA;
   GLenum type = GL_UNSIGNED_BYTE;
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   TextureManager* manager = group().texture_manager();
   TextureRef* texture_ref = manager->GetTexture(client_texture_id_);
-  ASSERT_TRUE(texture_ref != NULL);
+  ASSERT_TRUE(texture_ref != nullptr);
   Texture* texture = texture_ref->texture();
   EXPECT_FALSE(
       texture->GetLevelSize(GL_TEXTURE_2D, level, &width, &height, nullptr));
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_OUT_OF_MEMORY))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_,
               TexImage2D(target,
                          level,
@@ skipping 25 matching lines @@
 TEST_P(GLES2DecoderTest, CopyTexImage2DGLError) {
   GLenum target = GL_TEXTURE_2D;
   GLint level = 0;
   GLenum internal_format = GL_RGBA;
   GLsizei width = 2;
   GLsizei height = 4;
   GLint border = 0;
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   TextureManager* manager = group().texture_manager();
   TextureRef* texture_ref = manager->GetTexture(client_texture_id_);
-  ASSERT_TRUE(texture_ref != NULL);
+  ASSERT_TRUE(texture_ref != nullptr);
   Texture* texture = texture_ref->texture();
   EXPECT_FALSE(
       texture->GetLevelSize(GL_TEXTURE_2D, level, &width, &height, nullptr));
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_OUT_OF_MEMORY))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_,
               CopyTexImage2D(
                   target, level, internal_format, 0, 0, width, height, border))
       .Times(1)
       .RetiresOnSaturation();
   CopyTexImage2D cmd;
   cmd.Init(target, level, internal_format, 0, 0, width, height);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
   EXPECT_FALSE(
       texture->GetLevelSize(GL_TEXTURE_2D, level, &width, &height, nullptr));
 }
 
 TEST_P(GLES2DecoderManualInitTest, CopyTexImage2DUnsizedInternalFormat) {
-  base::CommandLine command_line(0, NULL);
+  base::CommandLine command_line(0, nullptr);
   command_line.AppendSwitch(switches::kEnableUnsafeES3APIs);
   InitState init;
   init.gl_version = "OpenGL ES 3.0";
   init.extensions = "GL_APPLE_texture_format_BGRA8888 GL_EXT_sRGB";
   init.has_alpha = true;
   init.request_alpha = true;
   init.bind_generates_resource = true;
   init.context_type = CONTEXT_TYPE_OPENGLES2;
   InitDecoderWithCommandLine(init, &command_line);
 
@@ skipping 70 matching lines @@
     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
     if (complete) {
       EXPECT_EQ(GL_NO_ERROR, GetGLError());
     } else {
       EXPECT_EQ(GL_INVALID_FRAMEBUFFER_OPERATION, GetGLError());
     }
   }
 }
 
 TEST_P(GLES2DecoderManualInitTest, CopyTexImage2DUnsizedInternalFormatES3) {
-  base::CommandLine command_line(0, NULL);
+  base::CommandLine command_line(0, nullptr);
   command_line.AppendSwitch(switches::kEnableUnsafeES3APIs);
   InitState init;
   init.gl_version = "OpenGL ES 3.0";
   init.extensions = "GL_APPLE_texture_format_BGRA8888";
   init.has_alpha = true;
   init.request_alpha = true;
   init.bind_generates_resource = true;
   init.context_type = CONTEXT_TYPE_OPENGLES3;
   InitDecoderWithCommandLine(init, &command_line);
 
@@ skipping 87 matching lines @@
   const uint32_t kBucketId = 123;
   const uint32_t kBadBucketId = 99;
   const GLenum kTarget = GL_TEXTURE_2D_ARRAY;
   const GLint kLevel = 0;
   const GLenum kInternalFormat = GL_COMPRESSED_R11_EAC;
   const GLsizei kWidth = 4;
   const GLsizei kHeight = 4;
   const GLsizei kDepth = 4;
   const GLint kBorder = 0;
   CommonDecoder::Bucket* bucket = decoder_->CreateBucket(kBucketId);
-  ASSERT_TRUE(bucket != NULL);
+  ASSERT_TRUE(bucket != nullptr);
   const GLsizei kImageSize = 32;
   bucket->SetSize(kImageSize);
 
   DoBindTexture(kTarget, client_texture_id_, kServiceTextureId);
 
   CompressedTexImage3DBucket cmd;
   cmd.Init(kTarget,
            kLevel,
            kInternalFormat,
            kWidth,
@@ skipping 26 matching lines @@
   const uint32_t kBucketId = 123;
   const uint32_t kBadBucketId = 99;
   const GLenum kTarget = GL_TEXTURE_2D_ARRAY;
   const GLint kLevel = 0;
   const GLenum kInternalFormat = GL_COMPRESSED_R11_EAC;
   const GLsizei kWidth = 4;
   const GLsizei kHeight = 4;
   const GLsizei kDepth = 4;
   const GLint kBorder = 0;
   CommonDecoder::Bucket* bucket = decoder_->CreateBucket(kBucketId);
-  ASSERT_TRUE(bucket != NULL);
+  ASSERT_TRUE(bucket != nullptr);
   const GLsizei kImageSize = 0;
   bucket->SetSize(kImageSize);
 
   DoBindTexture(kTarget, client_texture_id_, kServiceTextureId);
 
   // Bad bucket
   CompressedTexImage3DBucket cmd;
   cmd.Init(kTarget,
            kLevel,
            kInternalFormat,
@@ skipping 37 matching lines @@
 
 TEST_P(GLES2DecoderTest, CompressedTexImage3DFailsOnES2) {
   const uint32_t kBucketId = 123;
   const GLenum kTarget = GL_TEXTURE_2D_ARRAY;
   const GLint kLevel = 0;
   const GLenum kInternalFormat = GL_COMPRESSED_R11_EAC;
   const GLsizei kWidth = 4;
   const GLsizei kHeight = 4;
   const GLsizei kDepth = 4;
   CommonDecoder::Bucket* bucket = decoder_->CreateBucket(kBucketId);
-  ASSERT_TRUE(bucket != NULL);
+  ASSERT_TRUE(bucket != nullptr);
   const GLsizei kImageSize = 32;
   bucket->SetSize(kImageSize);
 
   {
     CompressedTexImage3DBucket cmd;
     cmd.Init(kTarget,
              kLevel,
              kInternalFormat,
              kWidth,
              kHeight,
@@ skipping 323 matching lines @@
   const GLsizei kDepth = 2;
   const GLenum kFormat = GL_RGB;
   const GLenum kType = GL_UNSIGNED_BYTE;
   const uint32_t kBufferSize = kWidth * kHeight * kDepth * 4;
 
   DoBindTexture(kTarget, client_texture_id_, kServiceTextureId);
   DoTexImage3D(kTarget, kLevel, kInternalFormat, kWidth, kHeight, kDepth, 0,
                kFormat, kType, 0, 0);
   TextureRef* texture_ref =
       group().texture_manager()->GetTexture(client_texture_id_);
-  ASSERT_TRUE(texture_ref != NULL);
+  ASSERT_TRUE(texture_ref != nullptr);
   Texture* texture = texture_ref->texture();
 
   EXPECT_FALSE(texture->SafeToRenderFrom());
   EXPECT_FALSE(texture->IsLevelCleared(kTarget, kLevel));
 
   // CopyTexSubImage3D will clear the uncleared texture
   EXPECT_CALL(*gl_, GenBuffersARB(1, _))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, BindBuffer(GL_PIXEL_UNPACK_BUFFER, _))
@@ skipping 39 matching lines @@
 
 TEST_P(GLES3DecoderTest, CompressedTexImage3DFailsWithBadImageSize) {
   const uint32_t kBucketId = 123;
   const GLenum kTarget = GL_TEXTURE_2D_ARRAY;
   const GLint kLevel = 0;
   const GLenum kInternalFormat = GL_COMPRESSED_RGBA8_ETC2_EAC;
   const GLsizei kWidth = 4;
   const GLsizei kHeight = 8;
   const GLsizei kDepth = 4;
   CommonDecoder::Bucket* bucket = decoder_->CreateBucket(kBucketId);
-  ASSERT_TRUE(bucket != NULL);
+  ASSERT_TRUE(bucket != nullptr);
   const GLsizei kBadImageSize = 64;
   bucket->SetSize(kBadImageSize);
 
   DoBindTexture(kTarget, client_texture_id_, kServiceTextureId);
 
   CompressedTexImage3DBucket cmd;
   cmd.Init(kTarget,
            kLevel,
            kInternalFormat,
            kWidth,
            kHeight,
            kDepth,
            kBucketId);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
 TEST_P(GLES3DecoderTest, CompressedTexSubImage3DFails) {
   const uint32_t kBucketId = 123;
   const GLenum kTarget = GL_TEXTURE_2D_ARRAY;
   const GLint kLevel = 0;
   const GLenum kInternalFormat = GL_COMPRESSED_RGBA8_ETC2_EAC;
   const GLsizei kWidth = 4;
   const GLsizei kHeight = 8;
   const GLsizei kDepth = 4;
   const GLint kBorder = 0;
   CommonDecoder::Bucket* bucket = decoder_->CreateBucket(kBucketId);
-  ASSERT_TRUE(bucket != NULL);
+  ASSERT_TRUE(bucket != nullptr);
   const GLsizei kImageSize = 128;
   bucket->SetSize(kImageSize);
 
   DoBindTexture(kTarget, client_texture_id_, kServiceTextureId);
 
   CompressedTexImage3DBucket tex_cmd;
   tex_cmd.Init(kTarget,
                kLevel,
                kInternalFormat,
                kWidth,
@@ skipping 164 matching lines @@
 TEST_P(GLES3DecoderTest, CompressedTexImage2DBucketBucketSizeIsZero) {
   const uint32_t kBucketId = 123;
   const uint32_t kBadBucketId = 99;
   const GLenum kTarget = GL_TEXTURE_2D;
   const GLint kLevel = 0;
   const GLenum kInternalFormat = GL_COMPRESSED_R11_EAC;
   const GLsizei kWidth = 4;
   const GLsizei kHeight = 4;
   const GLint kBorder = 0;
   CommonDecoder::Bucket* bucket = decoder_->CreateBucket(kBucketId);
-  ASSERT_TRUE(bucket != NULL);
+  ASSERT_TRUE(bucket != nullptr);
   const GLsizei kImageSize = 0;
   bucket->SetSize(kImageSize);
 
   DoBindTexture(kTarget, client_texture_id_, kServiceTextureId);
 
   // Bad bucket
   CompressedTexImage2DBucket cmd;
   cmd.Init(kTarget,
            kLevel,
            kInternalFormat,
@@ skipping 70 matching lines @@
 }  // anonymous namespace.
 
 TEST_P(GLES2DecoderManualInitTest, CompressedTexImage2DS3TCWebGL) {
   InitState init;
   init.extensions = "GL_EXT_texture_compression_s3tc";
   init.bind_generates_resource = true;
   init.context_type = CONTEXT_TYPE_WEBGL1;
   InitDecoder(init);
   const uint32_t kBucketId = 123;
   CommonDecoder::Bucket* bucket = decoder_->CreateBucket(kBucketId);
-  ASSERT_TRUE(bucket != NULL);
+  ASSERT_TRUE(bucket != nullptr);
 
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
 
   static const S3TCTestData test_data[] = {
       {
        GL_COMPRESSED_RGB_S3TC_DXT1_EXT, 8,
       },
       {
        GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, 8,
       },
@@ skipping 136 matching lines @@
   }
 }
 
 TEST_P(GLES2DecoderManualInitTest, CompressedTexImage2DS3TC) {
   InitState init;
   init.extensions = "GL_EXT_texture_compression_s3tc";
   init.bind_generates_resource = true;
   InitDecoder(init);
   const uint32_t kBucketId = 123;
   CommonDecoder::Bucket* bucket = decoder_->CreateBucket(kBucketId);
-  ASSERT_TRUE(bucket != NULL);
+  ASSERT_TRUE(bucket != nullptr);
 
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
 
   static const S3TCTestData test_data[] = {
       {
        GL_COMPRESSED_RGB_S3TC_DXT1_EXT, 8,
       },
       {
        GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, 8,
       },
@@ skipping 250 matching lines @@
 
   // Test CompressedTexSubImage not allowed
   CompressedTexSubImage2DBucket sub_cmd;
   bucket->SetSize(kBlockSize);
   sub_cmd.Init(GL_TEXTURE_2D, 0, 0, 0, 4, 4, kFormat, kBucketId);
   EXPECT_EQ(error::kNoError, ExecuteCmd(sub_cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 
   // Test TexSubImage not allowed for ETC1 compressed texture
   TextureRef* texture_ref = GetTexture(client_texture_id_);
-  ASSERT_TRUE(texture_ref != NULL);
+  ASSERT_TRUE(texture_ref != nullptr);
   Texture* texture = texture_ref->texture();
   GLenum type, internal_format;
   EXPECT_TRUE(texture->GetLevelType(GL_TEXTURE_2D, 0, &type, &internal_format));
   EXPECT_EQ(kFormat, internal_format);
   TexSubImage2D texsub_cmd;
   texsub_cmd.Init(GL_TEXTURE_2D,
                   0,
                   0,
                   0,
                   4,
@@ skipping 22 matching lines @@
   init.bind_generates_resource = true;
   InitDecoder(init);
   EXPECT_CALL(*gl_, BindTexture(GL_TEXTURE_EXTERNAL_OES, kNewServiceId));
   EXPECT_CALL(*gl_, GenTextures(1, _))
       .WillOnce(SetArgumentPointee<1>(kNewServiceId));
   BindTexture cmd;
   cmd.Init(GL_TEXTURE_EXTERNAL_OES, kNewClientId);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   TextureRef* texture_ref = GetTexture(kNewClientId);
-  EXPECT_TRUE(texture_ref != NULL);
+  EXPECT_TRUE(texture_ref != nullptr);
   EXPECT_TRUE(texture_ref->texture()->target() == GL_TEXTURE_EXTERNAL_OES);
 }
 
 TEST_P(GLES2DecoderManualInitTest, EGLImageExternalGetBinding) {
   InitState init;
   init.extensions = "GL_OES_EGL_image_external";
   init.gl_version = "opengl es 2.0";
   init.bind_generates_resource = true;
   InitDecoder(init);
   DoBindTexture(GL_TEXTURE_EXTERNAL_OES, client_texture_id_, kServiceTextureId);
@@ skipping 22 matching lines @@
 
 TEST_P(GLES2DecoderManualInitTest, EGLImageExternalTextureDefaults) {
   InitState init;
   init.extensions = "GL_OES_EGL_image_external";
   init.gl_version = "opengl es 2.0";
   init.bind_generates_resource = true;
   InitDecoder(init);
   DoBindTexture(GL_TEXTURE_EXTERNAL_OES, client_texture_id_, kServiceTextureId);
 
   TextureRef* texture_ref = GetTexture(client_texture_id_);
-  EXPECT_TRUE(texture_ref != NULL);
+  EXPECT_TRUE(texture_ref != nullptr);
   Texture* texture = texture_ref->texture();
   EXPECT_TRUE(texture->target() == GL_TEXTURE_EXTERNAL_OES);
   EXPECT_TRUE(texture->min_filter() == GL_LINEAR);
   EXPECT_TRUE(texture->wrap_s() == GL_CLAMP_TO_EDGE);
   EXPECT_TRUE(texture->wrap_t() == GL_CLAMP_TO_EDGE);
 }
 
 TEST_P(GLES2DecoderManualInitTest, EGLImageExternalTextureParam) {
   InitState init;
   init.extensions = "GL_OES_EGL_image_external";
@@ skipping 27 matching lines @@
 
   cmd.Init(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
   cmd.Init(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
   TextureRef* texture_ref = GetTexture(client_texture_id_);
-  EXPECT_TRUE(texture_ref != NULL);
+  EXPECT_TRUE(texture_ref != nullptr);
   Texture* texture = texture_ref->texture();
   EXPECT_TRUE(texture->target() == GL_TEXTURE_EXTERNAL_OES);
   EXPECT_TRUE(texture->min_filter() == GL_LINEAR);
   EXPECT_TRUE(texture->wrap_s() == GL_CLAMP_TO_EDGE);
   EXPECT_TRUE(texture->wrap_t() == GL_CLAMP_TO_EDGE);
 }
 
 TEST_P(GLES2DecoderManualInitTest, EGLImageExternalTextureParamInvalid) {
   InitState init;
   init.extensions = "GL_OES_EGL_image_external";
@@ skipping 11 matching lines @@
 
   cmd.Init(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_S, GL_REPEAT);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 
   cmd.Init(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_T, GL_REPEAT);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 
   TextureRef* texture_ref = GetTexture(client_texture_id_);
-  EXPECT_TRUE(texture_ref != NULL);
+  EXPECT_TRUE(texture_ref != nullptr);
   Texture* texture = texture_ref->texture();
   EXPECT_TRUE(texture->target() == GL_TEXTURE_EXTERNAL_OES);
   EXPECT_TRUE(texture->min_filter() == GL_LINEAR);
   EXPECT_TRUE(texture->wrap_s() == GL_CLAMP_TO_EDGE);
   EXPECT_TRUE(texture->wrap_t() == GL_CLAMP_TO_EDGE);
 }
 
 TEST_P(GLES2DecoderManualInitTest, EGLImageExternalTexImage2DError) {
   InitState init;
   init.extensions = "GL_OES_EGL_image_external";
   init.gl_version = "opengl es 2.0";
   init.bind_generates_resource = true;
   InitDecoder(init);
 
   GLenum target = GL_TEXTURE_EXTERNAL_OES;
   GLint level = 0;
   GLenum internal_format = GL_RGBA;
   GLsizei width = 2;
   GLsizei height = 4;
   GLenum format = GL_RGBA;
   GLenum type = GL_UNSIGNED_BYTE;
   DoBindTexture(GL_TEXTURE_EXTERNAL_OES, client_texture_id_, kServiceTextureId);
-  ASSERT_TRUE(GetTexture(client_texture_id_) != NULL);
+  ASSERT_TRUE(GetTexture(client_texture_id_) != nullptr);
   TexImage2D cmd;
   cmd.Init(target,
            level,
            internal_format,
            width,
            height,
            format,
            type,
            kSharedMemoryId,
            kSharedMemoryOffset);
@@ skipping 238 matching lines @@
   init.bind_generates_resource = true;
   InitDecoder(init);
   EXPECT_CALL(*gl_, BindTexture(GL_TEXTURE_RECTANGLE_ARB, kNewServiceId));
   EXPECT_CALL(*gl_, GenTextures(1, _))
       .WillOnce(SetArgumentPointee<1>(kNewServiceId));
   BindTexture cmd;
   cmd.Init(GL_TEXTURE_RECTANGLE_ARB, kNewClientId);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   Texture* texture = GetTexture(kNewClientId)->texture();
-  EXPECT_TRUE(texture != NULL);
+  EXPECT_TRUE(texture != nullptr);
   EXPECT_TRUE(texture->target() == GL_TEXTURE_RECTANGLE_ARB);
 }
 
 TEST_P(GLES2DecoderManualInitTest, ARBTextureRectangleGetBinding) {
   InitState init;
   init.extensions = "GL_ARB_texture_rectangle";
   init.bind_generates_resource = true;
   InitDecoder(init);
   DoBindTexture(
       GL_TEXTURE_RECTANGLE_ARB, client_texture_id_, kServiceTextureId);
@@ skipping 22 matching lines @@
 
 TEST_P(GLES2DecoderManualInitTest, ARBTextureRectangleTextureDefaults) {
   InitState init;
   init.extensions = "GL_ARB_texture_rectangle";
   init.bind_generates_resource = true;
   InitDecoder(init);
   DoBindTexture(
       GL_TEXTURE_RECTANGLE_ARB, client_texture_id_, kServiceTextureId);
 
   Texture* texture = GetTexture(client_texture_id_)->texture();
-  EXPECT_TRUE(texture != NULL);
+  EXPECT_TRUE(texture != nullptr);
   EXPECT_TRUE(texture->target() == GL_TEXTURE_RECTANGLE_ARB);
   EXPECT_TRUE(texture->min_filter() == GL_LINEAR);
   EXPECT_TRUE(texture->wrap_s() == GL_CLAMP_TO_EDGE);
   EXPECT_TRUE(texture->wrap_t() == GL_CLAMP_TO_EDGE);
 }
 
 TEST_P(GLES2DecoderManualInitTest, ARBTextureRectangleTextureParam) {
   InitState init;
   init.extensions = "GL_ARB_texture_rectangle";
   init.bind_generates_resource = true;
@@ skipping 27 matching lines @@
 
   cmd.Init(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
   cmd.Init(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
   Texture* texture = GetTexture(client_texture_id_)->texture();
-  EXPECT_TRUE(texture != NULL);
+  EXPECT_TRUE(texture != nullptr);
   EXPECT_TRUE(texture->target() == GL_TEXTURE_RECTANGLE_ARB);
   EXPECT_TRUE(texture->min_filter() == GL_LINEAR);
   EXPECT_TRUE(texture->wrap_s() == GL_CLAMP_TO_EDGE);
   EXPECT_TRUE(texture->wrap_t() == GL_CLAMP_TO_EDGE);
 }
 
 TEST_P(GLES2DecoderManualInitTest, ARBTextureRectangleTextureParamInvalid) {
   InitState init;
   init.extensions = "GL_ARB_texture_rectangle";
   init.bind_generates_resource = true;
@@ skipping 11 matching lines @@
 
   cmd.Init(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_REPEAT);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 
   cmd.Init(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_REPEAT);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 
   Texture* texture = GetTexture(client_texture_id_)->texture();
-  EXPECT_TRUE(texture != NULL);
+  EXPECT_TRUE(texture != nullptr);
   EXPECT_TRUE(texture->target() == GL_TEXTURE_RECTANGLE_ARB);
   EXPECT_TRUE(texture->min_filter() == GL_LINEAR);
   EXPECT_TRUE(texture->wrap_s() == GL_CLAMP_TO_EDGE);
   EXPECT_TRUE(texture->wrap_t() == GL_CLAMP_TO_EDGE);
 }
 
 TEST_P(GLES2DecoderManualInitTest, ARBTextureRectangleTexImage2D) {
   InitState init;
   init.extensions = "GL_ARB_texture_rectangle";
   init.bind_generates_resource = true;
   InitDecoder(init);
 
   GLenum target = GL_TEXTURE_RECTANGLE_ARB;
   GLint level = 0;
   GLenum internal_format = GL_RGBA;
   GLsizei width = 2;
   GLsizei height = 4;
   GLenum format = GL_RGBA;
   GLenum type = GL_UNSIGNED_BYTE;
 
   DoBindTexture(
       GL_TEXTURE_RECTANGLE_ARB, client_texture_id_, kServiceTextureId);
-  ASSERT_TRUE(GetTexture(client_texture_id_) != NULL);
+  ASSERT_TRUE(GetTexture(client_texture_id_) != nullptr);
 
   TexImage2D cmd;
   cmd.Init(target,
            level,
            internal_format,
            width,
            height,
            format,
            type,
            kSharedMemoryId,
@@ skipping 12 matching lines @@
   GLenum target = GL_TEXTURE_RECTANGLE_ARB;
   GLint level = 1;
   GLenum internal_format = GL_RGBA;
   GLsizei width = 2;
   GLsizei height = 4;
   GLenum format = GL_RGBA;
   GLenum type = GL_UNSIGNED_BYTE;
 
   DoBindTexture(
       GL_TEXTURE_RECTANGLE_ARB, client_texture_id_, kServiceTextureId);
-  ASSERT_TRUE(GetTexture(client_texture_id_) != NULL);
+  ASSERT_TRUE(GetTexture(client_texture_id_) != nullptr);
 
   TexImage2D cmd;
   cmd.Init(target,
            level,
            internal_format,
            width,
            height,
            format,
            type,
            kSharedMemoryId,
@@ skipping 88 matching lines @@
                             GL_UNSIGNED_BYTE,
                             shared_memory_address_))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
 TEST_P(
     GLES2DecoderManualInitTest,
     TexSubImage2DDoesNotClearAfterTexImage2DNULLThenDataWithTexImage2DIsFaster) {
-  base::CommandLine command_line(0, NULL);
+  base::CommandLine command_line(0, nullptr);
   command_line.AppendSwitchASCII(
       switches::kGpuDriverBugWorkarounds,
       base::IntToString(gpu::TEXSUBIMAGE_FASTER_THAN_TEXIMAGE));
   InitState init;
   init.bind_generates_resource = true;
   InitDecoderWithCommandLine(init, &command_line);
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   DoTexImage2D(
       GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0);
 
@@ skipping 93 matching lines @@
   cmd.Init(GL_TEXTURE_2D, 0, 0, 1, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE,
            kSharedMemoryId, kSharedMemoryOffset, GL_FALSE);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
 TEST_P(GLES2DecoderTest, CopyTexImage2DMarksTextureAsCleared) {
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
 
   TextureManager* manager = group().texture_manager();
   TextureRef* texture_ref = manager->GetTexture(client_texture_id_);
-  ASSERT_TRUE(texture_ref != NULL);
+  ASSERT_TRUE(texture_ref != nullptr);
   Texture* texture = texture_ref->texture();
 
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, CopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 0, 0, 1, 1, 0))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
@@ skipping 25 matching lines @@
     EXPECT_CALL(*gl_, CopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 1, 0, 0, 2, 1))
         .Times(1)
         .RetiresOnSaturation();
     CopyTexSubImage2D cmd;
     cmd.Init(GL_TEXTURE_2D, 0, 0, 1, 0, 0, 2, 1);
     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   }
 
   TextureManager* manager = group().texture_manager();
   TextureRef* texture_ref = manager->GetTexture(client_texture_id_);
-  ASSERT_TRUE(texture_ref != NULL);
+  ASSERT_TRUE(texture_ref != nullptr);
   Texture* texture = texture_ref->texture();
   EXPECT_TRUE(texture->SafeToRenderFrom());
 }
 
 TEST_P(GLES2DecoderTest, CopyTexSubImage2DTwiceClearsUnclearedTexture) {
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0,
                0);
 
   // This will initialize the top part.
@@ skipping 16 matching lines @@
     EXPECT_CALL(*gl_, CopyTexSubImage2D(GL_TEXTURE_2D, 0, 1, 1, 0, 0, 1, 1))
         .Times(1)
         .RetiresOnSaturation();
     CopyTexSubImage2D cmd;
     cmd.Init(GL_TEXTURE_2D, 0, 1, 1, 0, 0, 1, 1);
     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   }
 
   TextureManager* manager = group().texture_manager();
   TextureRef* texture_ref = manager->GetTexture(client_texture_id_);
-  ASSERT_TRUE(texture_ref != NULL);
+  ASSERT_TRUE(texture_ref != nullptr);
   Texture* texture = texture_ref->texture();
   EXPECT_TRUE(texture->SafeToRenderFrom());
 }
 
 TEST_P(GLES2DecoderTest, CopyTexSubImage2DClearsUnclearedBackBufferSizedTexture) {
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, kBackBufferWidth, kBackBufferHeight,
                0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0);
 
   EXPECT_CALL(*gl_, CopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0,
                                       kBackBufferWidth, kBackBufferHeight))
       .Times(1)
       .RetiresOnSaturation();
   CopyTexSubImage2D cmd;
   cmd.Init(GL_TEXTURE_2D, 0, 0, 0, 0, 0, kBackBufferWidth, kBackBufferHeight);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 
   TextureManager* manager = group().texture_manager();
   TextureRef* texture_ref = manager->GetTexture(client_texture_id_);
-  ASSERT_TRUE(texture_ref != NULL);
+  ASSERT_TRUE(texture_ref != nullptr);
   Texture* texture = texture_ref->texture();
   EXPECT_TRUE(texture->SafeToRenderFrom());
 }
 
 TEST_P(GLES2DecoderManualInitTest, CompressedImage2DMarksTextureAsCleared) {
   InitState init;
   init.extensions = "GL_EXT_texture_compression_s3tc";
   init.bind_generates_resource = true;
   InitDecoder(init);
 
@@ skipping 38 matching lines @@
 TEST_P(GLES2DecoderTest, ProduceAndConsumeTextureCHROMIUM) {
   Mailbox mailbox = Mailbox::Generate();
 
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   DoTexImage2D(
       GL_TEXTURE_2D, 0, GL_RGBA, 3, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0);
   DoTexImage2D(
       GL_TEXTURE_2D, 1, GL_RGBA, 2, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0);
   TextureRef* texture_ref =
       group().texture_manager()->GetTexture(client_texture_id_);
-  ASSERT_TRUE(texture_ref != NULL);
+  ASSERT_TRUE(texture_ref != nullptr);
   Texture* texture = texture_ref->texture();
   EXPECT_EQ(kServiceTextureId, texture->service_id());
 
   ProduceTextureCHROMIUMImmediate& produce_cmd =
       *GetImmediateAs<ProduceTextureCHROMIUMImmediate>();
   produce_cmd.Init(GL_TEXTURE_2D, mailbox.name);
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(produce_cmd, sizeof(mailbox.name)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
@@ skipping 68 matching lines @@
 TEST_P(GLES2DecoderTest, ProduceAndConsumeDirectTextureCHROMIUM) {
   Mailbox mailbox = Mailbox::Generate();
 
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   DoTexImage2D(
       GL_TEXTURE_2D, 0, GL_RGBA, 3, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0);
   DoTexImage2D(
       GL_TEXTURE_2D, 1, GL_RGBA, 2, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0);
   TextureRef* texture_ref =
       group().texture_manager()->GetTexture(client_texture_id_);
-  ASSERT_TRUE(texture_ref != NULL);
+  ASSERT_TRUE(texture_ref != nullptr);
   Texture* texture = texture_ref->texture();
   EXPECT_EQ(kServiceTextureId, texture->service_id());
 
   ProduceTextureDirectCHROMIUMImmediate& produce_cmd =
       *GetImmediateAs<ProduceTextureDirectCHROMIUMImmediate>();
   produce_cmd.Init(client_texture_id_, GL_TEXTURE_2D, mailbox.name);
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(produce_cmd, sizeof(mailbox.name)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
@@ skipping 26 matching lines @@
   GLuint new_texture_id = kNewClientId;
   CreateAndConsumeTextureINTERNALImmediate& consume_cmd =
       *GetImmediateAs<CreateAndConsumeTextureINTERNALImmediate>();
   consume_cmd.Init(GL_TEXTURE_2D, new_texture_id, mailbox.name);
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(consume_cmd, sizeof(mailbox.name)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
   // Make sure the new client ID is associated with the produced service ID.
   texture_ref = group().texture_manager()->GetTexture(new_texture_id);
-  ASSERT_TRUE(texture_ref != NULL);
+  ASSERT_TRUE(texture_ref != nullptr);
   texture = texture_ref->texture();
   EXPECT_EQ(kServiceTextureId, texture->service_id());
 
   DoBindTexture(GL_TEXTURE_2D, kNewClientId, kServiceTextureId);
 
   // Texture is redefined.
   EXPECT_TRUE(
       texture->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height, nullptr));
   EXPECT_EQ(3, width);
   EXPECT_EQ(1, height);
@@ skipping 12 matching lines @@
 
 TEST_P(GLES2DecoderTest, ProduceTextureCHROMIUMInvalidTarget) {
   Mailbox mailbox = Mailbox::Generate();
 
   DoBindTexture(GL_TEXTURE_CUBE_MAP, client_texture_id_, kServiceTextureId);
   DoTexImage2D(
       GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGBA, 3, 1, 0, GL_RGBA,
       GL_UNSIGNED_BYTE, 0, 0);
   TextureRef* texture_ref =
       group().texture_manager()->GetTexture(client_texture_id_);
-  ASSERT_TRUE(texture_ref != NULL);
+  ASSERT_TRUE(texture_ref != nullptr);
   Texture* texture = texture_ref->texture();
   EXPECT_EQ(kServiceTextureId, texture->service_id());
 
   ProduceTextureDirectCHROMIUMImmediate& produce_cmd =
       *GetImmediateAs<ProduceTextureDirectCHROMIUMImmediate>();
   produce_cmd.Init(client_texture_id_, GL_TEXTURE_2D, mailbox.name);
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(produce_cmd, sizeof(mailbox.name)));
 
   // ProduceTexture should fail it the texture and produce targets don't match.
@@ skipping 22 matching lines @@
             ExecuteImmediateCmd(consume_cmd, sizeof(mailbox.name)));
 
   // CreateAndConsumeTexture should fail if the mailbox isn't associated with a
   // texture.
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 
   // Make sure the new client_id is associated with a texture ref even though
   // CreateAndConsumeTexture failed.
   TextureRef* texture_ref =
       group().texture_manager()->GetTexture(new_texture_id);
-  ASSERT_TRUE(texture_ref != NULL);
+  ASSERT_TRUE(texture_ref != nullptr);
   Texture* texture = texture_ref->texture();
   // New texture should have the correct target type.
   EXPECT_TRUE(texture->target() == GL_TEXTURE_2D);
   // New texture should have a valid service_id.
   EXPECT_EQ(kNewServiceId, texture->service_id());
 }
 
 TEST_P(GLES2DecoderTest, CreateAndConsumeTextureCHROMIUMInvalidTarget) {
   Mailbox mailbox = Mailbox::Generate();
 
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   TextureRef* texture_ref =
       group().texture_manager()->GetTexture(client_texture_id_);
-  ASSERT_TRUE(texture_ref != NULL);
+  ASSERT_TRUE(texture_ref != nullptr);
 
   ProduceTextureDirectCHROMIUMImmediate& produce_cmd =
       *GetImmediateAs<ProduceTextureDirectCHROMIUMImmediate>();
   produce_cmd.Init(client_texture_id_, GL_TEXTURE_2D, mailbox.name);
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(produce_cmd, sizeof(mailbox.name)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
   EXPECT_CALL(*gl_, GenTextures(1, _))
         .WillOnce(SetArgumentPointee<1>(kNewServiceId))
@@ skipping 13 matching lines @@
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(consume_cmd, sizeof(mailbox.name)));
 
   // CreateAndConsumeTexture should fail if the produced texture had a different
   // target.
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 
   // Make sure the new client_id is associated with a texture ref even though
   // CreateAndConsumeTexture failed.
   texture_ref = group().texture_manager()->GetTexture(new_texture_id);
-  ASSERT_TRUE(texture_ref != NULL);
+  ASSERT_TRUE(texture_ref != nullptr);
   Texture* texture = texture_ref->texture();
   // New texture should have the correct target type.
   EXPECT_TRUE(texture->target() == GL_TEXTURE_CUBE_MAP);
   // New texture should have a valid service_id.
   EXPECT_EQ(kNewServiceId, texture->service_id());
 
   // Make sure the client_id did not become associated with the produced texture
   // service_id.
   EXPECT_NE(kServiceTextureId, texture->service_id());
 }
@@ skipping 103 matching lines @@
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
 TEST_P(GLES2DecoderTest, BindTexImage2DCHROMIUM) {
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   DoTexImage2D(
       GL_TEXTURE_2D, 0, GL_RGBA, 3, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0);
   TextureRef* texture_ref =
       group().texture_manager()->GetTexture(client_texture_id_);
-  ASSERT_TRUE(texture_ref != NULL);
+  ASSERT_TRUE(texture_ref != nullptr);
   Texture* texture = texture_ref->texture();
   EXPECT_EQ(kServiceTextureId, texture->service_id());
 
   scoped_refptr<gl::GLImage> image(new gl::GLImageStub);
   GetImageManager()->AddImage(image.get(), 1);
-  EXPECT_FALSE(GetImageManager()->LookupImage(1) == NULL);
+  EXPECT_FALSE(GetImageManager()->LookupImage(1) == nullptr);
 
   GLsizei width;
   GLsizei height;
   GLenum type;
   GLenum internal_format;
 
   EXPECT_TRUE(
       texture->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height, nullptr));
   EXPECT_EQ(3, width);
   EXPECT_EQ(1, height);
   EXPECT_TRUE(texture->GetLevelType(GL_TEXTURE_2D, 0, &type, &internal_format));
   EXPECT_EQ(static_cast<GLenum>(GL_RGBA), internal_format);
   EXPECT_EQ(static_cast<GLenum>(GL_UNSIGNED_BYTE), type);
-  EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 0) == NULL);
+  EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 0) == nullptr);
 
   // Bind image to texture.
   // ScopedGLErrorSuppressor calls GetError on its constructor and destructor.
   DoBindTexImage2DCHROMIUM(GL_TEXTURE_2D, 1);
   EXPECT_TRUE(
       texture->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height, nullptr));
   // Image should now be set.
-  EXPECT_FALSE(texture->GetLevelImage(GL_TEXTURE_2D, 0) == NULL);
+  EXPECT_FALSE(texture->GetLevelImage(GL_TEXTURE_2D, 0) == nullptr);
 
   // Define new texture image.
   DoTexImage2D(
       GL_TEXTURE_2D, 0, GL_RGBA, 3, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0);
   EXPECT_TRUE(
       texture->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height, nullptr));
   // Image should no longer be set.
-  EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 0) == NULL);
+  EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 0) == nullptr);
 }
 
 TEST_P(GLES2DecoderTest, BindTexImage2DCHROMIUMCubeMapNotAllowed) {
   scoped_refptr<gl::GLImage> image(new gl::GLImageStub);
   GetImageManager()->AddImage(image.get(), 1);
   DoBindTexture(GL_TEXTURE_CUBE_MAP, client_texture_id_, kServiceTextureId);
 
   BindTexImage2DCHROMIUM bind_tex_image_2d_cmd;
   bind_tex_image_2d_cmd.Init(GL_TEXTURE_CUBE_MAP, 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(bind_tex_image_2d_cmd));
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
 TEST_P(GLES2DecoderTest, OrphanGLImageWithTexImage2D) {
   scoped_refptr<gl::GLImage> image(new gl::GLImageStub);
   GetImageManager()->AddImage(image.get(), 1);
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
 
   DoBindTexImage2DCHROMIUM(GL_TEXTURE_2D, 1);
 
   TextureRef* texture_ref =
       group().texture_manager()->GetTexture(client_texture_id_);
-  ASSERT_TRUE(texture_ref != NULL);
+  ASSERT_TRUE(texture_ref != nullptr);
   Texture* texture = texture_ref->texture();
 
   EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 0) == image.get());
   DoTexImage2D(
       GL_TEXTURE_2D, 0, GL_RGBA, 3, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0);
-  EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 0) == NULL);
+  EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 0) == nullptr);
 }
 
 TEST_P(GLES2DecoderTest, GLImageAttachedAfterSubTexImage2D) {
   // Specifically tests that TexSubImage2D is not optimized to TexImage2D
   // in the presence of image attachments.
   ASSERT_FALSE(
       feature_info()->workarounds().texsubimage_faster_than_teximage);
 
   scoped_refptr<gl::GLImage> image(new gl::GLImageStub);
   GetImageManager()->AddImage(image.get(), 1);
@@ skipping 15 matching lines @@
   // Define texture first.
   DoTexImage2D(target, level, format, width, height, border, format, type,
                pixels_shm_id, pixels_shm_offset);
 
   // Bind texture to GLImage.
   DoBindTexImage2DCHROMIUM(GL_TEXTURE_2D, 1);
 
   // Check binding.
   TextureRef* texture_ref =
       group().texture_manager()->GetTexture(client_texture_id_);
-  ASSERT_TRUE(texture_ref != NULL);
+  ASSERT_TRUE(texture_ref != nullptr);
   Texture* texture = texture_ref->texture();
   EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 0) == image.get());
 
   // TexSubImage2D should not unbind GLImage.
   EXPECT_CALL(*gl_, TexSubImage2D(target, level, xoffset, yoffset, width,
                                   height, format, type, _))
       .Times(1)
       .RetiresOnSaturation();
   TexSubImage2D tex_sub_image_2d_cmd;
   tex_sub_image_2d_cmd.Init(target, level, xoffset, yoffset, width, height,
@@ skipping 23 matching lines @@
   // Define texture first.
   DoTexImage2D(target, level, format, width, height, border, format, type,
                pixels_shm_id, pixels_shm_offset);
 
   // Bind texture to GLImage.
   DoBindTexImage2DCHROMIUM(GL_TEXTURE_2D, 1);
 
   // Check binding.
   TextureRef* texture_ref =
       group().texture_manager()->GetTexture(client_texture_id_);
-  ASSERT_TRUE(texture_ref != NULL);
+  ASSERT_TRUE(texture_ref != nullptr);
   Texture* texture = texture_ref->texture();
   EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 0) == image.get());
 
   // ClearLevel should use glTexSubImage2D to avoid unbinding GLImage.
   EXPECT_CALL(*gl_, BindTexture(GL_TEXTURE_2D, kServiceTextureId))
       .Times(2)
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, TexSubImage2D(target, level, xoffset, yoffset, width,
                                   height, format, type, _))
       .Times(1)
       .RetiresOnSaturation();
   GetDecoder()->ClearLevel(texture, target, level, format, type, 0, 0, width,
                            height);
   EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 0) == image.get());
 }
 
 TEST_P(GLES2DecoderTest, ReleaseTexImage2DCHROMIUM) {
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   DoTexImage2D(
       GL_TEXTURE_2D, 0, GL_RGBA, 3, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0);
   TextureRef* texture_ref =
       group().texture_manager()->GetTexture(client_texture_id_);
-  ASSERT_TRUE(texture_ref != NULL);
+  ASSERT_TRUE(texture_ref != nullptr);
   Texture* texture = texture_ref->texture();
   EXPECT_EQ(kServiceTextureId, texture->service_id());
 
   scoped_refptr<gl::GLImage> image(new gl::GLImageStub);
   GetImageManager()->AddImage(image.get(), 1);
-  EXPECT_FALSE(GetImageManager()->LookupImage(1) == NULL);
+  EXPECT_FALSE(GetImageManager()->LookupImage(1) == nullptr);
 
   GLsizei width;
   GLsizei height;
   GLenum type;
   GLenum internal_format;
 
   EXPECT_TRUE(
       texture->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height, nullptr));
   EXPECT_EQ(3, width);
   EXPECT_EQ(1, height);
   EXPECT_TRUE(texture->GetLevelType(GL_TEXTURE_2D, 0, &type, &internal_format));
   EXPECT_EQ(static_cast<GLenum>(GL_RGBA), internal_format);
   EXPECT_EQ(static_cast<GLenum>(GL_UNSIGNED_BYTE), type);
-  EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 0) == NULL);
+  EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 0) == nullptr);
 
   // Bind image to texture.
   // ScopedGLErrorSuppressor calls GetError on its constructor and destructor.
   DoBindTexImage2DCHROMIUM(GL_TEXTURE_2D, 1);
   EXPECT_TRUE(
       texture->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height, nullptr));
   // Image should now be set.
-  EXPECT_FALSE(texture->GetLevelImage(GL_TEXTURE_2D, 0) == NULL);
+  EXPECT_FALSE(texture->GetLevelImage(GL_TEXTURE_2D, 0) == nullptr);
 
   // Release image from texture.
   // ScopedGLErrorSuppressor calls GetError on its constructor and destructor.
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   ReleaseTexImage2DCHROMIUM release_tex_image_2d_cmd;
   release_tex_image_2d_cmd.Init(GL_TEXTURE_2D, 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(release_tex_image_2d_cmd));
   EXPECT_TRUE(
       texture->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height, nullptr));
   // Image should no longer be set.
-  EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 0) == NULL);
+  EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 0) == nullptr);
 }
 
 class MockGLImage : public gl::GLImage {
  public:
   MockGLImage() {}
 
   // Overridden from gl::GLImage:
   MOCK_METHOD0(GetSize, gfx::Size());
   MOCK_METHOD0(GetInternalFormat, unsigned());
   MOCK_METHOD1(Destroy, void(bool));
@@ skipping 25 matching lines @@
                1,
                1,
                0,
                GL_RGBA,
                GL_UNSIGNED_BYTE,
                kSharedMemoryId,
                kSharedMemoryOffset);
 
   TextureRef* texture_ref =
       group().texture_manager()->GetTexture(client_texture_id_);
-  ASSERT_TRUE(texture_ref != NULL);
+  ASSERT_TRUE(texture_ref != nullptr);
   Texture* texture = texture_ref->texture();
   EXPECT_EQ(kServiceTextureId, texture->service_id());
 
   const int32_t kImageId = 1;
   scoped_refptr<MockGLImage> image(new MockGLImage);
   GetImageManager()->AddImage(image.get(), kImageId);
 
   // Bind image to texture.
   EXPECT_CALL(*image.get(), BindTexImage(GL_TEXTURE_2D))
       .Times(1)
@@ skipping 147 matching lines @@
                16,
                17,
                0,
                GL_LUMINANCE_ALPHA,
                GL_FLOAT,
                0,
                0);
 }
 
 TEST_P(GLES2DecoderManualInitTest, TexImage2DFloatOnGLES3) {
+  base::CommandLine command_line(0, nullptr);
+  command_line.AppendSwitch(switches::kEnableUnsafeES3APIs);
   InitState init;
   init.extensions = "GL_OES_texture_float GL_EXT_color_buffer_float";
   init.gl_version = "opengl es 3.0";
-  InitDecoder(init);
+  init.context_type = CONTEXT_TYPE_OPENGLES3;
+  InitDecoderWithCommandLine(init, &command_line);
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 17, 0, GL_RGBA, GL_FLOAT, 0, 0);
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 16, 17, 0, GL_RGB, GL_FLOAT, 0, 0);
   DoTexImage2D(
       GL_TEXTURE_2D, 0, GL_RGBA32F, 16, 17, 0, GL_RGBA, GL_FLOAT, 0, 0);
   DoTexImage2D(
       GL_TEXTURE_2D, 0, GL_LUMINANCE, 16, 17, 0, GL_LUMINANCE, GL_FLOAT, 0, 0);
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, 16, 17, 0, GL_ALPHA, GL_FLOAT, 0, 0);
   DoTexImage2D(GL_TEXTURE_2D,
                0,
                GL_LUMINANCE_ALPHA,
                16,
                17,
                0,
                GL_LUMINANCE_ALPHA,
                GL_FLOAT,
                0,
                0);
 }
 
 TEST_P(GLES2DecoderManualInitTest, TexSubImage2DFloatOnGLES3) {
+  base::CommandLine command_line(0, nullptr);
+  command_line.AppendSwitch(switches::kEnableUnsafeES3APIs);
   InitState init;
   init.extensions = "GL_OES_texture_float GL_EXT_color_buffer_float";
   init.gl_version = "opengl es 3.0";
-  InitDecoder(init);
+  init.context_type = CONTEXT_TYPE_OPENGLES3;
+  InitDecoderWithCommandLine(init, &command_line);
   const int kWidth = 8;
   const int kHeight = 4;
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   DoTexImage2D(GL_TEXTURE_2D,
                0,
                GL_RGBA32F,
                kWidth,
                kHeight,
                0,
                GL_RGBA,
@@ skipping 22 matching lines @@
            GL_RGBA,
            GL_FLOAT,
            kSharedMemoryId,
            kSharedMemoryOffset,
            GL_FALSE);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_P(GLES2DecoderManualInitTest, TexSubImage2DFloatDoesClearOnGLES3) {
+  base::CommandLine command_line(0, nullptr);
+  command_line.AppendSwitch(switches::kEnableUnsafeES3APIs);

[Zhenyao Mo, 2016/11/01 22:28:45]

Qiankun: sorry about this, but we are in the process of removing this switch. 
So this CL is definitely in the opposite direction.

[qiankun, 2016/11/02 01:43:14]

So, we are not able to add new ES3 tests and fix bugs like
conformance2/textures/misc/tex-image-with-bad-args.html before unsafe mode
removal work is done. The initial motivation of this CL was to remove blocking
issue to fix above CTS test failure.

We just need to remove this command line for unsafe mode removal.

   InitState init;
   init.extensions = "GL_OES_texture_float GL_EXT_color_buffer_float";
   init.gl_version = "opengl es 3.0";
-  InitDecoder(init);
+  init.context_type = CONTEXT_TYPE_OPENGLES3;
+  InitDecoderWithCommandLine(init, &command_line);
   const int kWidth = 8;
   const int kHeight = 4;
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   DoTexImage2D(GL_TEXTURE_2D,
                0,
                GL_RGBA32F,
                kWidth,
                kHeight,
                0,
                GL_RGBA,
@@ skipping 284 matching lines @@
   const GLsizei kDepth = 2;
   const GLenum kFormat = GL_RGBA;
   const GLenum kType = GL_UNSIGNED_BYTE;
   const uint32_t kBufferSize = kWidth * kHeight * kDepth * 4;
 
   DoBindTexture(kTarget, client_texture_id_, kServiceTextureId);
   DoTexImage3D(kTarget, kLevel, kInternalFormat, kWidth, kHeight, kDepth, 0,
                kFormat, kType, 0, 0);
   TextureRef* texture_ref =
       group().texture_manager()->GetTexture(client_texture_id_);
-  ASSERT_TRUE(texture_ref != NULL);
+  ASSERT_TRUE(texture_ref != nullptr);
   Texture* texture = texture_ref->texture();
 
   EXPECT_CALL(*gl_, GenBuffersARB(1, _))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, BindBuffer(GL_PIXEL_UNPACK_BUFFER, _))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, BufferData(GL_PIXEL_UNPACK_BUFFER,
                                kBufferSize, _, GL_STATIC_DRAW))
@@ skipping 33 matching lines @@
   const GLsizei kDepth = 7;
   const GLenum kFormat = GL_RGBA;
   const GLenum kType = GL_UNSIGNED_BYTE;
   const uint32_t kBufferSize = 1024 * 1024 * 2;  // Max buffer size per call.
 
   DoBindTexture(kTarget, client_texture_id_, kServiceTextureId);
   DoTexImage3D(kTarget, kLevel, kInternalFormat, kWidth, kHeight, kDepth, 0,
                kFormat, kType, 0, 0);
   TextureRef* texture_ref =
       group().texture_manager()->GetTexture(client_texture_id_);
-  ASSERT_TRUE(texture_ref != NULL);
+  ASSERT_TRUE(texture_ref != nullptr);
   Texture* texture = texture_ref->texture();
 
   EXPECT_CALL(*gl_, GenBuffersARB(1, _))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, BindBuffer(GL_PIXEL_UNPACK_BUFFER, _))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, BufferData(GL_PIXEL_UNPACK_BUFFER,
                                kBufferSize, _, GL_STATIC_DRAW))
@@ skipping 44 matching lines @@
   const GLsizei kDepth = 2;
   const GLenum kFormat = GL_RGBA;
   const GLenum kType = GL_UNSIGNED_BYTE;
   const uint32_t kBufferSize = 1024 * 1024 * 2;  // Max buffer size per call.
 
   DoBindTexture(kTarget, client_texture_id_, kServiceTextureId);
   DoTexImage3D(kTarget, kLevel, kInternalFormat, kWidth, kHeight, kDepth, 0,
                kFormat, kType, 0, 0);
   TextureRef* texture_ref =
       group().texture_manager()->GetTexture(client_texture_id_);
-  ASSERT_TRUE(texture_ref != NULL);
+  ASSERT_TRUE(texture_ref != nullptr);
   Texture* texture = texture_ref->texture();
 
   EXPECT_CALL(*gl_, GenBuffersARB(1, _))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, BindBuffer(GL_PIXEL_UNPACK_BUFFER, _))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, BufferData(GL_PIXEL_UNPACK_BUFFER,
                                kBufferSize, _, GL_STATIC_DRAW))
@@ skipping 65 matching lines @@
       // Generate and bind the source image. Making a new image for each set of
       // parameters is easier than trying to reuse images. Obviously there's no
       // performance penalty.
       int image_id = use_rgb_emulation * 2 + destination_texture_index;
       scoped_refptr<gl::GLImage> image;
       if (use_rgb_emulation)
         image = new EmulatingRGBImageStub;
       else
         image = new gl::GLImageStub;
       GetImageManager()->AddImage(image.get(), image_id);
-      EXPECT_FALSE(GetImageManager()->LookupImage(image_id) == NULL);
+      EXPECT_FALSE(GetImageManager()->LookupImage(image_id) == nullptr);
       DoBindTexture(GL_TEXTURE_2D, kFBOClientTextureId, kFBOServiceTextureId);
 
       DoBindTexImage2DCHROMIUM(GL_TEXTURE_2D, image_id);
       DoFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, target,
                              kFBOClientTextureId, kFBOServiceTextureId, level,
                              GL_NO_ERROR);
 
       GLenum destination_texture_format =
           destination_texture_formats[destination_texture_index];
       bool should_succeed =
@@ skipping 57 matching lines @@
     EXPECT_CALL(*gl_, TexParameteri(GL_TEXTURE_2D,
                                     GL_DEPTH_TEXTURE_MODE,
                                     GL_RED))
         .Times(1)
         .RetiresOnSaturation();
   }
   BindTexture cmd;
   cmd.Init(GL_TEXTURE_2D, kNewClientId);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
-  EXPECT_TRUE(GetTexture(kNewClientId) != NULL);
+  EXPECT_TRUE(GetTexture(kNewClientId) != nullptr);
 }
 
 TEST_P(GLES2DecoderTest, BindTextureInvalidArgs) {
   EXPECT_CALL(*gl_, BindTexture(_, _)).Times(0);
   BindTexture cmd;
   cmd.Init(GL_TEXTURE_1D, client_texture_id_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 
   cmd.Init(GL_TEXTURE_3D, client_texture_id_);
@@ skipping 12 matching lines @@
 // TODO(gman): CompressedTexSubImage2DImmediate
 
 // TODO(gman): TexImage2D
 
 // TODO(gman): TexImage2DImmediate
 
 // TODO(gman): TexSubImage2DImmediate
 
 }  // namespace gles2
 }  // namespace gpu