gpu: Remove async texture uploads.

gpu/command_buffer/service/gles2_cmd_decoder.cc

Index: gpu/command_buffer/service/gles2_cmd_decoder.cc
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder.cc b/gpu/command_buffer/service/gles2_cmd_decoder.cc
index 74f3401b497a4995a3d0e38a40c4bc21374d0a47..6c9571923d1c72f5818a60426da9e65ed4a4c0c8 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder.cc
@@ -29,8 +29,6 @@
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/common/mailbox.h"
-#include "gpu/command_buffer/service/async_pixel_transfer_delegate.h"
-#include "gpu/command_buffer/service/async_pixel_transfer_manager.h"
 #include "gpu/command_buffer/service/buffer_manager.h"
 #include "gpu/command_buffer/service/context_group.h"
 #include "gpu/command_buffer/service/context_state.h"
@@ -558,28 +556,6 @@ struct FenceCallback {
   scoped_ptr<gfx::GLFence> fence;
 };
 
-class AsyncUploadTokenCompletionObserver
-    : public AsyncPixelTransferCompletionObserver {
- public:
-  explicit AsyncUploadTokenCompletionObserver(uint32 async_upload_token)
-      : async_upload_token_(async_upload_token) {
-  }
-
-  void DidComplete(const AsyncMemoryParams& mem_params) override {
-    DCHECK(mem_params.buffer().get());
-    void* data = mem_params.GetDataAddress();
-    AsyncUploadSync* sync = static_cast<AsyncUploadSync*>(data);
-    sync->SetAsyncUploadToken(async_upload_token_);
-  }
-
- private:
-  ~AsyncUploadTokenCompletionObserver() override {}
-
-  uint32 async_upload_token_;
-
-  DISALLOW_COPY_AND_ASSIGN(AsyncUploadTokenCompletionObserver);
-};
-
 // }  // anonymous namespace.
 
 // static
@@ -708,10 +684,6 @@ class GLES2DecoderImpl : public GLES2Decoder,
   void SetShaderCacheCallback(const ShaderCacheCallback& callback) override;
   void SetWaitSyncPointCallback(const WaitSyncPointCallback& callback) override;
 
-  AsyncPixelTransferManager* GetAsyncPixelTransferManager() override;
-  void ResetAsyncPixelTransferManagerForTest() override;
-  void SetAsyncPixelTransferManagerForTest(
-      AsyncPixelTransferManager* manager) override;
   void SetIgnoreCachedStateForTest(bool ignore) override;
   void ProcessFinishedAsyncTransfers();
 
@@ -796,13 +768,6 @@ class GLES2DecoderImpl : public GLES2Decoder,
   bool GenPathsCHROMIUMHelper(GLuint first_client_id, GLsizei range);
   bool DeletePathsCHROMIUMHelper(GLuint first_client_id, GLsizei range);
 
-  // Helper for async upload token completion notification callback.
-  base::Closure AsyncUploadTokenCompletionClosure(uint32 async_upload_token,
-                                                  uint32 sync_data_shm_id,
-                                                  uint32 sync_data_shm_offset);
-
-
-
   // Workarounds
   void OnFboChanged() const;
   void OnUseFramebuffer() const;
@@ -1022,14 +987,6 @@ class GLES2DecoderImpl : public GLES2Decoder,
       GLenum type,
       const void * data);
 
