remove 'unsafe' from ES3 apis in gpu process

gpu/command_buffer/service/gles2_cmd_decoder.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
 #include <limits.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
@@ skipping 460 matching lines @@
   return false;
 }
 
 uint32_t GLES2Decoder::GetAndClearBackbufferClearBitsForTest() {
   return 0;
 }
 
 GLES2Decoder::GLES2Decoder()
     : initialized_(false),
       debug_(false),
-      log_commands_(false),
-      unsafe_es3_apis_enabled_(false) {
+      log_commands_(false) {
 }
 
 GLES2Decoder::~GLES2Decoder() {
 }
 
 void GLES2Decoder::BeginDecoding() {}
 
 void GLES2Decoder::EndDecoding() {}
 
 error::Error GLES2Decoder::DoCommand(unsigned int command,
@@ skipping 2595 matching lines @@
   transform_feedback_manager_.reset(new TransformFeedbackManager(
       group_->max_transform_feedback_separate_attribs(), needs_emulation));
 
   if (feature_info_->IsWebGL2OrES3Context()) {
     if (!feature_info_->IsES3Capable()) {
       LOG(ERROR) << "ES3 is blacklisted/disabled/unsupported by driver.";
       Destroy(true);
       return false;
     }
     feature_info_->EnableES3Validators();
-    set_unsafe_es3_apis_enabled(true);
 
     frag_depth_explicitly_enabled_ = true;
     draw_buffers_explicitly_enabled_ = true;
     // TODO(zmo): Look into shader_texture_lod_explicitly_enabled_ situation.
 
     // Create a fake default transform feedback and bind to it.
     GLuint default_transform_feedback = 0;
     glGenTransformFeedbacks(1, &default_transform_feedback);
     state_.default_transform_feedback =
         transform_feedback_manager_->CreateTransformFeedback(
@@ skipping 4470 matching lines @@
     GLenum texture_target = texture_ref->texture()->target();
     if (texture_target != GLES2Util::GLFaceTargetToTextureTarget(textarget)) {
       LOCAL_SET_GL_ERROR(
           GL_INVALID_OPERATION,
           name, "Attachment textarget doesn't match texture target");
       return;
     }
     service_id = texture_ref->service_id();
   }
 
-  if ((level > 0 && !feature_info_->IsES3Enabled()) ||
+  if ((level > 0 && !feature_info_->IsWebGL2OrES3Context()) ||
       !texture_manager()->ValidForTarget(textarget, level, 0, 0, 1)) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE,
         name, "level out of range");
     return;
   }
 
   if (texture_ref)
     DoCopyTexImageIfNeeded(texture_ref->texture(), textarget);
 
@@ skipping 4570 matching lines @@
                                   int level,
                                   unsigned format,
                                   unsigned type,
                                   int xoffset,
                                   int yoffset,
                                   int width,
                                   int height) {
   DCHECK(target != GL_TEXTURE_3D && target != GL_TEXTURE_2D_ARRAY);
   uint32_t channels = GLES2Util::GetChannelsForFormat(format);
   if ((feature_info_->feature_flags().angle_depth_texture ||
-       feature_info_->IsES3Enabled())
+       feature_info_->IsWebGL2OrES3Context())
       && (channels & GLES2Util::kDepth) != 0) {
     // It's a depth format and ANGLE doesn't allow texImage2D or texSubImage2D
     // on depth formats.
     GLuint fb = 0;
     glGenFramebuffersEXT(1, &fb);
     glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, fb);
 
     glFramebufferTexture2DEXT(GL_DRAW_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT,
                               target, texture->service_id(), level);
     bool have_stencil = (channels & GLES2Util::kStencil) != 0;
@@ skipping 84 matching lines @@
                                                    unsigned target,
                                                    int level,
                                                    unsigned format,
                                                    int width,
                                                    int height) {
   DCHECK(target != GL_TEXTURE_3D && target != GL_TEXTURE_2D_ARRAY);
   // This code path can only be called if the texture was originally
   // allocated via TexStorage2D. Note that TexStorage2D is exposed
   // internally for ES 2.0 contexts, but compressed texture support is
   // not part of that exposure.
-  DCHECK(feature_info_->IsES3Enabled());
+  DCHECK(feature_info_->IsWebGL2OrES3Context());
 
   GLsizei bytes_required = 0;
   if (!GetCompressedTexSizeInBytes(
           "ClearCompressedTextureLevel", width, height, 1, format,
           &bytes_required)) {
     return false;
   }
 
   TRACE_EVENT1("gpu", "GLES2DecoderImpl::ClearCompressedTextureLevel",
                "bytes_required", bytes_required);
@@ skipping 23 matching lines @@
 
 bool GLES2DecoderImpl::ClearLevel3D(Texture* texture,
                                     unsigned target,
                                     int level,
                                     unsigned format,
                                     unsigned type,
                                     int width,
                                     int height,
                                     int depth) {
   DCHECK(target == GL_TEXTURE_3D || target == GL_TEXTURE_2D_ARRAY);
-  DCHECK(feature_info_->IsES3Enabled());
+  DCHECK(feature_info_->IsWebGL2OrES3Context());
   if (width == 0 || height == 0 || depth == 0)
     return true;
 
   uint32_t size;
   uint32_t padded_row_size;
   uint32_t padding;
   // Here we use unpack buffer to upload zeros into the texture, one layer
   // at a time.
   // We only take into consideration UNPACK_ALIGNMENT, and clear other unpack
   // parameters if necessary before TexSubImage3D calls.
@@ skipping 737 matching lines @@
     }
     data = GetSharedMemoryAs<const void*>(
         data_shm_id, data_shm_offset, image_size);
   }
   return DoCompressedTexImage(target, level, internal_format, width, height, 1,
                               border, image_size, data, ContextState::k2D);
 }
 
 error::Error GLES2DecoderImpl::HandleCompressedTexImage3DBucket(
     uint32_t immediate_data_size, const volatile void* cmd_data) {
-  if (!unsafe_es3_apis_enabled())
+  if (!feature_info_->IsWebGL2OrES3Context())
     return error::kUnknownCommand;
   const volatile gles2::cmds::CompressedTexImage3DBucket& c =
       *static_cast<const volatile gles2::cmds::CompressedTexImage3DBucket*>(
           cmd_data);
   GLenum target = static_cast<GLenum>(c.target);
   GLint level = static_cast<GLint>(c.level);
   GLenum internal_format = static_cast<GLenum>(c.internalformat);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
   GLsizei depth = static_cast<GLsizei>(c.depth);
   GLuint bucket_id = static_cast<GLuint>(c.bucket_id);
   GLint border = static_cast<GLint>(c.border);
 
   if (state_.bound_pixel_unpack_buffer.get()) {
     return error::kInvalidArguments;
   }
   Bucket* bucket = GetBucket(bucket_id);
   if (!bucket)
     return error::kInvalidArguments;
   uint32_t image_size = bucket->size();
   const void* data = bucket->GetData(0, image_size);
   DCHECK(data || !image_size);
   return DoCompressedTexImage(target, level, internal_format, width, height,
                               depth, border, image_size, data,
                               ContextState::k3D);
 }
 
 error::Error GLES2DecoderImpl::HandleCompressedTexImage3D(
     uint32_t immediate_data_size, const volatile void* cmd_data) {
-  if (!unsafe_es3_apis_enabled())
+  if (!feature_info_->IsWebGL2OrES3Context())
     return error::kUnknownCommand;
   const volatile gles2::cmds::CompressedTexImage3D& c =
       *static_cast<const volatile gles2::cmds::CompressedTexImage3D*>(cmd_data);
   GLenum target = static_cast<GLenum>(c.target);
   GLint level = static_cast<GLint>(c.level);
   GLenum internal_format = static_cast<GLenum>(c.internalformat);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
   GLsizei depth = static_cast<GLsizei>(c.depth);
   GLint border = static_cast<GLint>(c.border);
@@ skipping 14 matching lines @@
     data = GetSharedMemoryAs<const void*>(
         data_shm_id, data_shm_offset, image_size);
   }
   return DoCompressedTexImage(target, level, internal_format, width, height,
                               depth, border, image_size, data,
                               ContextState::k3D);
 }
 
 error::Error GLES2DecoderImpl::HandleCompressedTexSubImage3DBucket(
     uint32_t immediate_data_size, const volatile void* cmd_data) {
-  if (!unsafe_es3_apis_enabled())
+  if (!feature_info_->IsWebGL2OrES3Context())
     return error::kUnknownCommand;
   const volatile gles2::cmds::CompressedTexSubImage3DBucket& c =
       *static_cast<const volatile gles2::cmds::CompressedTexSubImage3DBucket*>(
           cmd_data);
   GLenum target = static_cast<GLenum>(c.target);
   GLint level = static_cast<GLint>(c.level);
   GLint xoffset = static_cast<GLint>(c.xoffset);
   GLint yoffset = static_cast<GLint>(c.yoffset);
   GLint zoffset = static_cast<GLint>(c.zoffset);
   GLsizei width = static_cast<GLsizei>(c.width);
@@ skipping 11 matching lines @@
   uint32_t image_size = bucket->size();
   const void* data = bucket->GetData(0, image_size);
   DCHECK(data || !image_size);
   return DoCompressedTexSubImage(target, level, xoffset, yoffset, zoffset,
                                  width, height, depth, format, image_size,
                                  data, ContextState::k3D);
 }
 
 error::Error GLES2DecoderImpl::HandleCompressedTexSubImage3D(
     uint32_t immediate_data_size, const volatile void* cmd_data) {
-  if (!unsafe_es3_apis_enabled())
+  if (!feature_info_->IsWebGL2OrES3Context())
     return error::kUnknownCommand;
   const volatile gles2::cmds::CompressedTexSubImage3D& c =
       *static_cast<const volatile gles2::cmds::CompressedTexSubImage3D*>(
           cmd_data);
   GLenum target = static_cast<GLenum>(c.target);
   GLint level = static_cast<GLint>(c.level);
   GLint xoffset = static_cast<GLint>(c.xoffset);
   GLint yoffset = static_cast<GLint>(c.yoffset);
   GLint zoffset = static_cast<GLint>(c.zoffset);
   GLsizei width = static_cast<GLsizei>(c.width);
@@ skipping 509 matching lines @@
   }
   // Check we have compatible formats.
   uint32_t channels_exist = GLES2Util::GetChannelsForFormat(read_format);
   uint32_t channels_needed = GLES2Util::GetChannelsForFormat(internal_format);
   if (!channels_needed ||
       (channels_needed & channels_exist) != channels_needed) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION, func_name, "incompatible format");
     return false;
   }
