Remove unsafe mode to enable es3 api by default for WebGL2 and ES3 context

gpu/command_buffer/service/gles2_cmd_decoder_unittest_programs.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 72 matching lines @@
   const uint32_t kBucketId = 123;
   GetUniformBlocksCHROMIUM cmd;
   cmd.Init(client_program_id_, kBucketId);
   EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _))
       .WillOnce(SetArgPointee<2>(GL_TRUE))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_,
               GetProgramiv(kServiceProgramId, GL_ACTIVE_UNIFORM_BLOCKS, _))
       .WillOnce(SetArgPointee<2>(0))
       .RetiresOnSaturation();
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId);
   EXPECT_EQ(sizeof(UniformBlocksHeader), bucket->size());
   UniformBlocksHeader* header =
       bucket->GetDataAs<UniformBlocksHeader*>(0, sizeof(UniformBlocksHeader));
   EXPECT_TRUE(header != NULL);
   EXPECT_EQ(0u, header->num_uniform_blocks);
-  decoder_->set_unsafe_es3_apis_enabled(false);
+  decoder_->set_es3_apis_enabled(false);
   EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetUniformBlocksCHROMIUMInvalidArgs) {
   const uint32_t kBucketId = 123;
   CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId);
   EXPECT_TRUE(bucket == NULL);
   GetUniformBlocksCHROMIUM cmd;
   cmd.Init(kInvalidClientId, kBucketId);
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   bucket = decoder_->GetBucket(kBucketId);
   ASSERT_TRUE(bucket != NULL);
   EXPECT_EQ(sizeof(UniformBlocksHeader), bucket->size());
   UniformBlocksHeader* header =
       bucket->GetDataAs<UniformBlocksHeader*>(0, sizeof(UniformBlocksHeader));
   ASSERT_TRUE(header != NULL);
   EXPECT_EQ(0u, header->num_uniform_blocks);
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetUniformsES3CHROMIUMValidArgs) {
   const uint32_t kBucketId = 123;
   GetUniformsES3CHROMIUM cmd;
   cmd.Init(client_program_id_, kBucketId);
   EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _))
       .WillOnce(SetArgPointee<2>(GL_TRUE))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_,
               GetProgramiv(kServiceProgramId, GL_ACTIVE_UNIFORMS, _))
       .WillOnce(SetArgPointee<2>(0))
       .RetiresOnSaturation();
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId);
   EXPECT_EQ(sizeof(UniformsES3Header), bucket->size());
   UniformsES3Header* header =
       bucket->GetDataAs<UniformsES3Header*>(0, sizeof(UniformsES3Header));
   EXPECT_TRUE(header != NULL);
   EXPECT_EQ(0u, header->num_uniforms);
-  decoder_->set_unsafe_es3_apis_enabled(false);
+  decoder_->set_es3_apis_enabled(false);
   EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetUniformsES3CHROMIUMInvalidArgs) {
   const uint32_t kBucketId = 123;
   CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId);
   EXPECT_TRUE(bucket == NULL);
   GetUniformsES3CHROMIUM cmd;
   cmd.Init(kInvalidClientId, kBucketId);
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   bucket = decoder_->GetBucket(kBucketId);
   ASSERT_TRUE(bucket != NULL);
   EXPECT_EQ(sizeof(UniformsES3Header), bucket->size());
   UniformsES3Header* header =
       bucket->GetDataAs<UniformsES3Header*>(0, sizeof(UniformsES3Header));
   ASSERT_TRUE(header != NULL);
   EXPECT_EQ(0u, header->num_uniforms);
 }
@@ skipping 10 matching lines @@
       .WillOnce(SetArgPointee<2>(GL_INTERLEAVED_ATTRIBS))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _))
       .WillOnce(SetArgPointee<2>(GL_TRUE))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_,
               GetProgramiv(
                   kServiceProgramId, GL_TRANSFORM_FEEDBACK_VARYINGS, _))
       .WillOnce(SetArgPointee<2>(0))
       .RetiresOnSaturation();
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId);
   EXPECT_EQ(sizeof(TransformFeedbackVaryingsHeader), bucket->size());
   TransformFeedbackVaryingsHeader* header =
       bucket->GetDataAs<TransformFeedbackVaryingsHeader*>(
           0, sizeof(TransformFeedbackVaryingsHeader));
   EXPECT_TRUE(header != NULL);
   EXPECT_EQ(static_cast<uint32_t>(GL_INTERLEAVED_ATTRIBS),
             header->transform_feedback_buffer_mode);
   EXPECT_EQ(0u, header->num_transform_feedback_varyings);
