public:

///

/// Returns the current (top) context object in the V8 context stack.

///

/*--cef()--*/

static CefRefPtr<CefV8Context> GetCurrentContext();

///

/// Returns the entered (bottom) context object in the V8 context stack.

///

/*--cef()--*/

static CefRefPtr<CefV8Context> GetEnteredContext();

///

/// Returns true if V8 is currently inside a context.

///

/*--cef()--*/

static bool InContext();

///

/// Returns the task runner associated with this context. V8 handles can only

/// be accessed from the thread on which they are created. This method can be

/// called on any render process thread.

///

/*--cef()--*/

virtual CefRefPtr<CefTaskRunner> GetTaskRunner() = 0;

///

/// Returns true if the underlying handle is valid and it can be accessed on

/// the current thread. Do not call any other methods if this method returns

/// false.

///

/*--cef()--*/

virtual bool IsValid() = 0;

///

/// Returns the browser for this context. This method will return an empty

/// reference for WebWorker contexts.

///

/*--cef()--*/

virtual CefRefPtr<CefBrowser> GetBrowser() = 0;

///

/// Returns the frame for this context. This method will return an empty

/// reference for WebWorker contexts.

///

/*--cef()--*/

virtual CefRefPtr<CefFrame> GetFrame() = 0;

///

/// Returns the global object for this context. The context must be entered

/// before calling this method.

///

/*--cef()--*/

virtual CefRefPtr<CefV8Value> GetGlobal() = 0;

///

/// Enter this context. A context must be explicitly entered before creating a

/// V8 Object, Array, Function or Date asynchronously. Exit() must be called

/// the same number of times as Enter() before releasing this context. V8

/// objects belong to the context in which they are created. Returns true if

/// the scope was entered successfully.

///

/*--cef()--*/

virtual bool Enter() = 0;

///

/// Exit this context. Call this method only after calling Enter(). Returns

/// true if the scope was exited successfully.

///

/*--cef()--*/

virtual bool Exit() = 0;

///

/// Returns true if this object is pointing to the same handle as |that|

/// object.

///

/*--cef()--*/

virtual bool IsSame(CefRefPtr<CefV8Context> that) = 0;

///

/// Execute a string of JavaScript code in this V8 context. The |script_url|

/// parameter is the URL where the script in question can be found, if any.

/// The |start_line| parameter is the base line number to use for error

/// reporting. On success |retval| will be set to the return value, if any,

/// and the function will return true. On failure |exception| will be set to

/// the exception, if any, and the function will return false.

///

/*--cef(optional_param=script_url)--*/

virtual bool Eval(const CefString& code,

const CefString& script_url,

int start_line,

CefRefPtr<CefV8Value>& retval,

CefRefPtr<CefV8Exception>& exception) = 0;

public:

///

/// Handle execution of the function identified by |name|. |object| is the

/// receiver ('this' object) of the function. |arguments| is the list of

/// arguments passed to the function. If execution succeeds set |retval| to

/// the function return value. If execution fails set |exception| to the

/// exception that will be thrown. Return true if execution was handled.

///

/*--cef()--*/

virtual bool Execute(const CefString& name,

CefRefPtr<CefV8Value> object,

const CefV8ValueList& arguments,

CefRefPtr<CefV8Value>& retval,

CefString& exception) = 0;

public:

///

/// Handle retrieval the accessor value identified by |name|. |object| is the

/// receiver ('this' object) of the accessor. If retrieval succeeds set

/// |retval| to the return value. If retrieval fails set |exception| to the

/// exception that will be thrown. Return true if accessor retrieval was

/// handled.

///

/*--cef()--*/

virtual bool Get(const CefString& name,

const CefRefPtr<CefV8Value> object,

CefRefPtr<CefV8Value>& retval,

CefString& exception) = 0;

///

/// Handle assignment of the accessor value identified by |name|. |object| is

/// the receiver ('this' object) of the accessor. |value| is the new value

/// being assigned to the accessor. If assignment fails set |exception| to the

/// exception that will be thrown. Return true if accessor assignment was

/// handled.

///

/*--cef()--*/

virtual bool Set(const CefString& name,

const CefRefPtr<CefV8Value> object,

const CefRefPtr<CefV8Value> value,

CefString& exception) = 0;

public:

///

/// Handle retrieval of the interceptor value identified by |name|. |object|