-  // Extra validation for async tex(Sub)Image2D.
-  bool ValidateAsyncTransfer(
-      const char* function_name,
-      TextureRef* texture_ref,
-      GLenum target,
-      GLint level,
-      const void * data);
-
   // Wrapper for TexImageIOSurface2DCHROMIUM.
   void DoTexImageIOSurface2DCHROMIUM(
       GLenum target,
@@ -1983,8 +1940,6 @@ class GLES2DecoderImpl : public GLES2Decoder,
 
   ShaderCacheCallback shader_cache_callback_;
 
-  scoped_ptr<AsyncPixelTransferManager> async_pixel_transfer_manager_;
-
   // The format of the back buffer_
   GLenum back_buffer_color_format_;
   bool back_buffer_has_depth_;
@@ -3053,10 +3008,6 @@ bool GLES2DecoderImpl::Initialize(
   if (!offscreen)
     context_->SetSafeToForceGpuSwitch();
 
-  async_pixel_transfer_manager_.reset(
-      AsyncPixelTransferManager::Create(context.get()));
-  async_pixel_transfer_manager_->Initialize(texture_manager());
-
   if (workarounds().gl_clear_broken) {
     DCHECK(!clear_framebuffer_blit_.get());
     LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("glClearWorkaroundInit");
@@ -3614,13 +3565,6 @@ void GLES2DecoderImpl::ProcessFinishedAsyncTransfers() {
   ProcessPendingReadPixels(false);
   if (engine() && query_manager_.get())
     query_manager_->ProcessPendingTransferQueries();
-
-  // TODO(epenner): Is there a better place to do this?
-  // This needs to occur before we execute any batch of commands
-  // from the client, as the client may have recieved an async
-  // completion while issuing those commands.
-  // "DidFlushStart" would be ideal if we had such a callback.
-  async_pixel_transfer_manager_->BindCompletedAsyncTransfers();
 }
 
 static void RebindCurrentFramebuffer(
@@ -3904,20 +3848,6 @@ void GLES2DecoderImpl::SetWaitSyncPointCallback(
   wait_sync_point_callback_ = callback;
 }
 
-AsyncPixelTransferManager*
-    GLES2DecoderImpl::GetAsyncPixelTransferManager() {
-  return async_pixel_transfer_manager_.get();
-}
-
-void GLES2DecoderImpl::ResetAsyncPixelTransferManagerForTest() {
-  async_pixel_transfer_manager_.reset();
-}
-
-void GLES2DecoderImpl::SetAsyncPixelTransferManagerForTest(
-    AsyncPixelTransferManager* manager) {
-  async_pixel_transfer_manager_ = make_scoped_ptr(manager);
-}
-
 bool GLES2DecoderImpl::GetServiceTextureId(uint32 client_texture_id,
                                            uint32* service_texture_id) {
   TextureRef* texture_ref = texture_manager()->GetTexture(client_texture_id);
@@ -3929,13 +3859,11 @@ bool GLES2DecoderImpl::GetServiceTextureId(uint32 client_texture_id,
 }
 
 uint32 GLES2DecoderImpl::GetTextureUploadCount() {
-  return texture_state_.texture_upload_count +
-         async_pixel_transfer_manager_->GetTextureUploadCount();
+  return texture_state_.texture_upload_count;
 }
 
 base::TimeDelta GLES2DecoderImpl::GetTotalTextureUploadTime() {
-  return texture_state_.total_texture_upload_time +
-         async_pixel_transfer_manager_->GetTotalTextureUploadTime();
+  return texture_state_.total_texture_upload_time;
 }
 
 base::TimeDelta GLES2DecoderImpl::GetTotalProcessingCommandsTime() {
@@ -4080,10 +4008,6 @@ void GLES2DecoderImpl::Destroy(bool have_context) {
   fragment_translator_ = NULL;
   vertex_translator_ = NULL;
 
-  // Should destroy the transfer manager before the texture manager held
-  // by the context group.
-  async_pixel_transfer_manager_.reset();
-
   // Destroy the GPU Tracer which may own some in process GPU Timings.
   if (gpu_tracer_) {
     gpu_tracer_->Destroy(have_context);
@@ -10304,12 +10228,6 @@ void GLES2DecoderImpl::DoCopyTexSubImage2D(
         GL_INVALID_VALUE, "glCopyTexSubImage2D", "bad dimensions.");
     return;
   }
-  if (async_pixel_transfer_manager_->AsyncTransferIsInProgress(texture_ref)) {
-    LOCAL_SET_GL_ERROR(
-        GL_INVALID_OPERATION,
-        "glCopyTexSubImage2D", "async upload pending for texture");
-    return;
-  }
 
   // Check we have compatible formats.
   GLenum read_format = GetBoundReadFrameBufferInternalFormat();
@@ -10466,12 +10384,6 @@ bool GLES2DecoderImpl::ValidateTexSubImage2D(
         function_name, "type does not match type of texture.");
     return false;
   }
-  if (async_pixel_transfer_manager_->AsyncTransferIsInProgress(texture_ref)) {
-    LOCAL_SET_GL_ERROR(
-        GL_INVALID_OPERATION,
-        function_name, "async upload pending for texture");
-    return false;
-  }
   if (!texture->ValidForTexture(
           target, level, xoffset, yoffset, 0, width, height, 1, type)) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, function_name, "bad dimensions.");
@@ -11737,17 +11649,12 @@ void GLES2DecoderImpl::ProcessPendingReadPixels(bool did_finish) {
 
 bool GLES2DecoderImpl::HasMoreIdleWork() {
   return !pending_readpixel_fences_.empty() ||
-      async_pixel_transfer_manager_->NeedsProcessMorePendingTransfers() ||
-      gpu_tracer_->HasTracesToProcess();
+         gpu_tracer_->HasTracesToProcess();
 }
 
 void GLES2DecoderImpl::PerformIdleWork() {
   gpu_tracer_->ProcessTraces();
   ProcessPendingReadPixels(false);
-  if (!async_pixel_transfer_manager_->NeedsProcessMorePendingTransfers())
-    return;
-  async_pixel_transfer_manager_->ProcessMorePendingTransfers();
-  ProcessFinishedAsyncTransfers();
 }
 
 error::Error GLES2DecoderImpl::HandleBeginQueryEXT(uint32 immediate_data_size,
@@ -11762,7 +11669,6 @@ error::Error GLES2DecoderImpl::HandleBeginQueryEXT(uint32 immediate_data_size,
   switch (target) {
     case GL_COMMANDS_ISSUED_CHROMIUM:
     case GL_LATENCY_QUERY_CHROMIUM:
-    case GL_ASYNC_PIXEL_UNPACK_COMPLETED_CHROMIUM:
     case GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM:
     case GL_GET_ERROR_QUERY_CHROMIUM:
       break;
@@ -13772,312 +13678,6 @@ void GLES2DecoderImpl::DoMatrixLoadIdentityCHROMIUM(GLenum matrix_mode) {
   glMatrixLoadIdentityEXT(matrix_mode);
 }
 
-bool GLES2DecoderImpl::ValidateAsyncTransfer(
-    const char* function_name,
-    TextureRef* texture_ref,
-    GLenum target,
-    GLint level,
-    const void * data) {
-  // We only support async uploads to 2D textures for now.
-  if (GL_TEXTURE_2D != target) {
-    LOCAL_SET_GL_ERROR_INVALID_ENUM(function_name, target, "target");
-    return false;
-  }
-  // We only support uploads to level zero for now.
-  if (level != 0) {
-    LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, function_name, "level != 0");
-    return false;
-  }
-  // A transfer buffer must be bound, even for asyncTexImage2D.
-  if (data == NULL) {
-    LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, function_name, "buffer == 0");
-    return false;
-  }
-  // We only support one async transfer in progress.
-  if (!texture_ref ||
-      async_pixel_transfer_manager_->AsyncTransferIsInProgress(texture_ref)) {
-    LOCAL_SET_GL_ERROR(
-        GL_INVALID_OPERATION,
-        function_name, "transfer already in progress");
-    return false;
-  }
-  return true;
-}
-
-base::Closure GLES2DecoderImpl::AsyncUploadTokenCompletionClosure(
-    uint32 async_upload_token,
-    uint32 sync_data_shm_id,
-    uint32 sync_data_shm_offset) {
-  scoped_refptr<gpu::Buffer> buffer = GetSharedMemoryBuffer(sync_data_shm_id);
-  if (!buffer.get() ||
-      !buffer->GetDataAddress(sync_data_shm_offset, sizeof(AsyncUploadSync)))
-    return base::Closure();
-
-  AsyncMemoryParams mem_params(buffer,
-                               sync_data_shm_offset,
-                               sizeof(AsyncUploadSync));
-
-  scoped_refptr<AsyncUploadTokenCompletionObserver> observer(
-      new AsyncUploadTokenCompletionObserver(async_upload_token));
-
-  return base::Bind(
-      &AsyncPixelTransferManager::AsyncNotifyCompletion,
-      base::Unretained(GetAsyncPixelTransferManager()),
-      mem_params,
-      observer);
-}
-
-error::Error GLES2DecoderImpl::HandleAsyncTexImage2DCHROMIUM(
-    uint32 immediate_data_size,
-    const void* cmd_data) {
-  const gles2::cmds::AsyncTexImage2DCHROMIUM& c =
-      *static_cast<const gles2::cmds::AsyncTexImage2DCHROMIUM*>(cmd_data);
-  TRACE_EVENT0("gpu", "GLES2DecoderImpl::HandleAsyncTexImage2DCHROMIUM");
-  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);
-  GLint border = static_cast<GLint>(c.border);
-  GLenum format = static_cast<GLenum>(c.format);
-  GLenum type = static_cast<GLenum>(c.type);
-  uint32 pixels_shm_id = static_cast<uint32>(c.pixels_shm_id);
-  uint32 pixels_shm_offset = static_cast<uint32>(c.pixels_shm_offset);
-  uint32 pixels_size;
-  uint32 async_upload_token = static_cast<uint32>(c.async_upload_token);
-  uint32 sync_data_shm_id = static_cast<uint32>(c.sync_data_shm_id);
-  uint32 sync_data_shm_offset = static_cast<uint32>(c.sync_data_shm_offset);
-
-  base::ScopedClosureRunner scoped_completion_callback;
-  if (async_upload_token) {
-    base::Closure completion_closure =
-        AsyncUploadTokenCompletionClosure(async_upload_token,
-                                          sync_data_shm_id,
-                                          sync_data_shm_offset);
-    if (completion_closure.is_null())
-      return error::kInvalidArguments;
-
-    scoped_completion_callback.Reset(completion_closure);
-  }
-
-  // TODO(epenner): Move this and copies of this memory validation
-  // into ValidateTexImage2D step.
-  if (!GLES2Util::ComputeImageDataSizes(
-      width, height, 1, format, type, state_.unpack_alignment, &pixels_size,
-      NULL, NULL)) {
-    return error::kOutOfBounds;
-  }
-  const void* pixels = NULL;
-  if (pixels_shm_id != 0 || pixels_shm_offset != 0) {
-    pixels = GetSharedMemoryAs<const void*>(
-        pixels_shm_id, pixels_shm_offset, pixels_size);
-    if (!pixels) {
-      return error::kOutOfBounds;
-    }
-  }
-
-  TextureManager::DoTexImageArguments args = {
-    target, level, internal_format, width, height, 1, border, format, type,
-    pixels, pixels_size, TextureManager::DoTexImageArguments::kTexImage2D };
-  TextureRef* texture_ref;
-  // All the normal glTexSubImage2D validation.
-  if (!texture_manager()->ValidateTexImage(
-      &state_, "glAsyncTexImage2DCHROMIUM", args, &texture_ref)) {
-    return error::kNoError;
-  }
-
-  // Extra async validation.
-  Texture* texture = texture_ref->texture();
-  if (!ValidateAsyncTransfer(
-      "glAsyncTexImage2DCHROMIUM", texture_ref, target, level, pixels))
-    return error::kNoError;
-
-  // Don't allow async redefinition of a textures.
-  if (texture->IsDefined()) {
-    LOCAL_SET_GL_ERROR(
-        GL_INVALID_OPERATION,
-        "glAsyncTexImage2DCHROMIUM", "already defined");
-    return error::kNoError;
-  }
-
-  if (!EnsureGPUMemoryAvailable(pixels_size)) {
-    LOCAL_SET_GL_ERROR(
-        GL_OUT_OF_MEMORY, "glAsyncTexImage2DCHROMIUM", "out of memory");
-    return error::kNoError;
-  }
-
-  // Setup the parameters.
-  AsyncTexImage2DParams tex_params = {
-      target, level, static_cast<GLenum>(internal_format),
-      width, height, border, format, type};
-  AsyncMemoryParams mem_params(
-      GetSharedMemoryBuffer(c.pixels_shm_id), c.pixels_shm_offset, pixels_size);
-
-  // Set up the async state if needed, and make the texture
-  // immutable so the async state stays valid. The level info
-  // is set up lazily when the transfer completes.
-  AsyncPixelTransferDelegate* delegate =
-      async_pixel_transfer_manager_->CreatePixelTransferDelegate(texture_ref,
-                                                                 tex_params);
-  texture->SetImmutable(true);
-
-  delegate->AsyncTexImage2D(
-      tex_params,
-      mem_params,
-      base::Bind(&TextureManager::SetLevelInfoFromParams,
-                 // The callback is only invoked if the transfer delegate still
-                 // exists, which implies through manager->texture_ref->state
-                 // ownership that both of these pointers are valid.
-                 base::Unretained(texture_manager()),
-                 base::Unretained(texture_ref),
-                 tex_params));
-  return error::kNoError;
-}
-
-error::Error GLES2DecoderImpl::HandleAsyncTexSubImage2DCHROMIUM(
-    uint32 immediate_data_size,
-    const void* cmd_data) {
-  const gles2::cmds::AsyncTexSubImage2DCHROMIUM& c =
-      *static_cast<const gles2::cmds::AsyncTexSubImage2DCHROMIUM*>(cmd_data);
-  TRACE_EVENT0("gpu", "GLES2DecoderImpl::HandleAsyncTexSubImage2DCHROMIUM");
-  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);
-  GLsizei width = static_cast<GLsizei>(c.width);
-  GLsizei height = static_cast<GLsizei>(c.height);
-  GLenum format = static_cast<GLenum>(c.format);
-  GLenum type = static_cast<GLenum>(c.type);
-  uint32 async_upload_token = static_cast<uint32>(c.async_upload_token);
-  uint32 sync_data_shm_id = static_cast<uint32>(c.sync_data_shm_id);
-  uint32 sync_data_shm_offset = static_cast<uint32>(c.sync_data_shm_offset);
-
-  base::ScopedClosureRunner scoped_completion_callback;
-  if (async_upload_token) {
-    base::Closure completion_closure =
-        AsyncUploadTokenCompletionClosure(async_upload_token,
-                                          sync_data_shm_id,
-                                          sync_data_shm_offset);
-    if (completion_closure.is_null())
-      return error::kInvalidArguments;
-
-    scoped_completion_callback.Reset(completion_closure);
-  }
-
-  // TODO(epenner): Move this and copies of this memory validation
-  // into ValidateTexSubImage2D step.
-  uint32 data_size;
-  if (!GLES2Util::ComputeImageDataSizes(
-      width, height, 1, format, type, state_.unpack_alignment, &data_size,
-      NULL, NULL)) {
-    return error::kOutOfBounds;
-  }
-  const void* pixels = GetSharedMemoryAs<const void*>(
-      c.data_shm_id, c.data_shm_offset, data_size);
-
-  // All the normal glTexSubImage2D validation.
-  error::Error error = error::kNoError;
-  if (!ValidateTexSubImage2D(&error, "glAsyncTexSubImage2DCHROMIUM",
-      target, level, xoffset, yoffset, width, height, format, type, pixels)) {
-    return error;
-  }
-
-  // Extra async validation.
-  TextureRef* texture_ref = texture_manager()->GetTextureInfoForTarget(
-      &state_, target);
-  Texture* texture = texture_ref->texture();
-  if (!ValidateAsyncTransfer(
-         "glAsyncTexSubImage2DCHROMIUM", texture_ref, target, level, pixels))
-    return error::kNoError;
-
-  // Guarantee async textures are always 'cleared' as follows:
-  // - AsyncTexImage2D can not redefine an existing texture
-  // - AsyncTexImage2D must initialize the entire image via non-null buffer.
-  // - AsyncTexSubImage2D clears synchronously if not already cleared.
-  // - Textures become immutable after an async call.
-  // This way we know in all cases that an async texture is always clear.
-  if (!texture->SafeToRenderFrom()) {
-    if (!texture_manager()->ClearTextureLevel(this, texture_ref,
-                                              target, level)) {
-      LOCAL_SET_GL_ERROR(
-          GL_OUT_OF_MEMORY,
-          "glAsyncTexSubImage2DCHROMIUM", "dimensions too big");
-      return error::kNoError;
-    }
-  }
-
-  // Setup the parameters.
-  AsyncTexSubImage2DParams tex_params = {target, level, xoffset, yoffset,
-                                              width, height, format, type};
-  AsyncMemoryParams mem_params(
-      GetSharedMemoryBuffer(c.data_shm_id), c.data_shm_offset, data_size);
-  AsyncPixelTransferDelegate* delegate =
-      async_pixel_transfer_manager_->GetPixelTransferDelegate(texture_ref);
-  if (!delegate) {
-    // TODO(epenner): We may want to enforce exclusive use
-    // of async APIs in which case this should become an error,
-    // (the texture should have been async defined).
-    AsyncTexImage2DParams define_params = {target, level,
-                                                0, 0, 0, 0, 0, 0};
-    texture->GetLevelSize(
-        target, level, &define_params.width, &define_params.height, nullptr);
-    texture->GetLevelType(
-        target, level, &define_params.type, &define_params.internal_format);
-    // Set up the async state if needed, and make the texture
-    // immutable so the async state stays valid.
-    delegate = async_pixel_transfer_manager_->CreatePixelTransferDelegate(
-        texture_ref, define_params);
-    texture->SetImmutable(true);
-  }
-
-  delegate->AsyncTexSubImage2D(tex_params, mem_params);
-  return error::kNoError;
-}
-
-error::Error GLES2DecoderImpl::HandleWaitAsyncTexImage2DCHROMIUM(
-    uint32 immediate_data_size,
-    const void* cmd_data) {
-  const gles2::cmds::WaitAsyncTexImage2DCHROMIUM& c =
-      *static_cast<const gles2::cmds::WaitAsyncTexImage2DCHROMIUM*>(cmd_data);
-  TRACE_EVENT0("gpu", "GLES2DecoderImpl::HandleWaitAsyncTexImage2DCHROMIUM");
-  GLenum target = static_cast<GLenum>(c.target);
-
-  if (GL_TEXTURE_2D != target) {
-    LOCAL_SET_GL_ERROR(
-        GL_INVALID_ENUM, "glWaitAsyncTexImage2DCHROMIUM", "target");
-    return error::kNoError;
-  }
-  TextureRef* texture_ref = texture_manager()->GetTextureInfoForTarget(
-      &state_, target);
-  if (!texture_ref) {
-      LOCAL_SET_GL_ERROR(
-          GL_INVALID_OPERATION,
-          "glWaitAsyncTexImage2DCHROMIUM", "unknown texture");
-    return error::kNoError;
-  }
-  AsyncPixelTransferDelegate* delegate =
-      async_pixel_transfer_manager_->GetPixelTransferDelegate(texture_ref);
-  if (!delegate) {
-      LOCAL_SET_GL_ERROR(
-          GL_INVALID_OPERATION,
-          "glWaitAsyncTexImage2DCHROMIUM", "No async transfer started");
-    return error::kNoError;
-  }
-  delegate->WaitForTransferCompletion();
-  ProcessFinishedAsyncTransfers();
-  return error::kNoError;
-}
-
-error::Error GLES2DecoderImpl::HandleWaitAllAsyncTexImage2DCHROMIUM(
-    uint32 immediate_data_size,
-    const void* data) {
-  TRACE_EVENT0("gpu", "GLES2DecoderImpl::HandleWaitAsyncTexImage2DCHROMIUM");
-
-  GetAsyncPixelTransferManager()->WaitAllAsyncTexImage2D();
-  ProcessFinishedAsyncTransfers();
-  return error::kNoError;
-}
-
 error::Error GLES2DecoderImpl::HandleUniformBlockBinding(
     uint32_t immediate_data_size, const void* cmd_data) {
   if (!unsafe_es3_apis_enabled())