-  decoder_->set_unsafe_es3_apis_enabled(false);
+  decoder_->set_es3_apis_enabled(false);
   EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
 }
 
 TEST_P(GLES2DecoderWithShaderTest,
        GetTransformFeedbackVaryingsCHROMIUMInvalidArgs) {
   const uint32_t kBucketId = 123;
   CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId);
   EXPECT_TRUE(bucket == NULL);
   GetTransformFeedbackVaryingsCHROMIUM cmd;
   cmd.Init(kInvalidClientId, kBucketId);
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   bucket = decoder_->GetBucket(kBucketId);
   ASSERT_TRUE(bucket != NULL);
   EXPECT_EQ(sizeof(TransformFeedbackVaryingsHeader), bucket->size());
   TransformFeedbackVaryingsHeader* header =
       bucket->GetDataAs<TransformFeedbackVaryingsHeader*>(
           0, sizeof(TransformFeedbackVaryingsHeader));
   ASSERT_TRUE(header != NULL);
   EXPECT_EQ(0u, header->num_transform_feedback_varyings);
@@ skipping 111 matching lines @@
   GetUniformuiv::Result* result =
       static_cast<GetUniformuiv::Result*>(shared_memory_address_);
   result->size = 0;
   GetUniformuiv cmd;
   cmd.Init(client_program_id_,
            kUniform2FakeLocation,
            kSharedMemoryId,
            kSharedMemoryOffset);
   EXPECT_CALL(*gl_, GetUniformuiv(kServiceProgramId, kUniform2RealLocation, _))
       .Times(1);
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GLES2Util::GetElementCountForUniformType(kUniform2Type),
             static_cast<uint32_t>(result->GetNumResults()));
-  decoder_->set_unsafe_es3_apis_enabled(false);
+  decoder_->set_es3_apis_enabled(false);
   EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetUniformuivArrayElementSucceeds) {
   GetUniformuiv::Result* result =
       static_cast<GetUniformuiv::Result*>(shared_memory_address_);
   result->size = 0;
   GetUniformuiv cmd;
   cmd.Init(client_program_id_,
            kUniform2ElementFakeLocation,
            kSharedMemoryId,
            kSharedMemoryOffset);
   EXPECT_CALL(*gl_,
               GetUniformuiv(kServiceProgramId, kUniform2ElementRealLocation, _))
       .Times(1);
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GLES2Util::GetElementCountForUniformType(kUniform2Type),
             static_cast<uint32_t>(result->GetNumResults()));
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetUniformuivBadProgramFails) {
   GetUniformuiv::Result* result =
       static_cast<GetUniformuiv::Result*>(shared_memory_address_);
   result->size = 0;
   GetUniformuiv cmd;
   // non-existant program
   cmd.Init(kInvalidClientId,
            kUniform2FakeLocation,
            kSharedMemoryId,
            kSharedMemoryOffset);
   EXPECT_CALL(*gl_, GetUniformuiv(_, _, _)).Times(0);
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(0U, result->size);
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 // Valid id that is not a program. The GL spec requires a different error for
 // this case.
 #if GLES2_TEST_SHADER_VS_PROGRAM_IDS
   result->size = kInitialResult;
   cmd.Init(client_shader_id_,
            kUniform2FakeLocation,
            kSharedMemoryId,
@@ skipping 24 matching lines @@
   GetUniformuiv::Result* result =
       static_cast<GetUniformuiv::Result*>(shared_memory_address_);
   result->size = 0;
   GetUniformuiv cmd;
   // invalid location
   cmd.Init(client_program_id_,
            kInvalidUniformLocation,
            kSharedMemoryId,
            kSharedMemoryOffset);
   EXPECT_CALL(*gl_, GetUniformuiv(_, _, _)).Times(0);
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(0U, result->size);
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetUniformuivBadSharedMemoryFails) {
   GetUniformuiv cmd;
   cmd.Init(client_program_id_,
            kUniform2FakeLocation,
            kInvalidSharedMemoryId,
            kSharedMemoryOffset);
   EXPECT_CALL(*gl_, GetUniformuiv(_, _, _)).Times(0);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   cmd.Init(client_program_id_,
            kUniform2FakeLocation,
            kSharedMemoryId,
            kInvalidSharedMemoryOffset);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 };
 
 TEST_P(GLES2DecoderWithShaderTest, GetUniformfvSucceeds) {
   GetUniformfv::Result* result =
       static_cast<GetUniformfv::Result*>(shared_memory_address_);
@@ skipping 360 matching lines @@
   EXPECT_CALL(*gl_,
               GetProgramiv(kServiceProgramId,
                            GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH, _))
       .WillOnce(SetArgPointee<2>(kMaxLength))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_,
               GetActiveUniformBlockName(kServiceProgramId, 0, _, _, _))
       .WillOnce(DoAll(SetArgPointee<3>(strlen(kName)),
                       SetArrayArgument<4>(kName, kName + strlen(kName) + 1)))
       .RetiresOnSaturation();
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_NE(0, *result);
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId);
   ASSERT_TRUE(bucket != NULL);
   EXPECT_EQ(0,
             memcmp(bucket->GetData(0, bucket->size()), kName, bucket->size()));