/// is the receiver ('this' object) of the interceptor. If retrieval succeeds,

/// set |retval| to the return value. If the requested value does not exist,

/// don't set either |retval| or |exception|. If retrieval fails, set

/// |exception| to the exception that will be thrown. If the property has an

/// associated accessor, it will be called only if you don't set |retval|.

/// Return true if interceptor retrieval was handled, false otherwise.

///

/*--cef(capi_name=get_byname)--*/

virtual bool Get(const CefString& name,

const CefRefPtr<CefV8Value> object,

CefRefPtr<CefV8Value>& retval,

CefString& exception) = 0;

///

/// Handle retrieval of the interceptor value identified by |index|. |object|

/// is the receiver ('this' object) of the interceptor. If retrieval succeeds,

/// set |retval| to the return value. If the requested value does not exist,

/// don't set either |retval| or |exception|. If retrieval fails, set

/// |exception| to the exception that will be thrown.

/// Return true if interceptor retrieval was handled, false otherwise.

///

/*--cef(capi_name=get_byindex,index_param=index)--*/

virtual bool Get(int index,

const CefRefPtr<CefV8Value> object,

CefRefPtr<CefV8Value>& retval,

CefString& exception) = 0;

///

/// Handle assignment of the interceptor value identified by |name|. |object|

/// is the receiver ('this' object) of the interceptor. |value| is the new

/// value being assigned to the interceptor. If assignment fails, set

/// |exception| to the exception that will be thrown. This setter will always

/// be called, even when the property has an associated accessor.

/// Return true if interceptor assignment was handled, false otherwise.

///

/*--cef(capi_name=set_byname)--*/

virtual bool Set(const CefString& name,

const CefRefPtr<CefV8Value> object,

const CefRefPtr<CefV8Value> value,

CefString& exception) = 0;

///

/// Handle assignment of the interceptor value identified by |index|. |object|

/// is the receiver ('this' object) of the interceptor. |value| is the new

/// value being assigned to the interceptor. If assignment fails, set

/// |exception| to the exception that will be thrown.

/// Return true if interceptor assignment was handled, false otherwise.

///

/*--cef(capi_name=set_byindex,index_param=index)--*/

virtual bool Set(int index,

const CefRefPtr<CefV8Value> object,

const CefRefPtr<CefV8Value> value,

CefString& exception) = 0;

public:

///

/// Returns the exception message.

///

/*--cef()--*/

virtual CefString GetMessage() = 0;

///

/// Returns the line of source code that the exception occurred within.

///

/*--cef()--*/

virtual CefString GetSourceLine() = 0;

///

/// Returns the resource name for the script from where the function causing

/// the error originates.

///

/*--cef()--*/

virtual CefString GetScriptResourceName() = 0;

///

/// Returns the 1-based number of the line where the error occurred or 0 if

/// the line number is unknown.

///

/*--cef()--*/

virtual int GetLineNumber() = 0;

///

/// Returns the index within the script of the first character where the error

/// occurred.

///

/*--cef()--*/

virtual int GetStartPosition() = 0;

///

/// Returns the index within the script of the last character where the error

/// occurred.

///

/*--cef()--*/

virtual int GetEndPosition() = 0;

///

/// Returns the index within the line of the first character where the error

/// occurred.

///

/*--cef()--*/

virtual int GetStartColumn() = 0;

///

/// Returns the index within the line of the last character where the error

/// occurred.

///

/*--cef()--*/

virtual int GetEndColumn() = 0;

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;

public:

typedef cef_v8_propertyattribute_t PropertyAttribute;

///

/// Create a new CefV8Value object of type undefined.

///

/*--cef()--*/

static CefRefPtr<CefV8Value> CreateUndefined();

///

/// Create a new CefV8Value object of type null.

///

/*--cef()--*/

static CefRefPtr<CefV8Value> CreateNull();

///

/// Create a new CefV8Value object of type bool.

///

/*--cef()--*/

static CefRefPtr<CefV8Value> CreateBool(bool value);

///

/// Create a new CefV8Value object of type int.

///

/*--cef()--*/

static CefRefPtr<CefV8Value> CreateInt(int32_t value);

///

/// Create a new CefV8Value object of type unsigned int.

///

/*--cef()--*/

static CefRefPtr<CefV8Value> CreateUInt(uint32_t value);

///

/// Create a new CefV8Value object of type double.

///

/*--cef()--*/