-  if (feature_info_->IsES3Enabled()) {
+  if (feature_info_->IsWebGL2OrES3Context()) {
     GLint color_encoding = GetColorEncodingFromInternalFormat(read_format);
     if (color_encoding != GetColorEncodingFromInternalFormat(internal_format) ||
         GLES2Util::IsFloatFormat(internal_format) ||
         (GLES2Util::IsSignedIntegerFormat(internal_format) !=
          GLES2Util::IsSignedIntegerFormat(read_format)) ||
         (GLES2Util::IsUnsignedIntegerFormat(internal_format) !=
          GLES2Util::IsUnsignedIntegerFormat(read_format))) {
       LOCAL_SET_GL_ERROR(
           GL_INVALID_OPERATION, func_name, "incompatible format");
       return false;
     }
   }
   if ((channels_needed & (GLES2Util::kDepth | GLES2Util::kStencil)) != 0) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         func_name, "can not be used with depth or stencil textures");
     return false;
   }
-  if (feature_info_->IsES3Enabled()) {
+  if (feature_info_->IsWebGL2OrES3Context()) {
     if (GLES2Util::IsSizedColorFormat(internal_format)) {
       int sr, sg, sb, sa;
       GLES2Util::GetColorFormatComponentSizes(
           read_format, read_type, &sr, &sg, &sb, &sa);
       DCHECK(sr > 0 || sg > 0 || sb > 0 || sa > 0);
       int dr, dg, db, da;
       GLES2Util::GetColorFormatComponentSizes(
           internal_format, 0, &dr, &dg, &db, &da);
       DCHECK(dr > 0 || dg > 0 || db > 0 || da > 0);
       if ((dr > 0 && sr != dr) ||
@@ skipping 1905 matching lines @@
       break;
     case GL_TIME_ELAPSED:
       if (!query_manager_->GPUTimingAvailable()) {
         LOCAL_SET_GL_ERROR(
             GL_INVALID_OPERATION, "glBeginQueryEXT",
             "not enabled for timing queries");
         return error::kNoError;
       }
       break;
     case GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN:
-      if (feature_info_->IsES3Enabled()) {
+      if (feature_info_->IsWebGL2OrES3Context()) {
         break;
       }
       // Fall through.
     default:
       LOCAL_SET_GL_ERROR(
           GL_INVALID_ENUM, "glBeginQueryEXT",
           "unknown query target");
       return error::kNoError;
   }
 
@@ skipping 3113 matching lines @@
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "base/macros.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu