remove 'unsafe' from ES3 apis in gpu process

gpu/command_buffer/service/texture_manager.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/texture_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 314 matching lines @@
 
   // TODO(dshwang): check if it's possible to remove
   // CHROMIUM_color_buffer_float_rgb. crbug.com/329605
   if ((feature_info->feature_flags().chromium_color_buffer_float_rgb &&
        internal_format == GL_RGB32F) ||
       (feature_info->feature_flags().chromium_color_buffer_float_rgba &&
        internal_format == GL_RGBA32F)) {
     return true;
   }
 
-  return feature_info->IsES3Enabled();
+  return feature_info->IsWebGL2OrES3Context();
 }
 
 // A 32-bit and 64-bit compatible way of converting a pointer to a GLuint.
 GLuint ToGLuint(const void* ptr) {
   return static_cast<GLuint>(reinterpret_cast<size_t>(ptr));
 }
 
 base::LazyInstance<const FormatTypeValidator>::Leaky g_format_type_validator =
     LAZY_INSTANCE_INITIALIZER;
 
@@ skipping 266 matching lines @@
       sampler_state.mag_filter != GL_NEAREST) {
     DCHECK(!face_infos_.empty());
     DCHECK_LT(static_cast<size_t>(base_level_),
               face_infos_[0].level_infos.size());
     const Texture::LevelInfo& first_level =
         face_infos_[0].level_infos[base_level_];
     if ((GLES2Util::GetChannelsForFormat(first_level.internal_format) &
          (GLES2Util::kDepth | GLES2Util::kStencil)) != 0) {
       if (sampler_state.compare_mode == GL_NONE) {
         // In ES2 with OES_depth_texture, such limitation isn't specified.
-        if (feature_info->IsES3Enabled()) {
+        if (feature_info->IsWebGL2OrES3Context()) {
           return false;
         }
       }
     } else if (feature_info->validators()->compressed_texture_format.IsValid(
         first_level.internal_format)) {
       // TODO(zmo): The assumption that compressed textures are all filterable
       // may not be true in the future.
     } else {
       if (!Texture::TextureFilterable(feature_info, first_level.internal_format,
                                       first_level.type, immutable_)) {
         return false;
       }
     }
   }
 
-  if (!feature_info->IsES3Enabled()) {
+  if (!feature_info->IsWebGL2OrES3Context()) {
     bool is_npot_compatible = !needs_mips &&
         sampler_state.wrap_s == GL_CLAMP_TO_EDGE &&
         sampler_state.wrap_t == GL_CLAMP_TO_EDGE;
 
     if (!is_npot_compatible) {
       if (target_ == GL_TEXTURE_RECTANGLE_ARB)
         return false;
       else if (npot())
         return feature_info->feature_flags().npot_ok;
     }
@@ skipping 1226 matching lines @@
 
   // TODO(gman): The default textures have to be real textures, not the 0
   // texture because we simulate non shared resources on top of shared
   // resources and all contexts that share resource share the same default
   // texture.
   default_textures_[kTexture2D] = CreateDefaultAndBlackTextures(
       GL_TEXTURE_2D, &black_texture_ids_[kTexture2D]);
   default_textures_[kCubeMap] = CreateDefaultAndBlackTextures(
       GL_TEXTURE_CUBE_MAP, &black_texture_ids_[kCubeMap]);
 
-  if (feature_info_->IsES3Enabled()) {
+  if (feature_info_->IsWebGL2OrES3Context()) {
     default_textures_[kTexture3D] = CreateDefaultAndBlackTextures(
         GL_TEXTURE_3D, &black_texture_ids_[kTexture3D]);
     default_textures_[kTexture2DArray] = CreateDefaultAndBlackTextures(
         GL_TEXTURE_2D_ARRAY, &black_texture_ids_[kTexture2DArray]);
   }
 
   if (feature_info_->feature_flags().oes_egl_image_external ||
       feature_info_->feature_flags().nv_egl_stream_consumer_external) {
     default_textures_[kExternalOES] = CreateDefaultAndBlackTextures(
         GL_TEXTURE_EXTERNAL_OES, &black_texture_ids_[kExternalOES]);
@@ skipping 410 matching lines @@
   if (!g_format_type_validator.Get().IsValid(internal_format, format, type)) {
     std::string msg = std::string(
         "invalid internalformat/format/type combination ") +
         GLES2Util::GetStringEnum(internal_format) + std::string("/") +
         GLES2Util::GetStringEnum(format) + std::string("/") +
         GLES2Util::GetStringEnum(type);
     ERRORSTATE_SET_GL_ERROR(error_state, GL_INVALID_OPERATION, function_name,
                             msg.c_str());
     return false;
   }
-  if (!feature_info_->IsES3Enabled()) {
+  if (!feature_info_->IsWebGL2OrES3Context()) {
     uint32_t channels = GLES2Util::GetChannelsForFormat(format);
     if ((channels & (GLES2Util::kDepth | GLES2Util::kStencil)) != 0 && level) {
       ERRORSTATE_SET_GL_ERROR(
           error_state, GL_INVALID_OPERATION, function_name,
           (std::string("invalid format ") + GLES2Util::GetStringEnum(format) +
            " for level != 0").c_str());
       return false;
     }
   }
   return true;
@@ skipping 77 matching lines @@
   if (!ValidForTarget(args.target, args.level,
                       args.width, args.height, args.depth) ||
       args.border != 0) {
     ERRORSTATE_SET_GL_ERROR(
         error_state, GL_INVALID_VALUE, function_name,
         "dimensions out of range");
     return false;
   }
   if ((GLES2Util::GetChannelsForFormat(args.format) &
        (GLES2Util::kDepth | GLES2Util::kStencil)) != 0 && args.pixels
-      && !feature_info_->IsES3Enabled()) {
+      && !feature_info_->IsWebGL2OrES3Context()) {
     ERRORSTATE_SET_GL_ERROR(
         error_state, GL_INVALID_OPERATION,
         function_name, "can not supply data for depth or stencil textures");
     return false;
   }
 
   TextureRef* local_texture_ref = GetTextureInfoForTarget(state, args.target);
   if (!local_texture_ref) {
     ERRORSTATE_SET_GL_ERROR(
         error_state, GL_INVALID_OPERATION, function_name,
@@ skipping 110 matching lines @@
   TextureRef* texture_ref;
   if (!ValidateTexImage(state, function_name, args, &texture_ref)) {
     return;
   }
 
   Buffer* buffer = state->bound_pixel_unpack_buffer.get();
 
   // ValidateTexImage is passed already.
   Texture* texture = texture_ref->texture();
   bool need_cube_map_workaround =
-      !feature_info_->IsES3Enabled() &&
+      !feature_info_->IsWebGL2OrES3Context() &&
       texture->target() == GL_TEXTURE_CUBE_MAP &&
       (texture_state->force_cube_complete ||
        (texture_state->force_cube_map_positive_x_allocation &&
         args.target != GL_TEXTURE_CUBE_MAP_POSITIVE_X));
   if (need_cube_map_workaround && !buffer) {
     DoCubeMapWorkaround(texture_state, state, framebuffer_state,
                         texture_ref, function_name, args);
   }
 
   if (texture_state->unpack_overlapping_rows_separately_unpack_buffer &&
@@ skipping 131 matching lines @@
     std::string msg = base::StringPrintf(
         "level %d does not exist", args.level);
     ERRORSTATE_SET_GL_ERROR(error_state, GL_INVALID_OPERATION, function_name,
                             msg.c_str());
     return false;
   }
   if (!ValidateTextureParameters(error_state, function_name, false, args.format,
                                  args.type, internal_format, args.level)) {
     return false;
   }
-  if (args.type != current_type && !feature_info_->IsES3Enabled()) {
+  if (args.type != current_type && !feature_info_->IsWebGL2OrES3Context()) {
     // It isn't explicitly required in the ES2 spec, but some drivers generate
     // an error. It is better to be consistent across drivers.
     ERRORSTATE_SET_GL_ERROR(error_state, GL_INVALID_OPERATION, function_name,
                             "type does not match type of texture.");
     return false;
   }
   if (!texture->ValidForTexture(args.target, args.level,
                                 args.xoffset, args.yoffset, args.zoffset,
                                 args.width, args.height, args.depth)) {
     ERRORSTATE_SET_GL_ERROR(error_state, GL_INVALID_VALUE, function_name,
                             "bad dimensions.");
     return false;
   }
   if ((GLES2Util::GetChannelsForFormat(args.format) &
        (GLES2Util::kDepth | GLES2Util::kStencil)) != 0 &&
-      !feature_info_->IsES3Enabled()) {
+      !feature_info_->IsWebGL2OrES3Context()) {
     ERRORSTATE_SET_GL_ERROR(
         error_state, GL_INVALID_OPERATION, function_name,
         "can not supply data for depth or stencil textures");
     return false;
   }
 
   Buffer* buffer = state->bound_pixel_unpack_buffer.get();
   if (buffer) {
     if (buffer->GetMappedRange()) {
       ERRORSTATE_SET_GL_ERROR(
@@ skipping 883 matching lines @@
 uint32_t TextureManager::GetServiceIdGeneration() const {
   return current_service_id_generation_;
 }
 
 void TextureManager::IncrementServiceIdGeneration() {
   current_service_id_generation_++;
 }
 
 }  // namespace gles2
 }  // namespace gpu