static CefRefPtr<CefV8Value> CreateDouble(double value);

///

/// Create a new CefV8Value object of type Date. 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> CreateDate(CefBaseTime date);

///

/// Create a new CefV8Value object of type string.

///

/*--cef(optional_param=value)--*/

static CefRefPtr<CefV8Value> CreateString(const CefString& value);

///

/// Create a new CefV8Value object of type object with optional accessor

/// and/or interceptor. 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(optional_param=accessor, optional_param=interceptor)--*/

static CefRefPtr<CefV8Value> CreateObject(

CefRefPtr<CefV8Accessor> accessor,

CefRefPtr<CefV8Interceptor> interceptor);

///

/// Create a new CefV8Value object of type array with the specified |length|.

/// If |length| is negative the returned array will have length 0. 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> 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(optional_param=buffer)--*/

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 CefV8Accessor callback, or in combination with calling Enter() and

/// Exit() on a stored CefV8Context reference.

///

/*--cef()--*/

static CefRefPtr<CefV8Value> CreateFunction(const CefString& name,

CefRefPtr<CefV8Handler> handler);

///

/// Create a new CefV8Value object of type Promise. 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> CreatePromise();

///

/// Returns true if the underlying handle is valid and it can be accessed on

/// the current thread. Do not call any other methods if this method returns

/// false.

///

/*--cef()--*/

virtual bool IsValid() = 0;

///

/// True if the value type is undefined.

///

/*--cef()--*/

virtual bool IsUndefined() = 0;

///

/// True if the value type is null.

///

/*--cef()--*/

virtual bool IsNull() = 0;

///

/// True if the value type is bool.

///

/*--cef()--*/

virtual bool IsBool() = 0;

///

/// True if the value type is int.

///

/*--cef()--*/

virtual bool IsInt() = 0;

///

/// True if the value type is unsigned int.

///

/*--cef()--*/

virtual bool IsUInt() = 0;

///

/// True if the value type is double.

///

/*--cef()--*/

virtual bool IsDouble() = 0;

///

/// True if the value type is Date.

///

/*--cef()--*/

virtual bool IsDate() = 0;

///

/// True if the value type is string.

///

/*--cef()--*/

virtual bool IsString() = 0;

///

/// True if the value type is object.

///

/*--cef()--*/

virtual bool IsObject() = 0;

///

/// True if the value type is array.

///

/*--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.

///

/*--cef()--*/

virtual bool IsFunction() = 0;

///

/// True if the value type is a Promise.

///

/*--cef()--*/

virtual bool IsPromise() = 0;

///

/// Returns true if this object is pointing to the same handle as |that|

/// object.

///

/*--cef()--*/

virtual bool IsSame(CefRefPtr<CefV8Value> that) = 0;

///

/// Return a bool value.

///

/*--cef()--*/

virtual bool GetBoolValue() = 0;

///

/// Return an int value.

///

/*--cef()--*/

virtual int32_t GetIntValue() = 0;

///

/// Return an unsigned int value.

///

/*--cef()--*/

virtual uint32_t GetUIntValue() = 0;

///

/// Return a double value.

///

/*--cef()--*/

virtual double GetDoubleValue() = 0;

///

/// Return a Date value.

///

/*--cef()--*/

virtual CefBaseTime GetDateValue() = 0;

///

/// Return a string value.

///

/*--cef()--*/

virtual CefString GetStringValue() = 0;

/// OBJECT METHODS - These methods are only available on objects. Arrays and

/// functions are also objects. String- and integer-based keys can be used

/// interchangably with the framework converting between them as necessary.

///

/// Returns true if this is a user created object.

///

/*--cef()--*/

virtual bool IsUserCreated() = 0;

///

/// Returns true if the last method call resulted in an exception. This

/// attribute exists only in the scope of the current CEF value object.

///

/*--cef()--*/

virtual bool HasException() = 0;

///

/// Returns the exception resulting from the last method call. This attribute

/// exists only in the scope of the current CEF value object.

///

/*--cef()--*/

virtual CefRefPtr<CefV8Exception> GetException() = 0;

///

/// Clears the last exception and returns true on success.

///

/*--cef()--*/

virtual bool ClearException() = 0;

///

/// Returns true if this object will re-throw future exceptions. This

/// attribute exists only in the scope of the current CEF value object.

///

/*--cef()--*/