-  decoder_->set_unsafe_es3_apis_enabled(false);
+  decoder_->set_es3_apis_enabled(false);
   EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformBlockNameUnlinkedProgram) {
   const uint32_t kBucketId = 123;
   GetActiveUniformBlockName cmd;
   typedef GetActiveUniformBlockName::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
   *result = 0;
   cmd.Init(client_program_id_,
            0,
            kBucketId,
            shared_memory_id_,
            shared_memory_offset_);
   EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _))
       .WillOnce(SetArgPointee<2>(GL_FALSE))
       .RetiresOnSaturation();
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(0, *result);
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
 TEST_P(GLES2DecoderWithShaderTest,
        GetActiveUniformBlockNameResultNotInitFails) {
   const uint32_t kBucketId = 123;
   GetActiveUniformBlockName cmd;
   typedef GetActiveUniformBlockName::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
   *result = 1;
   cmd.Init(client_program_id_,
            0,
            kBucketId,
            shared_memory_id_,
            shared_memory_offset_);
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformBlockNameBadProgramFails) {
   const uint32_t kBucketId = 123;
   GetActiveUniformBlockName cmd;
   typedef GetActiveUniformBlockName::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
   *result = 0;
   cmd.Init(kInvalidClientId,
            0,
            kBucketId,
            shared_memory_id_,
            shared_memory_offset_);
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(0, *result);
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
 TEST_P(GLES2DecoderWithShaderTest,
        GetActiveUniformBlockNameBadSharedMemoryFails) {
   const uint32_t kBucketId = 123;
   GetActiveUniformBlockName cmd;
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   cmd.Init(client_program_id_,
            0,
            kBucketId,
            kInvalidSharedMemoryId,
            shared_memory_offset_);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   cmd.Init(client_program_id_,
            0,
            kBucketId,
            shared_memory_id_,
@@ skipping 36 matching lines @@
                   GetActiveUniformBlockiv(kServiceProgramId, 0,
                       GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS, _))
           .WillOnce(SetArgPointee<3>(1))
           .RetiresOnSaturation();
     }
     EXPECT_CALL(*gl_,
                 GetActiveUniformBlockiv(
                     kServiceProgramId, 0, kPname[ii], _))
         .WillOnce(SetArgPointee<3>(1976))
         .RetiresOnSaturation();
-    decoder_->set_unsafe_es3_apis_enabled(true);
+    decoder_->set_es3_apis_enabled(true);
     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
     EXPECT_EQ(1, result->GetNumResults());
     EXPECT_EQ(GL_NO_ERROR, GetGLError());
     EXPECT_EQ(1976, result->GetData()[0]);
-    decoder_->set_unsafe_es3_apis_enabled(false);
+    decoder_->set_es3_apis_enabled(false);
     EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
   }
 }
 
 TEST_P(GLES2DecoderWithShaderTest,
        GetActiveUniformBlockivSucceedsZeroUniforms) {
   GetActiveUniformBlockiv cmd;
   typedef GetActiveUniformBlockiv::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
   result->SetNumResults(0);
@@ skipping 13 matching lines @@
   EXPECT_CALL(*gl_,
               GetActiveUniformBlockiv(
                   kServiceProgramId, 0, GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS, _))
       .WillOnce(SetArgPointee<3>(0))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_,
               GetActiveUniformBlockiv(kServiceProgramId, 0,
                   GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES, _))
       .Times(1)
       .RetiresOnSaturation();
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(0, result->GetNumResults());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformBlockivUnlinkedProgram) {
   GetActiveUniformBlockiv cmd;
   typedef GetActiveUniformBlockiv::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
   result->SetNumResults(0);
   cmd.Init(client_program_id_,
            0,
            GL_UNIFORM_BLOCK_BINDING,
            shared_memory_id_,
            shared_memory_offset_);
   EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _))
       .WillOnce(SetArgPointee<2>(GL_FALSE))
       .RetiresOnSaturation();
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(0, result->GetNumResults());
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
 TEST_P(GLES2DecoderWithShaderTest,
        GetActiveUniformBlockivResultNotInitFails) {
   GetActiveUniformBlockiv cmd;
   typedef GetActiveUniformBlockiv::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
   result->SetNumResults(1);  // Should be initialized to 0.
   cmd.Init(client_program_id_,
            0,
            GL_UNIFORM_BLOCK_BINDING,
            shared_memory_id_,
            shared_memory_offset_);
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _))
       .WillOnce(SetArgPointee<2>(GL_TRUE))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformBlockivBadProgramFails) {
   GetActiveUniformBlockiv cmd;
   typedef GetActiveUniformBlockiv::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
   result->SetNumResults(0);
   cmd.Init(kInvalidClientId,
            0,
            GL_UNIFORM_BLOCK_BINDING,
            shared_memory_id_,
            shared_memory_offset_);
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(0, result->GetNumResults());
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
 TEST_P(GLES2DecoderWithShaderTest,
        GetActiveUniformBlockivBadSharedMemoryFails) {
   GetActiveUniformBlockiv cmd;
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _))
       .WillOnce(SetArgPointee<2>(GL_TRUE))
       .WillOnce(SetArgPointee<2>(GL_TRUE))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   cmd.Init(client_program_id_,
            0,
@@ skipping 129 matching lines @@
   EXPECT_CALL(*gl_, GetUniformIndices(kServiceProgramId, kCount, _, _))
       .WillOnce(SetArrayArgument<3>(kIndices, kIndices + kCount))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _))
       .WillOnce(SetArgPointee<2>(GL_TRUE))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   result->size = 0;
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(kCount, static_cast<size_t>(result->GetNumResults()));
   for (size_t ii = 0; ii < kCount; ++ii) {
     EXPECT_EQ(kIndices[ii], result->GetData()[ii]);
   }
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
-  decoder_->set_unsafe_es3_apis_enabled(false);
+  decoder_->set_es3_apis_enabled(false);
   EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetUniformIndicesBadProgramFails) {
   const uint32_t kBucketId = 123;
   const char kName0[] = "Cow";
   const char kName1[] = "Chicken";
   const char* kNames[] = { kName0, kName1 };
   const size_t kCount = arraysize(kNames);
   const char kValidStrEnd = 0;
   SetBucketAsCStrings(kBucketId, kCount, kNames, kCount, kValidStrEnd);
   GetUniformIndices::Result* result =
       static_cast<GetUniformIndices::Result*>(shared_memory_address_);
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   GetUniformIndices cmd;
   // None-existant program
   cmd.Init(kInvalidClientId,
            kBucketId,
            kSharedMemoryId,
            kSharedMemoryOffset);
   result->size = 0;
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(0, result->GetNumResults());
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
@@ skipping 30 matching lines @@
   EXPECT_CALL(*gl_, GetUniformIndices(kServiceProgramId, kCount, _, _))
       .WillOnce(SetArrayArgument<3>(kIndices, kIndices + kCount))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _))
       .WillOnce(SetArgPointee<2>(GL_TRUE))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_INVALID_VALUE))
       .RetiresOnSaturation();
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   result->size = 0;
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(0, result->GetNumResults());
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetUniformIndicesResultNotInitFails) {
   const uint32_t kBucketId = 123;
   const char kName0[] = "Cow";
   const char kName1[] = "Chicken";
   const char* kNames[] = { kName0, kName1 };
   const size_t kCount = arraysize(kNames);
   const char kValidStrEnd = 0;
   SetBucketAsCStrings(kBucketId, kCount, kNames, kCount, kValidStrEnd);
   GetUniformIndices::Result* result =
       static_cast<GetUniformIndices::Result*>(shared_memory_address_);
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   GetUniformIndices cmd;
   result->size = 1976;  // Any value other than 0.
   cmd.Init(kInvalidClientId,
            kBucketId,
            kSharedMemoryId,
            kSharedMemoryOffset);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetUniformIndicesBadSharedMemoryFails) {
   const uint32_t kBucketId = 123;
   const char kName0[] = "Cow";
   const char kName1[] = "Chicken";
   const char* kNames[] = { kName0, kName1 };
   const size_t kCount = arraysize(kNames);
   const char kValidStrEnd = 0;
   SetBucketAsCStrings(kBucketId, kCount, kNames, kCount, kValidStrEnd);
   GetUniformIndices::Result* result =
       static_cast<GetUniformIndices::Result*>(shared_memory_address_);
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   GetUniformIndices cmd;
   cmd.Init(client_program_id_,
            kBucketId,
            kInvalidSharedMemoryId,
            kSharedMemoryOffset);
   result->size = 0;
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   cmd.Init(client_program_id_,
            kBucketId,
            kSharedMemoryId,
@@ skipping 21 matching lines @@
                   kServiceProgramId, kCount, _, GL_UNIFORM_TYPE, _))
       .WillOnce(SetArrayArgument<4>(kResults, kResults + kCount))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _))
       .WillOnce(SetArgPointee<2>(GL_TRUE))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   result->size = 0;
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(kCount, static_cast<size_t>(result->GetNumResults()));
   for (size_t ii = 0; ii < kCount; ++ii) {
     EXPECT_EQ(kResults[ii], result->GetData()[ii]);
   }
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
-  decoder_->set_unsafe_es3_apis_enabled(false);
+  decoder_->set_es3_apis_enabled(false);
   EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformsivBadProgramFails) {
   const uint32_t kBucketId = 123;
   const GLuint kIndices[] = { 1, 2 };
   const size_t kCount = arraysize(kIndices);
   SetBucketData(kBucketId, kIndices, sizeof(GLuint) * kCount);
   GetActiveUniformsiv::Result* result =
       static_cast<GetActiveUniformsiv::Result*>(shared_memory_address_);
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   GetActiveUniformsiv cmd;
   // None-existant program
   cmd.Init(kInvalidClientId,
            kBucketId,
            GL_UNIFORM_TYPE,
            kSharedMemoryId,
            kSharedMemoryOffset);
   result->size = 0;
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(0, result->GetNumResults());
@@ skipping 32 matching lines @@
                   kServiceProgramId, kCount, _, GL_UNIFORM_TYPE, _))
       .WillOnce(SetArrayArgument<4>(kResults, kResults + kCount))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _))
       .WillOnce(SetArgPointee<2>(GL_TRUE))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_INVALID_VALUE))
       .RetiresOnSaturation();
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   result->size = 0;
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(0, result->GetNumResults());
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformsivBadPnameFails) {
   const uint32_t kBucketId = 123;
   const GLuint kIndices[] = { 1, 2 };
   const size_t kCount = arraysize(kIndices);
   SetBucketData(kBucketId, kIndices, sizeof(GLuint) * kCount);
   GetActiveUniformsiv::Result* result =
       static_cast<GetActiveUniformsiv::Result*>(shared_memory_address_);
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   GetActiveUniformsiv cmd;
   // GL_UNIFORM_BLOCK_NAME_LENGTH should not be supported.
   cmd.Init(client_program_id_,
            kBucketId,
            GL_UNIFORM_BLOCK_NAME_LENGTH,
            kSharedMemoryId,
            kSharedMemoryOffset);
   result->size = 0;
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(0, result->GetNumResults());
@@ skipping 16 matching lines @@
   const size_t kCount = arraysize(kIndices);
   SetBucketData(kBucketId, kIndices, sizeof(GLuint) * kCount);
   GetActiveUniformsiv::Result* result =
       static_cast<GetActiveUniformsiv::Result*>(shared_memory_address_);
   GetActiveUniformsiv cmd;
   cmd.Init(client_program_id_,
            kBucketId,
            GL_UNIFORM_TYPE,
            kSharedMemoryId,
            kSharedMemoryOffset);
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   result->size = 1976;  // Any value other than 0.
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformsivBadSharedMemoryFails) {
   const uint32_t kBucketId = 123;
   const GLuint kIndices[] = { 1, 2 };
   const size_t kCount = arraysize(kIndices);
   SetBucketData(kBucketId, kIndices, sizeof(GLuint) * kCount);
   GetActiveUniformsiv::Result* result =
       static_cast<GetActiveUniformsiv::Result*>(shared_memory_address_);
   GetActiveUniformsiv cmd;
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   result->size = 0;
   cmd.Init(client_program_id_,
            kBucketId,
            GL_UNIFORM_TYPE,
            kInvalidSharedMemoryId,
            kSharedMemoryOffset);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   result->size = 0;
   cmd.Init(client_program_id_,
            kBucketId,
@@ skipping 76 matching lines @@
       .WillOnce(DoAll(SetArgPointee<3>(kBufferSize - 1),
                       SetArgPointee<4>(kSize),
                       SetArgPointee<5>(kType),
                       SetArrayArgument<6>(kName, kName + kBufferSize)))
       .RetiresOnSaturation();
   cmd.Init(client_program_id_,
            kIndex,
            kBucketId,
            shared_memory_id_,
            shared_memory_offset_);
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_NE(0, result->success);
   EXPECT_EQ(kSize, static_cast<GLsizei>(result->size));
   EXPECT_EQ(kType, static_cast<GLenum>(result->type));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId);
   ASSERT_TRUE(bucket != NULL);
   EXPECT_EQ(
       0, memcmp(bucket->GetData(0, bucket->size()), kName, bucket->size()));
-  decoder_->set_unsafe_es3_apis_enabled(false);
+  decoder_->set_es3_apis_enabled(false);
   EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetTransformFeedbackVaryingNotInitFails) {
   const GLuint kIndex = 1;
   const uint32_t kBucketId = 123;
   GetTransformFeedbackVarying cmd;
   typedef GetTransformFeedbackVarying::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
   result->success = 1;
   cmd.Init(client_program_id_,
            kIndex,
            kBucketId,
            shared_memory_id_,
            shared_memory_offset_);
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetTransformFeedbackVaryingBadProgramFails) {
   const GLuint kIndex = 1;
   const uint32_t kBucketId = 123;
   GetTransformFeedbackVarying cmd;
   typedef GetTransformFeedbackVarying::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
   result->success = 0;
   cmd.Init(kInvalidClientId,
            kIndex,
            kBucketId,
            shared_memory_id_,
            shared_memory_offset_);
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(0, result->success);
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetTransformFeedbackVaryingBadParamsFails) {
   const GLuint kIndex = 1;
   const uint32_t kBucketId = 123;
   const GLsizei kBufferSize = 10;
   GetTransformFeedbackVarying cmd;
@@ skipping 14 matching lines @@
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_INVALID_VALUE))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_,
               GetTransformFeedbackVarying(
                   kServiceProgramId, kIndex, _, _, _, _, _))
       .Times(1)
       .RetiresOnSaturation();
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(0, result->success);
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
 TEST_P(GLES2DecoderWithShaderTest,
        GetTransformFeedbackVaryingBadSharedMemoryFails) {
   const GLuint kIndex = 1;
   const uint32_t kBucketId = 123;
   GetTransformFeedbackVarying cmd;
   typedef GetTransformFeedbackVarying::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
   result->success = 0;
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   cmd.Init(client_program_id_,
            kIndex,
            kBucketId,
            kInvalidSharedMemoryId,
            shared_memory_offset_);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   cmd.Init(client_program_id_,
            kIndex,
            kBucketId,
            shared_memory_id_,
@@ skipping 102 matching lines @@
   EXPECT_CALL(*gl_, Uniform1i(kUniform1RealLocation, 2));
   Uniform1i cmd;
   cmd.Init(kUniform1FakeLocation, 2);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
 TEST_P(GLES2DecoderWithShaderTest, Uniform1uiValidArgs) {
   EXPECT_CALL(*gl_, Uniform1uiv(kUniform4RealLocation, 1, _));
   Uniform1ui cmd;
   cmd.Init(kUniform4FakeLocation, 2);
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
-  decoder_->set_unsafe_es3_apis_enabled(false);
+  decoder_->set_es3_apis_enabled(false);
   EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
 }
 
 TEST_P(GLES2DecoderWithShaderTest, Uniform1ivImmediateValidArgs) {
   Uniform1ivImmediate& cmd = *GetImmediateAs<Uniform1ivImmediate>();
   GLint temp[1] = {
       0,
   };
   EXPECT_CALL(*gl_,
               Uniform1iv(kUniform1RealLocation, 1, PointsToArray(temp, 1)));
@@ skipping 59 matching lines @@
 
 TEST_P(GLES2DecoderWithShaderTest, Uniform1uivImmediateValidArgs) {
   Uniform1uivImmediate& cmd =
       *GetImmediateAs<Uniform1uivImmediate>();
   GLuint temp[1] = {
       0,
   };
   EXPECT_CALL(*gl_,
               Uniform1uiv(kUniform4RealLocation, 1, PointsToArray(temp, 1)));
   cmd.Init(kUniform4FakeLocation, 1, &temp[0]);
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
-  decoder_->set_unsafe_es3_apis_enabled(false);
+  decoder_->set_es3_apis_enabled(false);
   EXPECT_EQ(error::kUnknownCommand, ExecuteImmediateCmd(cmd, sizeof(temp)));
 }
 
 TEST_P(GLES2DecoderWithShaderTest, Uniform1uivImmediateInvalidType) {
   EXPECT_CALL(*gl_, Uniform1uiv(_, _, _)).Times(0);
   Uniform1uivImmediate& cmd = *GetImmediateAs<Uniform1uivImmediate>();
   GLuint temp[1 * 2] = {
       0,
   };
   // uniform1 is SAMPLER type.
   cmd.Init(kUniform1FakeLocation, 1, &temp[0]);
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
 TEST_P(GLES2DecoderWithShaderTest, Uniform1uivZeroCount) {
   EXPECT_CALL(*gl_, Uniform1uiv(_, _, _)).Times(0);
   Uniform1uivImmediate& cmd = *GetImmediateAs<Uniform1uivImmediate>();
   GLuint temp = 0;
   cmd.Init(kUniform4FakeLocation, 0, &temp);
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_P(GLES2DecoderWithShaderTest, Uniform2uiValidArgs) {
   EXPECT_CALL(*gl_, Uniform2uiv(kUniform5RealLocation, 1, _));
   Uniform2ui cmd;
   cmd.Init(kUniform5FakeLocation, 2, 3);
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
-  decoder_->set_unsafe_es3_apis_enabled(false);
+  decoder_->set_es3_apis_enabled(false);
   EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
 }
 
 TEST_P(GLES2DecoderWithShaderTest, Uniform2uivImmediateValidArgs) {
   Uniform2uivImmediate& cmd =
       *GetImmediateAs<Uniform2uivImmediate>();
   GLuint temp[2 * 1] = {
       0,
   };
   EXPECT_CALL(*gl_,
               Uniform2uiv(kUniform5RealLocation, 1, PointsToArray(temp, 2)));
   cmd.Init(kUniform5FakeLocation, 1, &temp[0]);
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
-  decoder_->set_unsafe_es3_apis_enabled(false);
+  decoder_->set_es3_apis_enabled(false);
   EXPECT_EQ(error::kUnknownCommand, ExecuteImmediateCmd(cmd, sizeof(temp)));
 }
 
 TEST_P(GLES2DecoderWithShaderTest, Uniform3uiValidArgs) {
   EXPECT_CALL(*gl_, Uniform3uiv(kUniform6RealLocation, 1, _));
   Uniform3ui cmd;
   cmd.Init(kUniform6FakeLocation, 2, 3, 4);
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
-  decoder_->set_unsafe_es3_apis_enabled(false);
+  decoder_->set_es3_apis_enabled(false);
   EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
 }
 
 TEST_P(GLES2DecoderWithShaderTest, Uniform3uivImmediateValidArgs) {
   Uniform3uivImmediate& cmd =
       *GetImmediateAs<Uniform3uivImmediate>();
   GLuint temp[3 * 1] = {
       0,
   };
   EXPECT_CALL(*gl_,
               Uniform3uiv(kUniform6RealLocation, 1, PointsToArray(temp, 3)));
   cmd.Init(kUniform6FakeLocation, 1, &temp[0]);
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
-  decoder_->set_unsafe_es3_apis_enabled(false);
+  decoder_->set_es3_apis_enabled(false);
   EXPECT_EQ(error::kUnknownCommand, ExecuteImmediateCmd(cmd, sizeof(temp)));
 }
 
 TEST_P(GLES2DecoderWithShaderTest, Uniform4uiValidArgs) {
   EXPECT_CALL(*gl_, Uniform4uiv(kUniform7RealLocation, 1, _));
   Uniform4ui cmd;
   cmd.Init(kUniform7FakeLocation, 2, 3, 4, 5);
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
-  decoder_->set_unsafe_es3_apis_enabled(false);
+  decoder_->set_es3_apis_enabled(false);
   EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
 }
 
 TEST_P(GLES2DecoderWithShaderTest, Uniform4uivImmediateValidArgs) {
   Uniform4uivImmediate& cmd =
       *GetImmediateAs<Uniform4uivImmediate>();
   GLuint temp[4 * 1] = {
       0,
   };
   EXPECT_CALL(*gl_,
               Uniform4uiv(kUniform7RealLocation, 1, PointsToArray(temp, 4)));
   cmd.Init(kUniform7FakeLocation, 1, &temp[0]);
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
-  decoder_->set_unsafe_es3_apis_enabled(false);
+  decoder_->set_es3_apis_enabled(false);
   EXPECT_EQ(error::kUnknownCommand, ExecuteImmediateCmd(cmd, sizeof(temp)));
 }
 
 TEST_P(GLES2DecoderTest, BindAttribLocationBucket) {
   const uint32_t kBucketId = 123;
   const GLint kLocation = 2;
   const char* kName = "testing";
   EXPECT_CALL(*gl_,
               BindAttribLocation(kServiceProgramId, kLocation, StrEq(kName)))
       .Times(1);
@@ skipping 72 matching lines @@
 }
 
 TEST_P(GLES3DecoderWithESSL3ShaderTest, GetFragDataLocation) {
   const uint32_t kBucketId = 123;
   typedef GetFragDataLocation::Result Result;
   Result* result = GetSharedMemoryAs<Result*>();
   SetBucketAsCString(kBucketId, kOutputVariable1NameESSL3);
   *result = -1;
   GetFragDataLocation cmd;
   cmd.Init(client_program_id_, kBucketId, kSharedMemoryId, kSharedMemoryOffset);
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(static_cast<GLint>(kOutputVariable1ColorName), *result);
-  decoder_->set_unsafe_es3_apis_enabled(false);
+  decoder_->set_es3_apis_enabled(false);
   EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
 }
 
 TEST_P(GLES3DecoderWithESSL3ShaderTest, GetFragDataLocationInvalidArgs) {
   const uint32_t kBucketId = 123;
   typedef GetFragDataLocation::Result Result;
   Result* result = GetSharedMemoryAs<Result*>();
   *result = -1;
   GetFragDataLocation cmd;
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   // Check no bucket
   cmd.Init(client_program_id_, kBucketId, kSharedMemoryId, kSharedMemoryOffset);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(-1, *result);
   // Check bad program id.
   const char* kName = "color";
   SetBucketAsCString(kBucketId, kName);
   cmd.Init(kInvalidClientId, kBucketId, kSharedMemoryId, kSharedMemoryOffset);
   *result = -1;
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
@@ skipping 18 matching lines @@
   const char* kName = "color";
   typedef GetUniformBlockIndex::Result Result;
   Result* result = GetSharedMemoryAs<Result*>();
   SetBucketAsCString(kBucketId, kName);
   *result = GL_INVALID_INDEX;
   GetUniformBlockIndex cmd;
   cmd.Init(client_program_id_, kBucketId, kSharedMemoryId, kSharedMemoryOffset);
   EXPECT_CALL(*gl_, GetUniformBlockIndex(kServiceProgramId, StrEq(kName)))
       .WillOnce(Return(kIndex))
       .RetiresOnSaturation();
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(kIndex, *result);
-  decoder_->set_unsafe_es3_apis_enabled(false);
+  decoder_->set_es3_apis_enabled(false);
   EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetUniformBlockIndexInvalidArgs) {
   const uint32_t kBucketId = 123;
   typedef GetUniformBlockIndex::Result Result;
   Result* result = GetSharedMemoryAs<Result*>();
   *result = GL_INVALID_INDEX;
   GetUniformBlockIndex cmd;
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   // Check no bucket
   cmd.Init(client_program_id_, kBucketId, kSharedMemoryId, kSharedMemoryOffset);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_INDEX, *result);
   // Check bad program id.
   const char* kName = "color";
   SetBucketAsCString(kBucketId, kName);
   cmd.Init(kInvalidClientId, kBucketId, kSharedMemoryId, kSharedMemoryOffset);
   *result = GL_INVALID_INDEX;
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
@@ skipping 55 matching lines @@
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   cmd.Init(client_program_id_,
            kBucketId,
            kSharedMemoryId,
            kInvalidSharedMemoryOffset);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 }
 
 TEST_P(GLES3DecoderWithESSL3ShaderTest, Basic) {
   // Make sure the setup is correct for ES3.
-  EXPECT_TRUE(decoder_->unsafe_es3_apis_enabled());
+  EXPECT_TRUE(decoder_->es3_apis_enabled());
   EXPECT_TRUE(feature_info()->validators()->texture_bind_target.IsValid(
       GL_TEXTURE_3D));
 }
 
 TEST_P(GLES3DecoderWithESSL3ShaderTest, UniformBlockBindingValidArgs) {
   EXPECT_CALL(*gl_, UniformBlockBinding(kServiceProgramId, 1, 3));
   SpecializedSetup<UniformBlockBinding, 0>(true);
   UniformBlockBinding cmd;
   cmd.Init(client_program_id_, 1, 3);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
@@ skipping 128 matching lines @@
 }
 
 // TODO(gman): DeleteProgram
 
 // TODO(gman): UseProgram
 
 // TODO(gman): DeleteShader
 
 }  // namespace gles2
 }  // namespace gpu