bcarrella
/
cef
mirror of https://bitbucket.org/chromiumembedded/cef
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Add support for V8 ArrayBuffers (issue #244)

This commit is contained in:
Christopher Cifra 2018-04-10 15:37:33 -04:00 committed by Marshall Greenblatt
parent bb28b85bdd
commit 4315f3b724
16 changed files with 775 additions and 8 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
cef_paths.gypi
View File

@ -8,7 +8,7 @@
# by hand. See the translator.README.txt file in the tools directory for
# more information.
#
# $hash=bede6f61d0f5b45669b8e924144e4200c41f869b$
# $hash=67bc21133e37f5361a39f25dcfe004616d467dbc$
#
{
@ -432,6 +432,8 @@
'libcef_dll/ctocpp/urlrequest_client_ctocpp.h',
'libcef_dll/ctocpp/v8accessor_ctocpp.cc',
'libcef_dll/ctocpp/v8accessor_ctocpp.h',
'libcef_dll/ctocpp/v8array_buffer_release_callback_ctocpp.cc',
'libcef_dll/ctocpp/v8array_buffer_release_callback_ctocpp.h',
'libcef_dll/cpptoc/v8context_cpptoc.cc',
'libcef_dll/cpptoc/v8context_cpptoc.h',
'libcef_dll/cpptoc/v8exception_cpptoc.cc',
@ -712,6 +714,8 @@
'libcef_dll/cpptoc/urlrequest_client_cpptoc.h',
'libcef_dll/cpptoc/v8accessor_cpptoc.cc',
'libcef_dll/cpptoc/v8accessor_cpptoc.h',
'libcef_dll/cpptoc/v8array_buffer_release_callback_cpptoc.cc',
'libcef_dll/cpptoc/v8array_buffer_release_callback_cpptoc.h',
'libcef_dll/ctocpp/v8context_ctocpp.cc',
'libcef_dll/ctocpp/v8context_ctocpp.h',
'libcef_dll/ctocpp/v8exception_ctocpp.cc',

60
include/capi/cef_v8_capi.h
View File

@ -33,7 +33,7 @@
// by hand. See the translator.README.txt file in the tools directory for
// more information.
//
// $hash=e9e43167b1cf8033bd7e6ba6931213d7cf4b69b5$
// $hash=2303574e76708e5311aede8e66eb7f1f679e0d1f$
//
#ifndef CEF_INCLUDE_CAPI_CEF_V8_CAPI_H_
@ -355,6 +355,25 @@ typedef struct _cef_v8exception_t {
int(CEF_CALLBACK* get_end_column)(struct _cef_v8exception_t* self);
} cef_v8exception_t;
///
// Callback structure that is passed to cef_v8value_t::CreateArrayBuffer.
///
typedef struct _cef_v8array_buffer_release_callback_t {
///
// Base structure.
///
cef_base_ref_counted_t base;
///
// Called to release |buffer| when the ArrayBuffer JS object is garbage
// collected. |buffer| is the value that was passed to CreateArrayBuffer along
// with this object.
///
void(CEF_CALLBACK* release_buffer)(
struct _cef_v8array_buffer_release_callback_t* self,
void* buffer);
} cef_v8array_buffer_release_callback_t;
///
// Structure representing a V8 value handle. V8 handles can only be accessed
// from the thread on which they are created. Valid threads for creating a V8
@ -425,6 +444,11 @@ typedef struct _cef_v8value_t {
///
int(CEF_CALLBACK* is_array)(struct _cef_v8value_t* self);
///
// True if the value type is an ArrayBuffer.
///
int(CEF_CALLBACK* is_array_buffer)(struct _cef_v8value_t* self);
///
// True if the value type is function.
///
@ -639,6 +663,25 @@ typedef struct _cef_v8value_t {
///
int(CEF_CALLBACK* get_array_length)(struct _cef_v8value_t* self);
// ARRAY BUFFER METHODS - These functions are only available on ArrayBuffers.
///
// Returns the ReleaseCallback object associated with the ArrayBuffer or NULL
// if the ArrayBuffer was not created with CreateArrayBuffer.
///
struct _cef_v8array_buffer_release_callback_t*(
CEF_CALLBACK* get_array_buffer_release_callback)(
struct _cef_v8value_t* self);
///
// Prevent the ArrayBuffer from using it's memory block by setting the length
// to zero. This operation cannot be undone. If the ArrayBuffer was created
// with CreateArrayBuffer then
// cef_v8array_buffer_release_callback_t::ReleaseBuffer will be called to
// release the underlying buffer.
///
int(CEF_CALLBACK* neuter_array_buffer)(struct _cef_v8value_t* self);
// FUNCTION METHODS - These functions are only available on functions.
///
@ -751,6 +794,21 @@ CEF_EXPORT cef_v8value_t* cef_v8value_create_object(
///
CEF_EXPORT cef_v8value_t* cef_v8value_create_array(int length);
///
// Create a new cef_v8value_t object of type ArrayBuffer which wraps the
// provided |buffer| of size |length| bytes. The ArrayBuffer is externalized,
// meaning that it does not own |buffer|. The caller is responsible for freeing
// |buffer| when requested via a call to cef_v8array_buffer_release_callback_t::
// ReleaseBuffer. This function should only be called from within the scope of a
// cef_render_process_handler_t, cef_v8handler_t or cef_v8accessor_t callback,
// or in combination with calling enter() and exit() on a stored cef_v8context_t
// reference.
///
CEF_EXPORT cef_v8value_t* cef_v8value_create_array_buffer(
void* buffer,
size_t length,
cef_v8array_buffer_release_callback_t* release_callback);
///
// Create a new cef_v8value_t object of type function. This function should only
// be called from within the scope of a cef_render_process_handler_t,

56
include/cef_v8.h
View File

@ -407,6 +407,21 @@ class CefV8Exception : public virtual CefBaseRefCounted {
virtual int GetEndColumn() = 0;
};
///
// Callback interface that is passed to CefV8Value::CreateArrayBuffer.
///
/*--cef(source=client)--*/
class CefV8ArrayBufferReleaseCallback : public virtual CefBaseRefCounted {
public:
///
// Called to release |buffer| when the ArrayBuffer JS object is garbage
// collected. |buffer| is the value that was passed to CreateArrayBuffer along
// with this object.
///
/*--cef()--*/
virtual void ReleaseBuffer(void* buffer) = 0;
};
///
// Class representing a V8 value handle. V8 handles can only be accessed from
// the thread on which they are created. Valid threads for creating a V8 handle
@ -493,6 +508,22 @@ class CefV8Value : public virtual CefBaseRefCounted {
/*--cef()--*/
static CefRefPtr<CefV8Value> CreateArray(int length);
///
// Create a new CefV8Value object of type ArrayBuffer which wraps the provided
// |buffer| of size |length| bytes. The ArrayBuffer is externalized, meaning
// that it does not own |buffer|. The caller is responsible for freeing
// |buffer| when requested via a call to CefV8ArrayBufferReleaseCallback::
// ReleaseBuffer. This method should only be called from within the scope of a
// CefRenderProcessHandler, CefV8Handler or CefV8Accessor callback, or in
// combination with calling Enter() and Exit() on a stored CefV8Context
// reference.
///
/*--cef()--*/
static CefRefPtr<CefV8Value> CreateArrayBuffer(
void* buffer,
size_t length,
CefRefPtr<CefV8ArrayBufferReleaseCallback> release_callback);
///
// Create a new CefV8Value object of type function. This method should only be
// called from within the scope of a CefRenderProcessHandler, CefV8Handler or
@ -571,6 +602,12 @@ class CefV8Value : public virtual CefBaseRefCounted {
/*--cef()--*/
virtual bool IsArray() = 0;
///
// True if the value type is an ArrayBuffer.
///
/*--cef()--*/
virtual bool IsArrayBuffer() = 0;
///
// True if the value type is function.
///
@ -793,6 +830,25 @@ class CefV8Value : public virtual CefBaseRefCounted {
/*--cef()--*/
virtual int GetArrayLength() = 0;
// ARRAY BUFFER METHODS - These methods are only available on ArrayBuffers.
///
// Returns the ReleaseCallback object associated with the ArrayBuffer or NULL
// if the ArrayBuffer was not created with CreateArrayBuffer.
///
/*--cef()--*/
virtual CefRefPtr<CefV8ArrayBufferReleaseCallback>
GetArrayBufferReleaseCallback() = 0;
///
// Prevent the ArrayBuffer from using it's memory block by setting the length
// to zero. This operation cannot be undone. If the ArrayBuffer was created
// with CreateArrayBuffer then CefV8ArrayBufferReleaseCallback::ReleaseBuffer
// will be called to release the underlying buffer.
///
/*--cef()--*/
virtual bool NeuterArrayBuffer() = 0;
// FUNCTION METHODS - These methods are only available on functions.
///

161
libcef/renderer/v8_impl.cc
View File

@ -304,6 +304,74 @@ class V8TrackString : public CefTrackNode {
std::string string_;
};
class V8TrackArrayBuffer : public CefTrackNode {
public:
explicit V8TrackArrayBuffer(
v8::Isolate* isolate,
void* buffer,
CefRefPtr<CefV8ArrayBufferReleaseCallback> release_callback)
: isolate_(isolate),
buffer_(buffer),
release_callback_(release_callback) {
DCHECK(isolate_);
}
~V8TrackArrayBuffer() {
if (buffer_ != nullptr) {
release_callback_->ReleaseBuffer(buffer_);
}
isolate_->AdjustAmountOfExternalAllocatedMemory(
-static_cast<int>(sizeof(V8TrackArrayBuffer)));
}
CefRefPtr<CefV8ArrayBufferReleaseCallback> GetReleaseCallback() {
return release_callback_;
}
void Neuter() { buffer_ = nullptr; }
// Retrieve the track object for the specified V8 object.
static V8TrackArrayBuffer* Unwrap(v8::Local<v8::Context> context,
v8::Local<v8::Object> object) {
v8::Local<v8::Value> value;
if (GetPrivate(context, object, kCefTrackObject, &value))
return static_cast<V8TrackArrayBuffer*>(
v8::External::Cast(*value)->Value());
return nullptr;
}
// Attach this track object to the specified V8 object.
void AttachTo(v8::Local<v8::Context> context,
v8::Local<v8::ArrayBuffer> arrayBuffer) {
isolate_->AdjustAmountOfExternalAllocatedMemory(
static_cast<int>(sizeof(V8TrackArrayBuffer)));
SetPrivate(context, arrayBuffer, kCefTrackObject,
v8::External::New(isolate_, this));
handle_.Reset(isolate_, arrayBuffer);
handle_.SetWeak(this, FirstWeakCallback, v8::WeakCallbackType::kParameter);
handle_.MarkIndependent();
}
private:
static void FirstWeakCallback(
const v8::WeakCallbackInfo<V8TrackArrayBuffer>& data) {
V8TrackArrayBuffer* wrapper = data.GetParameter();
if (wrapper->buffer_ != nullptr) {
wrapper->release_callback_->ReleaseBuffer(wrapper->buffer_);
wrapper->buffer_ = nullptr;
}
wrapper->handle_.Reset();
}
v8::Isolate* isolate_;
void* buffer_;
CefRefPtr<CefV8ArrayBufferReleaseCallback> release_callback_;
v8::Persistent<v8::ArrayBuffer> handle_;
};
// Object wrapped in a v8::External and passed as the Data argument to
// v8::FunctionTemplate::New.
class V8FunctionData {
@ -1311,6 +1379,35 @@ CefRefPtr<CefV8Value> CefV8Value::CreateArray(int length) {
return impl.get();
}
// static
CefRefPtr<CefV8Value> CefV8Value::CreateArrayBuffer(
void* buffer,
size_t length,
CefRefPtr<CefV8ArrayBufferReleaseCallback> release_callback) {
CEF_V8_REQUIRE_ISOLATE_RETURN(NULL);
v8::Isolate* isolate = GetIsolateManager()->isolate();
v8::HandleScope handle_scope(isolate);
v8::Local<v8::Context> context = isolate->GetCurrentContext();
if (context.IsEmpty()) {
NOTREACHED() << "not currently in a V8 context";
return NULL;
}
// Create a tracker object that will cause the user data reference to be
// released when the V8 object is destroyed.
V8TrackArrayBuffer* tracker =
new V8TrackArrayBuffer(isolate, buffer, release_callback);
v8::Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(isolate, buffer, length);
// Attach the tracker object.
tracker->AttachTo(context, ab);
CefRefPtr<CefV8ValueImpl> impl = new CefV8ValueImpl(isolate);
impl->InitObject(ab, tracker);
return impl.get();
}
// static
CefRefPtr<CefV8Value> CefV8Value::CreateFunction(
const CefString& name,
@ -1571,6 +1668,16 @@ bool CefV8ValueImpl::IsArray() {
}
}
bool CefV8ValueImpl::IsArrayBuffer() {
CEF_V8_REQUIRE_MLT_RETURN(false);
if (type_ == TYPE_OBJECT) {
v8::HandleScope handle_scope(handle_->isolate());
return handle_->GetNewV8Handle(false)->IsArrayBuffer();
} else {
return false;
}
}
bool CefV8ValueImpl::IsFunction() {
CEF_V8_REQUIRE_MLT_RETURN(false);
if (type_ == TYPE_OBJECT) {
@ -2091,6 +2198,60 @@ int CefV8ValueImpl::GetArrayLength() {
return arr->Length();
}
CefRefPtr<CefV8ArrayBufferReleaseCallback>
CefV8ValueImpl::GetArrayBufferReleaseCallback() {
CEF_V8_REQUIRE_OBJECT_RETURN(0);
v8::Isolate* isolate = handle_->isolate();
v8::HandleScope handle_scope(isolate);
v8::Local<v8::Context> context = isolate->GetCurrentContext();
if (context.IsEmpty()) {
NOTREACHED() << "not currently in a V8 context";
return NULL;
}
v8::Local<v8::Value> value = handle_->GetNewV8Handle(false);
if (!value->IsArrayBuffer()) {
NOTREACHED() << "V8 value is not an array buffer";
return NULL;
}
v8::Local<v8::Object> obj = value->ToObject();
V8TrackArrayBuffer* tracker = V8TrackArrayBuffer::Unwrap(context, obj);
if (tracker)
return tracker->GetReleaseCallback();
return NULL;
}
bool CefV8ValueImpl::NeuterArrayBuffer() {
CEF_V8_REQUIRE_OBJECT_RETURN(0);
v8::Isolate* isolate = handle_->isolate();
v8::HandleScope handle_scope(isolate);
v8::Local<v8::Context> context = isolate->GetCurrentContext();
if (context.IsEmpty()) {
NOTREACHED() << "not currently in a V8 context";
return false;
}
v8::Local<v8::Value> value = handle_->GetNewV8Handle(false);
if (!value->IsArrayBuffer()) {
NOTREACHED() << "V8 value is not an array buffer";
return false;
}
v8::Local<v8::Object> obj = value->ToObject();
v8::Local<v8::ArrayBuffer> arr = v8::Local<v8::ArrayBuffer>::Cast(obj);
if (!arr->IsNeuterable()) {
return false;
}
arr->Neuter();
V8TrackArrayBuffer* tracker = V8TrackArrayBuffer::Unwrap(context, obj);
tracker->Neuter();
return true;
}
CefString CefV8ValueImpl::GetFunctionName() {
CefString rv;
CEF_V8_REQUIRE_OBJECT_RETURN(rv);

4
libcef/renderer/v8_impl.h
View File

@ -227,6 +227,7 @@ class CefV8ValueImpl : public CefV8Value {
bool IsString() override;
bool IsObject() override;
bool IsArray() override;
bool IsArrayBuffer() override;
bool IsFunction() override;
bool IsSame(CefRefPtr<CefV8Value> value) override;
bool GetBoolValue() override;
@ -260,6 +261,9 @@ class CefV8ValueImpl : public CefV8Value {
int GetExternallyAllocatedMemory() override;
int AdjustExternallyAllocatedMemory(int change_in_bytes) override;
int GetArrayLength() override;
CefRefPtr<CefV8ArrayBufferReleaseCallback> GetArrayBufferReleaseCallback()
override;
bool NeuterArrayBuffer() override;
CefString GetFunctionName() override;
CefRefPtr<CefV8Handler> GetFunctionHandler() override;
CefRefPtr<CefV8Value> ExecuteFunction(

70
libcef_dll/cpptoc/v8array_buffer_release_callback_cpptoc.cc Normal file
View File

@ -0,0 +1,70 @@
// Copyright (c) 2018 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
// ---------------------------------------------------------------------------
//
// This file was generated by the CEF translator tool. If making changes by
// hand only do so within the body of existing method and function
// implementations. See the translator.README.txt file in the tools directory
// for more information.
//
// $hash=a0e352ab964b29c7b1aa22791ee38a81cd418a99$
//
#include "libcef_dll/cpptoc/v8array_buffer_release_callback_cpptoc.h"
namespace {
// MEMBER FUNCTIONS - Body may be edited by hand.
void CEF_CALLBACK v8array_buffer_release_callback_release_buffer(
struct _cef_v8array_buffer_release_callback_t* self,
void* buffer) {
// AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
DCHECK(self);
if (!self)
return;
// Verify param: buffer; type: simple_byaddr
DCHECK(buffer);
if (!buffer)
return;
// Execute
CefV8ArrayBufferReleaseCallbackCppToC::Get(self)->ReleaseBuffer(buffer);
}
} // namespace
// CONSTRUCTOR - Do not edit by hand.
CefV8ArrayBufferReleaseCallbackCppToC::CefV8ArrayBufferReleaseCallbackCppToC() {
GetStruct()->release_buffer = v8array_buffer_release_callback_release_buffer;
}
template <>
CefRefPtr<CefV8ArrayBufferReleaseCallback>
CefCppToCRefCounted<CefV8ArrayBufferReleaseCallbackCppToC,
CefV8ArrayBufferReleaseCallback,
cef_v8array_buffer_release_callback_t>::
UnwrapDerived(CefWrapperType type,
cef_v8array_buffer_release_callback_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#if DCHECK_IS_ON()
template <>
base::AtomicRefCount CefCppToCRefCounted<
CefV8ArrayBufferReleaseCallbackCppToC,
CefV8ArrayBufferReleaseCallback,
cef_v8array_buffer_release_callback_t>::DebugObjCt ATOMIC_DECLARATION;
#endif
template <>
CefWrapperType
CefCppToCRefCounted<CefV8ArrayBufferReleaseCallbackCppToC,
CefV8ArrayBufferReleaseCallback,
cef_v8array_buffer_release_callback_t>::kWrapperType =
WT_V8ARRAY_BUFFER_RELEASE_CALLBACK;

37
libcef_dll/cpptoc/v8array_buffer_release_callback_cpptoc.h Normal file
View File

@ -0,0 +1,37 @@
// Copyright (c) 2018 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
// ---------------------------------------------------------------------------
//
// This file was generated by the CEF translator tool. If making changes by
// hand only do so within the body of existing method and function
// implementations. See the translator.README.txt file in the tools directory
// for more information.
//
// $hash=61fe643dbdefcacb37612d6611d5b3cd0d0f731a$
//
#ifndef CEF_LIBCEF_DLL_CPPTOC_V8ARRAY_BUFFER_RELEASE_CALLBACK_CPPTOC_H_
#define CEF_LIBCEF_DLL_CPPTOC_V8ARRAY_BUFFER_RELEASE_CALLBACK_CPPTOC_H_
#pragma once
#if !defined(WRAPPING_CEF_SHARED)
#error This file can be included wrapper-side only
#endif
#include "include/capi/cef_v8_capi.h"
#include "include/cef_v8.h"
#include "libcef_dll/cpptoc/cpptoc_ref_counted.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed wrapper-side only.
class CefV8ArrayBufferReleaseCallbackCppToC
: public CefCppToCRefCounted<CefV8ArrayBufferReleaseCallbackCppToC,
CefV8ArrayBufferReleaseCallback,
cef_v8array_buffer_release_callback_t> {
public:
CefV8ArrayBufferReleaseCallbackCppToC();
};
#endif // CEF_LIBCEF_DLL_CPPTOC_V8ARRAY_BUFFER_RELEASE_CALLBACK_CPPTOC_H_

75
libcef_dll/cpptoc/v8value_cpptoc.cc
View File

@ -9,7 +9,7 @@
// implementations. See the translator.README.txt file in the tools directory
// for more information.
//
// $hash=d4baeb8853a8d33bde68e82a87e73e63fefb6e59$
// $hash=b8c41c5cff5d308ad0ecbeafb38f12fae4ce06eb$
//
#include "libcef_dll/cpptoc/v8value_cpptoc.h"
@ -17,6 +17,7 @@
#include "libcef_dll/cpptoc/v8exception_cpptoc.h"
#include "libcef_dll/ctocpp/base_ref_counted_ctocpp.h"
#include "libcef_dll/ctocpp/v8accessor_ctocpp.h"
#include "libcef_dll/ctocpp/v8array_buffer_release_callback_ctocpp.h"
#include "libcef_dll/ctocpp/v8handler_ctocpp.h"
#include "libcef_dll/ctocpp/v8interceptor_ctocpp.h"
#include "libcef_dll/transfer_util.h"
@ -139,6 +140,30 @@ CEF_EXPORT cef_v8value_t* cef_v8value_create_array(int length) {
return CefV8ValueCppToC::Wrap(_retval);
}
CEF_EXPORT cef_v8value_t* cef_v8value_create_array_buffer(
void* buffer,
size_t length,
cef_v8array_buffer_release_callback_t* release_callback) {
// AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
// Verify param: buffer; type: simple_byaddr
DCHECK(buffer);
if (!buffer)
return NULL;
// Verify param: release_callback; type: refptr_diff
DCHECK(release_callback);
if (!release_callback)
return NULL;
// Execute
CefRefPtr<CefV8Value> _retval = CefV8Value::CreateArrayBuffer(
buffer, length,
CefV8ArrayBufferReleaseCallbackCToCpp::Wrap(release_callback));
// Return type: refptr_same
return CefV8ValueCppToC::Wrap(_retval);
}
CEF_EXPORT cef_v8value_t* cef_v8value_create_function(
const cef_string_t* name,
cef_v8handler_t* handler) {
@ -319,6 +344,20 @@ int CEF_CALLBACK v8value_is_array(struct _cef_v8value_t* self) {
return _retval;
}
int CEF_CALLBACK v8value_is_array_buffer(struct _cef_v8value_t* self) {
// AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
DCHECK(self);
if (!self)
return 0;
// Execute
bool _retval = CefV8ValueCppToC::Get(self)->IsArrayBuffer();
// Return type: bool
return _retval;
}
int CEF_CALLBACK v8value_is_function(struct _cef_v8value_t* self) {
// AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
@ -806,6 +845,36 @@ int CEF_CALLBACK v8value_get_array_length(struct _cef_v8value_t* self) {
return _retval;
}
cef_v8array_buffer_release_callback_t* CEF_CALLBACK
v8value_get_array_buffer_release_callback(struct _cef_v8value_t* self) {
// AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
DCHECK(self);
if (!self)
return NULL;
// Execute
CefRefPtr<CefV8ArrayBufferReleaseCallback> _retval =
CefV8ValueCppToC::Get(self)->GetArrayBufferReleaseCallback();
// Return type: refptr_diff
return CefV8ArrayBufferReleaseCallbackCToCpp::Unwrap(_retval);
}
int CEF_CALLBACK v8value_neuter_array_buffer(struct _cef_v8value_t* self) {
// AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
DCHECK(self);
if (!self)
return 0;
// Execute
bool _retval = CefV8ValueCppToC::Get(self)->NeuterArrayBuffer();
// Return type: bool
return _retval;
}
cef_string_userfree_t CEF_CALLBACK
v8value_get_function_name(struct _cef_v8value_t* self) {
// AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
@ -928,6 +997,7 @@ CefV8ValueCppToC::CefV8ValueCppToC() {
GetStruct()->is_string = v8value_is_string;
GetStruct()->is_object = v8value_is_object;
GetStruct()->is_array = v8value_is_array;
GetStruct()->is_array_buffer = v8value_is_array_buffer;
GetStruct()->is_function = v8value_is_function;
GetStruct()->is_same = v8value_is_same;
GetStruct()->get_bool_value = v8value_get_bool_value;
@ -959,6 +1029,9 @@ CefV8ValueCppToC::CefV8ValueCppToC() {
GetStruct()->adjust_externally_allocated_memory =
v8value_adjust_externally_allocated_memory;
GetStruct()->get_array_length = v8value_get_array_length;
GetStruct()->get_array_buffer_release_callback =
v8value_get_array_buffer_release_callback;
GetStruct()->neuter_array_buffer = v8value_neuter_array_buffer;
GetStruct()->get_function_name = v8value_get_function_name;
GetStruct()->get_function_handler = v8value_get_function_handler;
GetStruct()->execute_function = v8value_execute_function;

63
libcef_dll/ctocpp/v8array_buffer_release_callback_ctocpp.cc Normal file
View File

@ -0,0 +1,63 @@
// Copyright (c) 2018 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
// ---------------------------------------------------------------------------
//
// This file was generated by the CEF translator tool. If making changes by
// hand only do so within the body of existing method and function
// implementations. See the translator.README.txt file in the tools directory
// for more information.
//
// $hash=4518c58051d90673ecc1fc2b9e29b70467b36c97$
//
#include "libcef_dll/ctocpp/v8array_buffer_release_callback_ctocpp.h"
// VIRTUAL METHODS - Body may be edited by hand.
void CefV8ArrayBufferReleaseCallbackCToCpp::ReleaseBuffer(void* buffer) {
cef_v8array_buffer_release_callback_t* _struct = GetStruct();
if (CEF_MEMBER_MISSING(_struct, release_buffer))
return;
// AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
// Verify param: buffer; type: simple_byaddr
DCHECK(buffer);
if (!buffer)
return;
// Execute
_struct->release_buffer(_struct, buffer);
}
// CONSTRUCTOR - Do not edit by hand.
CefV8ArrayBufferReleaseCallbackCToCpp::CefV8ArrayBufferReleaseCallbackCToCpp() {
}
template <>
cef_v8array_buffer_release_callback_t*
CefCToCppRefCounted<CefV8ArrayBufferReleaseCallbackCToCpp,
CefV8ArrayBufferReleaseCallback,
cef_v8array_buffer_release_callback_t>::
UnwrapDerived(CefWrapperType type, CefV8ArrayBufferReleaseCallback* c) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#if DCHECK_IS_ON()
template <>
base::AtomicRefCount CefCToCppRefCounted<
CefV8ArrayBufferReleaseCallbackCToCpp,
CefV8ArrayBufferReleaseCallback,
cef_v8array_buffer_release_callback_t>::DebugObjCt ATOMIC_DECLARATION;
#endif
template <>
CefWrapperType
CefCToCppRefCounted<CefV8ArrayBufferReleaseCallbackCToCpp,
CefV8ArrayBufferReleaseCallback,
cef_v8array_buffer_release_callback_t>::kWrapperType =
WT_V8ARRAY_BUFFER_RELEASE_CALLBACK;

40
libcef_dll/ctocpp/v8array_buffer_release_callback_ctocpp.h Normal file
View File

@ -0,0 +1,40 @@
// Copyright (c) 2018 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
// ---------------------------------------------------------------------------
//
// This file was generated by the CEF translator tool. If making changes by
// hand only do so within the body of existing method and function
// implementations. See the translator.README.txt file in the tools directory
// for more information.
//
// $hash=6c5b7fe181699426e51ca11b6216a1ec56e36032$
//
#ifndef CEF_LIBCEF_DLL_CTOCPP_V8ARRAY_BUFFER_RELEASE_CALLBACK_CTOCPP_H_
#define CEF_LIBCEF_DLL_CTOCPP_V8ARRAY_BUFFER_RELEASE_CALLBACK_CTOCPP_H_
#pragma once
#if !defined(BUILDING_CEF_SHARED)
#error This file can be included DLL-side only
#endif
#include "include/capi/cef_v8_capi.h"
#include "include/cef_v8.h"
#include "libcef_dll/ctocpp/ctocpp_ref_counted.h"
// Wrap a C structure with a C++ class.
// This class may be instantiated and accessed DLL-side only.
class CefV8ArrayBufferReleaseCallbackCToCpp
: public CefCToCppRefCounted<CefV8ArrayBufferReleaseCallbackCToCpp,
CefV8ArrayBufferReleaseCallback,
cef_v8array_buffer_release_callback_t> {
public:
CefV8ArrayBufferReleaseCallbackCToCpp();
// CefV8ArrayBufferReleaseCallback methods.
void ReleaseBuffer(void* buffer) override;
};
#endif // CEF_LIBCEF_DLL_CTOCPP_V8ARRAY_BUFFER_RELEASE_CALLBACK_CTOCPP_H_

71
libcef_dll/ctocpp/v8value_ctocpp.cc
View File

@ -9,12 +9,13 @@
// implementations. See the translator.README.txt file in the tools directory
// for more information.
//
// $hash=54a9512b67fa17d33626e83e249fa27037bd92bc$
// $hash=c08a6af7e4295bc574af45eb798e84e546f2e1a0$
//
#include "libcef_dll/ctocpp/v8value_ctocpp.h"
#include "libcef_dll/cpptoc/base_ref_counted_cpptoc.h"
#include "libcef_dll/cpptoc/v8accessor_cpptoc.h"
#include "libcef_dll/cpptoc/v8array_buffer_release_callback_cpptoc.h"
#include "libcef_dll/cpptoc/v8handler_cpptoc.h"
#include "libcef_dll/cpptoc/v8interceptor_cpptoc.h"
#include "libcef_dll/ctocpp/v8context_ctocpp.h"
@ -131,6 +132,30 @@ CefRefPtr<CefV8Value> CefV8Value::CreateArray(int length) {
return CefV8ValueCToCpp::Wrap(_retval);
}
CefRefPtr<CefV8Value> CefV8Value::CreateArrayBuffer(
void* buffer,
size_t length,
CefRefPtr<CefV8ArrayBufferReleaseCallback> release_callback) {
// AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
// Verify param: buffer; type: simple_byaddr
DCHECK(buffer);
if (!buffer)
return NULL;
// Verify param: release_callback; type: refptr_diff
DCHECK(release_callback.get());
if (!release_callback.get())
return NULL;
// Execute
cef_v8value_t* _retval = cef_v8value_create_array_buffer(
buffer, length,
CefV8ArrayBufferReleaseCallbackCppToC::Wrap(release_callback));
// Return type: refptr_same
return CefV8ValueCToCpp::Wrap(_retval);
}
CefRefPtr<CefV8Value> CefV8Value::CreateFunction(
const CefString& name,
CefRefPtr<CefV8Handler> handler) {
@ -309,6 +334,20 @@ bool CefV8ValueCToCpp::IsArray() {
return _retval ? true : false;
}
bool CefV8ValueCToCpp::IsArrayBuffer() {
cef_v8value_t* _struct = GetStruct();
if (CEF_MEMBER_MISSING(_struct, is_array_buffer))
return false;
// AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
// Execute
int _retval = _struct->is_array_buffer(_struct);
// Return type: bool
return _retval ? true : false;
}
bool CefV8ValueCToCpp::IsFunction() {
cef_v8value_t* _struct = GetStruct();
if (CEF_MEMBER_MISSING(_struct, is_function))
@ -784,6 +823,36 @@ int CefV8ValueCToCpp::GetArrayLength() {
return _retval;
}
CefRefPtr<CefV8ArrayBufferReleaseCallback>
CefV8ValueCToCpp::GetArrayBufferReleaseCallback() {
cef_v8value_t* _struct = GetStruct();
if (CEF_MEMBER_MISSING(_struct, get_array_buffer_release_callback))
return NULL;
// AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
// Execute
cef_v8array_buffer_release_callback_t* _retval =
_struct->get_array_buffer_release_callback(_struct);
// Return type: refptr_diff
return CefV8ArrayBufferReleaseCallbackCppToC::Unwrap(_retval);
}
bool CefV8ValueCToCpp::NeuterArrayBuffer() {
cef_v8value_t* _struct = GetStruct();
if (CEF_MEMBER_MISSING(_struct, neuter_array_buffer))
return false;
// AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
// Execute
int _retval = _struct->neuter_array_buffer(_struct);
// Return type: bool
return _retval ? true : false;
}
CefString CefV8ValueCToCpp::GetFunctionName() {
cef_v8value_t* _struct = GetStruct();
if (CEF_MEMBER_MISSING(_struct, get_function_name))

6
libcef_dll/ctocpp/v8value_ctocpp.h
View File

@ -9,7 +9,7 @@
// implementations. See the translator.README.txt file in the tools directory
// for more information.
//
// $hash=8a913ff3ac0743621e969fed20ce713804ac4f16$
// $hash=72b98313f1c00f864fd01694eb741f066ae2c5f4$
//
#ifndef CEF_LIBCEF_DLL_CTOCPP_V8VALUE_CTOCPP_H_
@ -44,6 +44,7 @@ class CefV8ValueCToCpp
bool IsString() OVERRIDE;
bool IsObject() OVERRIDE;
bool IsArray() OVERRIDE;
bool IsArrayBuffer() OVERRIDE;
bool IsFunction() OVERRIDE;
bool IsSame(CefRefPtr<CefV8Value> that) OVERRIDE;
bool GetBoolValue() OVERRIDE;
@ -77,6 +78,9 @@ class CefV8ValueCToCpp
int GetExternallyAllocatedMemory() OVERRIDE;
int AdjustExternallyAllocatedMemory(int change_in_bytes) OVERRIDE;
int GetArrayLength() OVERRIDE;
CefRefPtr<CefV8ArrayBufferReleaseCallback> GetArrayBufferReleaseCallback()
OVERRIDE;
bool NeuterArrayBuffer() OVERRIDE;
CefString GetFunctionName() OVERRIDE;
CefRefPtr<CefV8Handler> GetFunctionHandler() OVERRIDE;
CefRefPtr<CefV8Value> ExecuteFunction(

5
libcef_dll/libcef_dll.cc
View File

@ -9,7 +9,7 @@
// implementations. See the translator.README.txt file in the tools directory
// for more information.
//
// $hash=8fb3e1af64274b34482ee34c75a6196654104360$
// $hash=34ae05a5b71f5f9ede44fb859074e9ffcd7b65ad$
//
#include "include/capi/cef_app_capi.h"
@ -158,6 +158,7 @@
#include "libcef_dll/ctocpp/test/translator_test_scoped_client_ctocpp.h"
#include "libcef_dll/ctocpp/urlrequest_client_ctocpp.h"
#include "libcef_dll/ctocpp/v8accessor_ctocpp.h"
#include "libcef_dll/ctocpp/v8array_buffer_release_callback_ctocpp.h"
#include "libcef_dll/ctocpp/v8handler_ctocpp.h"
#include "libcef_dll/ctocpp/v8interceptor_ctocpp.h"
#include "libcef_dll/ctocpp/views/browser_view_delegate_ctocpp.h"
@ -372,6 +373,8 @@ CEF_EXPORT void cef_shutdown() {
DCHECK(base::AtomicRefCountIsZero(&CefURLRequestClientCToCpp::DebugObjCt));
DCHECK(base::AtomicRefCountIsZero(&CefURLRequestCppToC::DebugObjCt));
DCHECK(base::AtomicRefCountIsZero(&CefV8AccessorCToCpp::DebugObjCt));
DCHECK(base::AtomicRefCountIsZero(
&CefV8ArrayBufferReleaseCallbackCToCpp::DebugObjCt));
DCHECK(base::AtomicRefCountIsZero(&CefV8ContextCppToC::DebugObjCt));
DCHECK(base::AtomicRefCountIsZero(&CefV8ExceptionCppToC::DebugObjCt));
DCHECK(base::AtomicRefCountIsZero(&CefV8HandlerCToCpp::DebugObjCt));

5
libcef_dll/wrapper/libcef_dll_wrapper.cc
View File

@ -9,7 +9,7 @@
// implementations. See the translator.README.txt file in the tools directory
// for more information.
//
// $hash=07d31c969dc527db8df550827d750aefa0abf1b8$
// $hash=0549060b3d0b129aa1d4b0824eeacf3af9d3d5ab$
//
#include "include/capi/cef_app_capi.h"
@ -87,6 +87,7 @@
#include "libcef_dll/cpptoc/test/translator_test_scoped_client_cpptoc.h"
#include "libcef_dll/cpptoc/urlrequest_client_cpptoc.h"
#include "libcef_dll/cpptoc/v8accessor_cpptoc.h"
#include "libcef_dll/cpptoc/v8array_buffer_release_callback_cpptoc.h"
#include "libcef_dll/cpptoc/v8handler_cpptoc.h"
#include "libcef_dll/cpptoc/v8interceptor_cpptoc.h"
#include "libcef_dll/cpptoc/views/browser_view_delegate_cpptoc.h"
@ -363,6 +364,8 @@ CEF_GLOBAL void CefShutdown() {
DCHECK(base::AtomicRefCountIsZero(&CefURLRequestCToCpp::DebugObjCt));
DCHECK(base::AtomicRefCountIsZero(&CefURLRequestClientCppToC::DebugObjCt));
DCHECK(base::AtomicRefCountIsZero(&CefV8AccessorCppToC::DebugObjCt));
DCHECK(base::AtomicRefCountIsZero(
&CefV8ArrayBufferReleaseCallbackCppToC::DebugObjCt));
DCHECK(base::AtomicRefCountIsZero(&CefV8ContextCToCpp::DebugObjCt));
DCHECK(base::AtomicRefCountIsZero(&CefV8ExceptionCToCpp::DebugObjCt));
DCHECK(base::AtomicRefCountIsZero(&CefV8HandlerCppToC::DebugObjCt));

3
libcef_dll/wrapper_types.h
View File

@ -9,7 +9,7 @@
// implementations. See the translator.README.txt file in the tools directory
// for more information.
//
// $hash=3fe3af71072987e46db28d1a94b8b6a9ad7d9e2a$
// $hash=47f1724d1f28c8295717e5df6ce8f5f8602ce1d5$
//
#ifndef CEF_LIBCEF_DLL_WRAPPER_TYPES_H_
@ -137,6 +137,7 @@ enum CefWrapperType {
WT_URLREQUEST,
WT_URLREQUEST_CLIENT,
WT_V8ACCESSOR,
WT_V8ARRAY_BUFFER_RELEASE_CALLBACK,
WT_V8CONTEXT,
WT_V8EXCEPTION,
WT_V8HANDLER,

121
tests/ceftests/v8_unittest.cc
View File

@ -57,6 +57,8 @@ enum V8TestMode {
V8TEST_EMPTY_STRING_CREATE,
V8TEST_ARRAY_CREATE,
V8TEST_ARRAY_VALUE,
V8TEST_ARRAY_BUFFER,
V8TEST_ARRAY_BUFFER_VALUE,
V8TEST_OBJECT_CREATE,
V8TEST_OBJECT_USERDATA,
V8TEST_OBJECT_ACCESSOR,
@ -159,6 +161,12 @@ class V8RendererTest : public ClientAppRenderer::Delegate,
case V8TEST_ARRAY_VALUE:
RunArrayValueTest();
break;
case V8TEST_ARRAY_BUFFER:
RunArrayBufferTest();
break;
case V8TEST_ARRAY_BUFFER_VALUE:
RunArrayBufferValueTest();
break;
case V8TEST_OBJECT_CREATE:
RunObjectCreateTest();
break;
@ -543,6 +551,117 @@ class V8RendererTest : public ClientAppRenderer::Delegate,
DestroyTest();
}
void RunArrayBufferTest() {
class TestArrayBufferReleaseCallback
: public CefV8ArrayBufferReleaseCallback {
public:
TestArrayBufferReleaseCallback(bool* destructorCalled,
bool* releaseBufferCalled)
: destructorCalled_(destructorCalled),
releaseBufferCalled_(releaseBufferCalled) {}
~TestArrayBufferReleaseCallback() { *destructorCalled_ = true; }
void ReleaseBuffer(void* buffer) { *releaseBufferCalled_ = true; }
IMPLEMENT_REFCOUNTING(TestArrayBufferReleaseCallback);
private:
bool* destructorCalled_;
bool* releaseBufferCalled_;
};
CefRefPtr<CefV8Context> context = GetContext();
bool destructorCalled = false;
bool releaseBufferCalled = false;
bool neuteredDestructorCalled = false;
bool neuteredReleaseBufferCalled = false;
// Enter the V8 context.
EXPECT_TRUE(context->Enter());
{
int static_data[16];
CefRefPtr<CefV8Value> value;
CefRefPtr<TestArrayBufferReleaseCallback> release_callback =
new TestArrayBufferReleaseCallback(&destructorCalled,
&releaseBufferCalled);
CefRefPtr<CefV8Value> neuteredValue;
CefRefPtr<TestArrayBufferReleaseCallback> neuteredReleaseCallback =
new TestArrayBufferReleaseCallback(&neuteredDestructorCalled,
&neuteredReleaseBufferCalled);
value = CefV8Value::CreateArrayBuffer(static_data, sizeof(static_data),
release_callback);
neuteredValue = CefV8Value::CreateArrayBuffer(
static_data, sizeof(static_data), neuteredReleaseCallback);
EXPECT_TRUE(value.get());
EXPECT_TRUE(value->IsArrayBuffer());
EXPECT_TRUE(value->IsObject());
EXPECT_FALSE(value->HasValue(0));
EXPECT_FALSE(destructorCalled);
EXPECT_TRUE(value->GetArrayBufferReleaseCallback().get() != nullptr);
EXPECT_TRUE(((TestArrayBufferReleaseCallback*)value
->GetArrayBufferReleaseCallback()
.get()) == release_callback);
EXPECT_TRUE(neuteredValue->NeuterArrayBuffer());
}
// Exit the V8 context.
EXPECT_TRUE(destructorCalled);
EXPECT_TRUE(releaseBufferCalled);
EXPECT_TRUE(neuteredDestructorCalled);
EXPECT_FALSE(neuteredReleaseBufferCalled);
EXPECT_TRUE(context->Exit());
DestroyTest();
}
void RunArrayBufferValueTest() {
class TestArrayBufferReleaseCallback
: public CefV8ArrayBufferReleaseCallback {
public:
TestArrayBufferReleaseCallback() {}
~TestArrayBufferReleaseCallback() {}
void ReleaseBuffer(void* buffer) {}
IMPLEMENT_REFCOUNTING(TestArrayBufferReleaseCallback);
};
CefRefPtr<CefV8Context> context = GetContext();
// Enter the V8 context.
CefRefPtr<CefV8Value> value;
CefRefPtr<TestArrayBufferReleaseCallback> owner =
new TestArrayBufferReleaseCallback();
EXPECT_TRUE(context->Enter());
int static_data[16];
static_data[0] = 3;
value =
CefV8Value::CreateArrayBuffer(static_data, sizeof(static_data), owner);
CefRefPtr<CefV8Value> object = context->GetGlobal();
EXPECT_TRUE(object.get());
object->SetValue("arr", value, V8_PROPERTY_ATTRIBUTE_NONE);
std::string test =
"let data = new Int32Array(window.arr); data[0] += data.length";
CefRefPtr<CefV8Value> retval;
CefRefPtr<CefV8Exception> exception;
EXPECT_TRUE(context->Eval(test, CefString(), 0, retval, exception));
if (exception.get())
ADD_FAILURE() << exception->GetMessage().c_str();
EXPECT_TRUE(static_data[0] == 19);
EXPECT_TRUE(value->GetArrayBufferReleaseCallback().get() != nullptr);
EXPECT_TRUE(value->NeuterArrayBuffer());
// Exit the V8 context.
EXPECT_TRUE(context->Exit());
DestroyTest();
}
void RunObjectCreateTest() {
CefRefPtr<CefV8Context> context = GetContext();
@ -2972,6 +3091,8 @@ V8_TEST(StringCreate, V8TEST_STRING_CREATE);
V8_TEST(EmptyStringCreate, V8TEST_EMPTY_STRING_CREATE);
V8_TEST(ArrayCreate, V8TEST_ARRAY_CREATE);
V8_TEST(ArrayValue, V8TEST_ARRAY_VALUE);
V8_TEST(ArrayBuffer, V8TEST_ARRAY_BUFFER);
V8_TEST(ArrayBufferValue, V8TEST_ARRAY_BUFFER_VALUE);
V8_TEST(ObjectCreate, V8TEST_OBJECT_CREATE);
V8_TEST(ObjectUserData, V8TEST_OBJECT_USERDATA);
V8_TEST(ObjectAccessor, V8TEST_OBJECT_ACCESSOR);