virtual bool WillRethrowExceptions() = 0;

///

/// Set whether this object will re-throw future exceptions. By default

/// exceptions are not re-thrown. If a exception is re-thrown the current

/// context should not be accessed again until after the exception has been

/// caught and not re-thrown. Returns true on success. This attribute exists

/// only in the scope of the current CEF value object.

///

/*--cef()--*/

virtual bool SetRethrowExceptions(bool rethrow) = 0;

///

/// Returns true if the object has a value with the specified identifier.

///

/*--cef(capi_name=has_value_bykey,optional_param=key)--*/

virtual bool HasValue(const CefString& key) = 0;

///

/// Returns true if the object has a value with the specified identifier.

///

/*--cef(capi_name=has_value_byindex,index_param=index)--*/

virtual bool HasValue(int index) = 0;

///

/// Deletes the value with the specified identifier and returns true on

/// success. Returns false if this method is called incorrectly or an

/// exception is thrown. For read-only and don't-delete values this method

/// will return true even though deletion failed.

///

/*--cef(capi_name=delete_value_bykey,optional_param=key)--*/

virtual bool DeleteValue(const CefString& key) = 0;

///

/// Deletes the value with the specified identifier and returns true on

/// success. Returns false if this method is called incorrectly, deletion

/// fails or an exception is thrown. For read-only and don't-delete values

/// this method will return true even though deletion failed.

///

/*--cef(capi_name=delete_value_byindex,index_param=index)--*/

virtual bool DeleteValue(int index) = 0;

///

/// Returns the value with the specified identifier on success. Returns NULL

/// if this method is called incorrectly or an exception is thrown.

///

/*--cef(capi_name=get_value_bykey,optional_param=key)--*/

virtual CefRefPtr<CefV8Value> GetValue(const CefString& key) = 0;

///

/// Returns the value with the specified identifier on success. Returns NULL

/// if this method is called incorrectly or an exception is thrown.

///

/*--cef(capi_name=get_value_byindex,index_param=index)--*/

virtual CefRefPtr<CefV8Value> GetValue(int index) = 0;

///

/// Associates a value with the specified identifier and returns true on

/// success. Returns false if this method is called incorrectly or an

/// exception is thrown. For read-only values this method will return true

/// even though assignment failed.

///

/*--cef(capi_name=set_value_bykey,optional_param=key)--*/

virtual bool SetValue(const CefString& key,

CefRefPtr<CefV8Value> value,

PropertyAttribute attribute) = 0;

///

/// Associates a value with the specified identifier and returns true on

/// success. Returns false if this method is called incorrectly or an

/// exception is thrown. For read-only values this method will return true

/// even though assignment failed.

///

/*--cef(capi_name=set_value_byindex,index_param=index)--*/

virtual bool SetValue(int index, CefRefPtr<CefV8Value> value) = 0;

///

/// Registers an identifier and returns true on success. Access to the

/// identifier will be forwarded to the CefV8Accessor instance passed to

/// CefV8Value::CreateObject(). Returns false if this method is called

/// incorrectly or an exception is thrown. For read-only values this method

/// will return true even though assignment failed.

///

/*--cef(capi_name=set_value_byaccessor,optional_param=key)--*/

virtual bool SetValue(const CefString& key, PropertyAttribute attribute) = 0;

///

/// Read the keys for the object's values into the specified vector. Integer-

/// based keys will also be returned as strings.

///

/*--cef()--*/

virtual bool GetKeys(std::vector<CefString>& keys) = 0;

///

/// Sets the user data for this object and returns true on success. Returns

/// false if this method is called incorrectly. This method can only be called

/// on user created objects.

///

/*--cef(optional_param=user_data)--*/

virtual bool SetUserData(CefRefPtr<CefBaseRefCounted> user_data) = 0;

///

/// Returns the user data, if any, assigned to this object.

///

/*--cef()--*/

virtual CefRefPtr<CefBaseRefCounted> GetUserData() = 0;

///

/// Returns the amount of externally allocated memory registered for the

/// object.

///

/*--cef()--*/

virtual int GetExternallyAllocatedMemory() = 0;

///

/// Adjusts the amount of registered external memory for the object. Used to

/// give V8 an indication of the amount of externally allocated memory that is

/// kept alive by JavaScript objects. V8 uses this information to decide when

/// to perform global garbage collection. Each CefV8Value tracks the amount of

/// external memory associated with it and automatically decreases the global

/// total by the appropriate amount on its destruction. |change_in_bytes|

/// specifies the number of bytes to adjust by. This method returns the number

/// of bytes associated with the object after the adjustment. This method can

/// only be called on user created objects.

///

/*--cef()--*/

virtual int AdjustExternallyAllocatedMemory(int change_in_bytes) = 0;

// ARRAY METHODS - These methods are only available on arrays.

///

/// Returns the number of elements in the array.

///

/*--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;

///

/// Returns the length (in bytes) of the ArrayBuffer.

///

/*--cef()--*/

virtual size_t GetArrayBufferByteLength() = 0;

///

/// Returns a pointer to the beginning of the memory block for this

/// ArrayBuffer backing store. The returned pointer is valid as long as the

/// CefV8Value is alive.

///

/*--cef()--*/

virtual void* GetArrayBufferData() = 0;

// FUNCTION METHODS - These methods are only available on functions.

///

/// Returns the function name.

///

/*--cef()--*/

virtual CefString GetFunctionName() = 0;

///

/// Returns the function handler or NULL if not a CEF-created function.

///

/*--cef()--*/

virtual CefRefPtr<CefV8Handler> GetFunctionHandler() = 0;

///

/// Execute the function using the current V8 context. This method should only

/// be called from within the scope of a CefV8Handler or CefV8Accessor

/// callback, or in combination with calling Enter() and Exit() on a stored

/// CefV8Context reference. |object| is the receiver ('this' object) of the

/// function. If |object| is empty the current context's global object will be

/// used. |arguments| is the list of arguments that will be passed to the

/// function. Returns the function return value on success. Returns NULL if

/// this method is called incorrectly or an exception is thrown.

///

/*--cef(optional_param=object)--*/

virtual CefRefPtr<CefV8Value> ExecuteFunction(

CefRefPtr<CefV8Value> object,

const CefV8ValueList& arguments) = 0;

///

/// Execute the function using the specified V8 context. |object| is the

/// receiver ('this' object) of the function. If |object| is empty the

/// specified context's global object will be used. |arguments| is the list of

/// arguments that will be passed to the function. Returns the function return

/// value on success. Returns NULL if this method is called incorrectly or an

/// exception is thrown.

///

/*--cef(optional_param=object)--*/

virtual CefRefPtr<CefV8Value> ExecuteFunctionWithContext(

CefRefPtr<CefV8Context> context,

CefRefPtr<CefV8Value> object,

const CefV8ValueList& arguments) = 0;

// PROMISE METHODS - These methods are only available on Promises.

///

/// Resolve the Promise using the current V8 context. This method should only

/// be called from within the scope of a CefV8Handler or CefV8Accessor

/// callback, or in combination with calling Enter() and Exit() on a stored

/// CefV8Context reference. |arg| is the argument passed to the resolved

/// promise. Returns true on success. Returns false if this method is called

/// incorrectly or an exception is thrown.

///

/*--cef(optional_param=arg)--*/

virtual bool ResolvePromise(CefRefPtr<CefV8Value> arg) = 0;

///

/// Reject the Promise using the current V8 context. This method should only

/// be called from within the scope of a CefV8Handler or CefV8Accessor

/// callback, or in combination with calling Enter() and Exit() on a stored

/// CefV8Context reference. Returns true on success. Returns false if this

/// method is called incorrectly or an exception is thrown.

///

/*--cef()--*/

virtual bool RejectPromise(const CefString& errorMsg) = 0;

public:

///

/// Returns the stack trace for the currently active context. |frame_limit| is

/// the maximum number of frames that will be captured.

///

/*--cef()--*/

static CefRefPtr<CefV8StackTrace> GetCurrent(int frame_limit);

///

/// Returns true if the underlying handle is valid and it can be accessed on

/// the current thread. Do not call any other methods if this method returns

/// false.

///

/*--cef()--*/

virtual bool IsValid() = 0;

///

/// Returns the number of stack frames.

///

/*--cef()--*/

virtual int GetFrameCount() = 0;

///

/// Returns the stack frame at the specified 0-based index.

///

/*--cef()--*/

virtual CefRefPtr<CefV8StackFrame> GetFrame(int index) = 0;

public:

///

/// Returns true if the underlying handle is valid and it can be accessed on

/// the current thread. Do not call any other methods if this method returns

/// false.

///