bcarrella/cef
1
0
Fork 0
mirror of https://bitbucket.org/chromiumembedded/cef synced 2025-06-05 21:39:12 +02:00
Code Issues Packages Projects Releases Wiki Activity

Support implicit detachment of CEF V8 references when the associated context is released (issue #484).

Browse Source 
git-svn-id: https://chromiumembedded.googlecode.com/svn/trunk@883 5089003a-bbd8-11dd-ad1f-f1f9622dbc98
This commit is contained in:
Marshall Greenblatt
2012-10-29 21:54:57 +00:00
parent 3ac5952636
commit 59fe4fbab3
25 changed files with 522 additions and 43 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
cef1/include/capi/cef_v8_capi.h
View File

@ -114,6 +114,12 @@ typedef struct _cef_v8context_t {
///
cef_base_t base;
///
// Returns true (1) if this object is valid. Do not call any other functions
// if this function returns false (0).
///
int (CEF_CALLBACK *is_valid)(struct _cef_v8context_t* self);
///
// Returns the browser for this context.
///
@ -314,6 +320,12 @@ typedef struct _cef_v8value_t {
///
cef_base_t base;
///
// Returns true (1) if this object is valid. Do not call any other functions
// if this function returns false (0).
///
int (CEF_CALLBACK *is_valid)(struct _cef_v8value_t* self);
///
// True if the value type is undefined.
///
@ -708,6 +720,12 @@ typedef struct _cef_v8stack_trace_t {
///
cef_base_t base;
///
// Returns true (1) if this object is valid. Do not call any other functions
// if this function returns false (0).
///
int (CEF_CALLBACK *is_valid)(struct _cef_v8stack_trace_t* self);
///
// Returns the number of stack frames.
///
@ -738,6 +756,12 @@ typedef struct _cef_v8stack_frame_t {
///
cef_base_t base;
///
// Returns true (1) if this object is valid. Do not call any other functions
// if this function returns false (0).
///
int (CEF_CALLBACK *is_valid)(struct _cef_v8stack_frame_t* self);
///
// Returns the name of the resource script that contains the function.
///

28
cef1/include/cef_v8.h
View File

@ -140,6 +140,13 @@ class CefV8Context : public virtual CefBase {
/*--cef()--*/
static bool InContext();
///
// Returns true if this object is valid. Do not call any other methods if this
// method returns false.
///
/*--cef()--*/
virtual bool IsValid() =0;
///
// Returns the browser for this context.
///
@ -407,6 +414,13 @@ class CefV8Value : public virtual CefBase {
static CefRefPtr<CefV8Value> CreateFunction(const CefString& name,
CefRefPtr<CefV8Handler> handler);
///
// Returns true if this object is valid. Do not call any other methods if this
// method returns false.
///
/*--cef()--*/
virtual bool IsValid() =0;
///
// True if the value type is undefined.
///
@ -754,6 +768,13 @@ class CefV8StackTrace : public virtual CefBase {
/*--cef()--*/
static CefRefPtr<CefV8StackTrace> GetCurrent(int frame_limit);
///
// Returns true if this object is valid. Do not call any other methods if this
// method returns false.
///
/*--cef()--*/
virtual bool IsValid() =0;
///
// Returns the number of stack frames.
///
@ -774,6 +795,13 @@ class CefV8StackTrace : public virtual CefBase {
/*--cef(source=library)--*/
class CefV8StackFrame : public virtual CefBase {
public:
///
// Returns true if this object is valid. Do not call any other methods if this
// method returns false.
///
/*--cef()--*/
virtual bool IsValid() =0;
///
// Returns the name of the resource script that contains the function.
///

19
cef1/include/internal/cef_types.h
View File

@ -218,6 +218,25 @@ typedef struct _cef_settings_t {
// OnUncaughtException() will not be called.
///
int uncaught_exception_stack_size;
///
// By default CEF V8 references will be invalidated (the IsValid() method will
// return false) after the owning context has been released. This reduces the
// need for external record keeping and avoids crashes due to the use of V8
// references after the associated context has been released.
//
// CEF currently offers two context safety implementations with different
// performance characteristics. The default implementation (value of 0) uses a
// map of hash values and should provide better performance in situations with
// a small number contexts. The alternate implementation (value of 1) uses a
// hidden value attached to each context and should provide better performance
// in situations with a large number of contexts.
//
// If you need better performance in the creation of V8 references and you
// plan to manually track context lifespan you can disable context safety by
// specifying a value of -1.
///
int context_safety_implementation;
} cef_settings_t;
///

1
cef1/include/internal/cef_types_wrappers.h
View File

@ -300,6 +300,7 @@ struct CefSettingsTraits {
&target->locales_dir_path, copy);
target->pack_loading_disabled = src->pack_loading_disabled;
target->uncaught_exception_stack_size = src->uncaught_exception_stack_size;
target->context_safety_implementation = src->context_safety_implementation;
}
};

23
cef1/libcef/browser_webview_delegate.cc
View File

@ -921,20 +921,21 @@ void BrowserWebViewDelegate::didCreateScriptContext(
void BrowserWebViewDelegate::willReleaseScriptContext(
WebFrame* frame, v8::Handle<v8::Context> context, int worldId) {
CefRefPtr<CefClient> client = browser_->GetClient();
if (!client.get())
return;
if (client.get()) {
CefRefPtr<CefV8ContextHandler> handler = client->GetV8ContextHandler();
if (handler.get()) {
v8::HandleScope handle_scope;
v8::Context::Scope scope(context);
CefRefPtr<CefV8ContextHandler> handler = client->GetV8ContextHandler();
if (!handler.get())
return;
CefRefPtr<CefFrame> framePtr(browser_->UIT_GetCefFrame(frame));
CefRefPtr<CefV8Context> contextPtr(new CefV8ContextImpl(context));
v8::HandleScope handle_scope;
v8::Context::Scope scope(context);
handler->OnContextReleased(browser_, framePtr, contextPtr);
}
}
CefRefPtr<CefFrame> framePtr(browser_->UIT_GetCefFrame(frame));
CefRefPtr<CefV8Context> contextPtr(new CefV8ContextImpl(context));
handler->OnContextReleased(browser_, framePtr, contextPtr);
// Disconnect any handles still associated with the context.
CefV8ReleaseContext(context);
}
void BrowserWebViewDelegate::didReceiveTitle(

189
cef1/libcef/v8_impl.cc
View File

@ -3,6 +3,7 @@
// can be found in the LICENSE file.
#include <string>
#include <vector>
#include "base/compiler_specific.h"
@ -43,10 +44,110 @@ MSVC_POP_WARNING();
namespace {
static const char kCefTrackObject[] = "Cef::TrackObject";
static const char kCefContextState[] = "Cef::ContextState";
// Memory manager.
base::LazyInstance<CefTrackManager> g_v8_tracker = LAZY_INSTANCE_INITIALIZER;
class CefV8TrackManager : public CefTrackManager {
public:
CefV8TrackManager() {
const CefSettings& settings = _Context->settings();
if (settings.context_safety_implementation < 0)
context_safety_impl_ = IMPL_DISABLED;
else if (settings.context_safety_implementation == 1)
context_safety_impl_ = IMPL_VALUE;
else
context_safety_impl_ = IMPL_HASH;
}
scoped_refptr<CefV8ContextState> GetContextState(
v8::Handle<v8::Context> context) {
if (context_safety_impl_ == IMPL_DISABLED)
return scoped_refptr<CefV8ContextState>();
if (context.IsEmpty()) {
if (v8::Context::InContext())
context = v8::Context::GetCurrent();
else
return scoped_refptr<CefV8ContextState>();
}
if (context_safety_impl_ == IMPL_HASH) {
int hash = context->Global()->GetIdentityHash();
ContextMap::const_iterator it = context_map_.find(hash);
if (it != context_map_.end())
return it->second;
scoped_refptr<CefV8ContextState> state = new CefV8ContextState();
context_map_.insert(std::make_pair(hash, state));
return state;
} else {
if (context_state_key_.IsEmpty()) {
context_state_key_ =
v8::Persistent<v8::String>::New(v8::String::New(kCefContextState));
}
v8::Handle<v8::Object> object = context->Global();
v8::Handle<v8::Value> value = object->GetHiddenValue(context_state_key_);
if (!value.IsEmpty())
return static_cast<CefV8ContextState*>(v8::External::Unwrap(value));
scoped_refptr<CefV8ContextState> state = new CefV8ContextState();
object->SetHiddenValue(context_state_key_,
v8::External::New(state.get()));
// Reference will be released in ReleaseContext.
state->AddRef();
return state;
}
}
void ReleaseContext(v8::Handle<v8::Context> context) {
if (context_safety_impl_ == IMPL_DISABLED)
return;
if (context_safety_impl_ == IMPL_HASH) {
int hash = context->Global()->GetIdentityHash();
ContextMap::iterator it = context_map_.find(hash);
if (it != context_map_.end()) {
it->second->Detach();
context_map_.erase(it);
}
} else {
if (context_state_key_.IsEmpty())
return;
v8::Handle<v8::Object> object = context->Global();
v8::Handle<v8::Value> value = object->GetHiddenValue(context_state_key_);
scoped_refptr<CefV8ContextState> state =
static_cast<CefV8ContextState*>(v8::External::Unwrap(value));
state->Detach();
object->DeleteHiddenValue(context_state_key_);
// Match the AddRef in GetContextState.
state->Release();
}
}
private:
enum ContextSafetyImpl {
IMPL_DISABLED,
IMPL_HASH,
IMPL_VALUE,
};
ContextSafetyImpl context_safety_impl_;
// Used with IMPL_HASH.
typedef std::map<int, scoped_refptr<CefV8ContextState> > ContextMap;
ContextMap context_map_;
// Used with IMPL_VALUE.
v8::Persistent<v8::String> context_state_key_;
};
base::LazyInstance<CefV8TrackManager> g_v8_tracker = LAZY_INSTANCE_INITIALIZER;
class V8TrackObject : public CefTrackNode {
public:
@ -417,6 +518,10 @@ class CefV8ExceptionImpl : public CefV8Exception {
// Global functions.
void CefV8ReleaseContext(v8::Handle<v8::Context> context) {
g_v8_tracker.Pointer()->ReleaseContext(context);
}
bool CefRegisterExtension(const CefString& extension_name,
const CefString& javascript_code,
CefRefPtr<CefV8Handler> handler) {
@ -437,6 +542,13 @@ bool CefRegisterExtension(const CefString& extension_name,
}
// CefV8HandleBase
CefV8HandleBase::CefV8HandleBase(v8::Handle<v8::Context> context) {
context_state_ = g_v8_tracker.Pointer()->GetContextState(context);
}
// CefV8Context
// static
@ -473,26 +585,35 @@ bool CefV8Context::InContext() {
// CefV8ContextImpl
#define CEF_V8_REQUIRE_VALID_RETURN(ret) \
if (!handle_->IsValid()) { \
NOTREACHED() << "V8 handle is not valid"; \
return ret; \
}
#define CEF_V8_REQUIRE_OBJECT_RETURN(ret) \
CEF_V8_REQUIRE_VALID_RETURN(ret); \
if (!GetHandle()->IsObject()) { \
NOTREACHED() << "V8 value is not an object"; \
return ret; \
}
#define CEF_V8_REQUIRE_ARRAY_RETURN(ret) \
CEF_V8_REQUIRE_VALID_RETURN(ret); \
if (!GetHandle()->IsArray()) { \
NOTREACHED() << "V8 value is not an array"; \
return ret; \
}
#define CEF_V8_REQUIRE_FUNCTION_RETURN(ret) \
CEF_V8_REQUIRE_VALID_RETURN(ret); \
if (!GetHandle()->IsFunction()) { \
NOTREACHED() << "V8 value is not a function"; \
return ret; \
}
CefV8ContextImpl::CefV8ContextImpl(v8::Handle<v8::Context> context)
: handle_(new Handle(context))
: handle_(new Handle(context, context))
#ifndef NDEBUG
, enter_count_(0)
#endif
@ -503,9 +624,15 @@ CefV8ContextImpl::~CefV8ContextImpl() {
DLOG_ASSERT(0 == enter_count_);
}
bool CefV8ContextImpl::IsValid() {
CEF_REQUIRE_UI_THREAD(false);
return handle_->IsValid();
}
CefRefPtr<CefBrowser> CefV8ContextImpl::GetBrowser() {
CefRefPtr<CefBrowser> browser;
CEF_REQUIRE_UI_THREAD(browser);
CEF_V8_REQUIRE_VALID_RETURN(browser);
WebKit::WebFrame* webframe = GetWebFrame();
if (webframe)
@ -517,6 +644,7 @@ CefRefPtr<CefBrowser> CefV8ContextImpl::GetBrowser() {
CefRefPtr<CefFrame> CefV8ContextImpl::GetFrame() {
CefRefPtr<CefFrame> frame;
CEF_REQUIRE_UI_THREAD(frame);
CEF_V8_REQUIRE_VALID_RETURN(frame);
WebKit::WebFrame* webframe = GetWebFrame();
if (webframe) {
@ -531,6 +659,7 @@ CefRefPtr<CefFrame> CefV8ContextImpl::GetFrame() {
CefRefPtr<CefV8Value> CefV8ContextImpl::GetGlobal() {
CEF_REQUIRE_UI_THREAD(NULL);
CEF_V8_REQUIRE_VALID_RETURN(NULL);
v8::HandleScope handle_scope;
v8::Context::Scope context_scope(GetHandle());
@ -539,6 +668,8 @@ CefRefPtr<CefV8Value> CefV8ContextImpl::GetGlobal() {
bool CefV8ContextImpl::Enter() {
CEF_REQUIRE_UI_THREAD(false);
CEF_V8_REQUIRE_VALID_RETURN(false);
GetHandle()->Enter();
#ifndef NDEBUG
++enter_count_;
@ -548,6 +679,8 @@ bool CefV8ContextImpl::Enter() {
bool CefV8ContextImpl::Exit() {
CEF_REQUIRE_UI_THREAD(false);
CEF_V8_REQUIRE_VALID_RETURN(false);
DLOG_ASSERT(enter_count_ > 0);
GetHandle()->Exit();
#ifndef NDEBUG
@ -558,6 +691,7 @@ bool CefV8ContextImpl::Exit() {
bool CefV8ContextImpl::IsSame(CefRefPtr<CefV8Context> that) {
CEF_REQUIRE_UI_THREAD(false);
CEF_V8_REQUIRE_VALID_RETURN(false);
v8::HandleScope handle_scope;
@ -575,6 +709,7 @@ bool CefV8ContextImpl::Eval(const CefString& code,
CefRefPtr<CefV8Value>& retval,
CefRefPtr<CefV8Exception>& exception) {
CEF_REQUIRE_UI_THREAD(false);
CEF_V8_REQUIRE_VALID_RETURN(false);
if (code.empty()) {
NOTREACHED() << "invalid input parameter";
@ -820,71 +955,89 @@ CefRefPtr<CefV8Value> CefV8Value::CreateFunction(
CefV8ValueImpl::CefV8ValueImpl(v8::Handle<v8::Value> value,
CefTrackNode* tracker)
: handle_(new Handle(value, tracker)),
: handle_(new Handle(v8::Handle<v8::Context>(), value, tracker)),
rethrow_exceptions_(false) {
}
CefV8ValueImpl::~CefV8ValueImpl() {
}
bool CefV8ValueImpl::IsValid() {
CEF_REQUIRE_UI_THREAD(false);
return handle_->IsValid();
}
bool CefV8ValueImpl::IsUndefined() {
CEF_REQUIRE_UI_THREAD(false);
CEF_V8_REQUIRE_VALID_RETURN(false);
return GetHandle()->IsUndefined();
}
bool CefV8ValueImpl::IsNull() {
CEF_REQUIRE_UI_THREAD(false);
CEF_V8_REQUIRE_VALID_RETURN(false);
return GetHandle()->IsNull();
}
bool CefV8ValueImpl::IsBool() {
CEF_REQUIRE_UI_THREAD(false);
CEF_V8_REQUIRE_VALID_RETURN(false);
return (GetHandle()->IsBoolean() || GetHandle()->IsTrue()
|| GetHandle()->IsFalse());
}
bool CefV8ValueImpl::IsInt() {
CEF_REQUIRE_UI_THREAD(false);
CEF_V8_REQUIRE_VALID_RETURN(false);
return GetHandle()->IsInt32();
}
bool CefV8ValueImpl::IsUInt() {
CEF_REQUIRE_UI_THREAD(false);
CEF_V8_REQUIRE_VALID_RETURN(false);
return GetHandle()->IsUint32();
}
bool CefV8ValueImpl::IsDouble() {
CEF_REQUIRE_UI_THREAD(false);
CEF_V8_REQUIRE_VALID_RETURN(false);
return GetHandle()->IsNumber();
}
bool CefV8ValueImpl::IsDate() {
CEF_REQUIRE_UI_THREAD(false);
CEF_V8_REQUIRE_VALID_RETURN(false);
return GetHandle()->IsDate();
}
bool CefV8ValueImpl::IsString() {
CEF_REQUIRE_UI_THREAD(false);
CEF_V8_REQUIRE_VALID_RETURN(false);
return GetHandle()->IsString();
}
bool CefV8ValueImpl::IsObject() {
CEF_REQUIRE_UI_THREAD(false);
CEF_V8_REQUIRE_VALID_RETURN(false);
return GetHandle()->IsObject();
}
bool CefV8ValueImpl::IsArray() {
CEF_REQUIRE_UI_THREAD(false);
CEF_V8_REQUIRE_VALID_RETURN(false);
return GetHandle()->IsArray();
}
bool CefV8ValueImpl::IsFunction() {
CEF_REQUIRE_UI_THREAD(false);
CEF_V8_REQUIRE_VALID_RETURN(false);
return GetHandle()->IsFunction();
}
bool CefV8ValueImpl::IsSame(CefRefPtr<CefV8Value> that) {
CEF_REQUIRE_UI_THREAD(false);
CEF_V8_REQUIRE_VALID_RETURN(false);
v8::HandleScope handle_scope;
@ -900,6 +1053,7 @@ bool CefV8ValueImpl::IsSame(CefRefPtr<CefV8Value> that) {
bool CefV8ValueImpl::GetBoolValue() {
CEF_REQUIRE_UI_THREAD(false);
CEF_V8_REQUIRE_VALID_RETURN(false);
if (GetHandle()->IsTrue()) {
return true;
} else if (GetHandle()->IsFalse()) {
@ -913,6 +1067,7 @@ bool CefV8ValueImpl::GetBoolValue() {
int32 CefV8ValueImpl::GetIntValue() {
CEF_REQUIRE_UI_THREAD(0);
CEF_V8_REQUIRE_VALID_RETURN(0);
v8::HandleScope handle_scope;
v8::Local<v8::Int32> val = GetHandle()->ToInt32();
return val->Value();
@ -920,6 +1075,7 @@ int32 CefV8ValueImpl::GetIntValue() {
uint32 CefV8ValueImpl::GetUIntValue() {
CEF_REQUIRE_UI_THREAD(0);
CEF_V8_REQUIRE_VALID_RETURN(0);
v8::HandleScope handle_scope;
v8::Local<v8::Uint32> val = GetHandle()->ToUint32();
return val->Value();
@ -927,6 +1083,7 @@ uint32 CefV8ValueImpl::GetUIntValue() {
double CefV8ValueImpl::GetDoubleValue() {
CEF_REQUIRE_UI_THREAD(0.);
CEF_V8_REQUIRE_VALID_RETURN(0.);
v8::HandleScope handle_scope;
v8::Local<v8::Number> val = GetHandle()->ToNumber();
return val->Value();
@ -934,6 +1091,7 @@ double CefV8ValueImpl::GetDoubleValue() {
CefTime CefV8ValueImpl::GetDateValue() {
CEF_REQUIRE_UI_THREAD(CefTime(0.));
CEF_V8_REQUIRE_VALID_RETURN(CefTime(0.));
v8::HandleScope handle_scope;
v8::Local<v8::Number> val = GetHandle()->ToNumber();
// Convert from milliseconds to seconds.
@ -943,6 +1101,7 @@ CefTime CefV8ValueImpl::GetDateValue() {
CefString CefV8ValueImpl::GetStringValue() {
CefString rv;
CEF_REQUIRE_UI_THREAD(rv);
CEF_V8_REQUIRE_VALID_RETURN(rv);
v8::HandleScope handle_scope;
GetCefString(GetHandle()->ToString(), rv);
return rv;
@ -1367,6 +1526,7 @@ CefRefPtr<CefV8StackTrace> CefV8StackTrace::GetCurrent(int frame_limit) {
CEF_REQUIRE_VALID_CONTEXT(NULL);
CEF_REQUIRE_UI_THREAD(NULL);
v8::HandleScope handle_scope;
v8::Handle<v8::StackTrace> stackTrace =
v8::StackTrace::CurrentStackTrace(
frame_limit, v8::StackTrace::kDetailed);
@ -1379,20 +1539,27 @@ CefRefPtr<CefV8StackTrace> CefV8StackTrace::GetCurrent(int frame_limit) {
// CefV8StackTraceImpl
CefV8StackTraceImpl::CefV8StackTraceImpl(v8::Handle<v8::StackTrace> handle)
: handle_(new Handle(handle)) {
: handle_(new Handle(v8::Handle<v8::Context>(), handle)) {
}
CefV8StackTraceImpl::~CefV8StackTraceImpl() {
}
bool CefV8StackTraceImpl::IsValid() {
CEF_REQUIRE_UI_THREAD(false);
return handle_->IsValid();
}
int CefV8StackTraceImpl::GetFrameCount() {
CEF_REQUIRE_UI_THREAD(0);
CEF_V8_REQUIRE_VALID_RETURN(0);
v8::HandleScope handle_scope;
return GetHandle()->GetFrameCount();
}
CefRefPtr<CefV8StackFrame> CefV8StackTraceImpl::GetFrame(int index) {
CEF_REQUIRE_UI_THREAD(NULL);
CEF_V8_REQUIRE_VALID_RETURN(NULL);
v8::HandleScope handle_scope;
v8::Handle<v8::StackFrame> stackFrame = GetHandle()->GetFrame(index);
if (stackFrame.IsEmpty())
@ -1404,15 +1571,21 @@ CefRefPtr<CefV8StackFrame> CefV8StackTraceImpl::GetFrame(int index) {
// CefV8StackFrameImpl
CefV8StackFrameImpl::CefV8StackFrameImpl(v8::Handle<v8::StackFrame> handle)
: handle_(new Handle(handle)) {
: handle_(new Handle(v8::Handle<v8::Context>(), handle)) {
}
CefV8StackFrameImpl::~CefV8StackFrameImpl() {
}
bool CefV8StackFrameImpl::IsValid() {
CEF_REQUIRE_UI_THREAD(false);
return handle_->IsValid();
}
CefString CefV8StackFrameImpl::GetScriptName() {
CefString rv;
CEF_REQUIRE_UI_THREAD(rv);
CEF_V8_REQUIRE_VALID_RETURN(rv);
v8::HandleScope handle_scope;
GetCefString(v8::Handle<v8::String>::Cast(GetHandle()->GetScriptName()), rv);
return rv;
@ -1421,6 +1594,7 @@ CefString CefV8StackFrameImpl::GetScriptName() {
CefString CefV8StackFrameImpl::GetScriptNameOrSourceURL() {
CefString rv;
CEF_REQUIRE_UI_THREAD(rv);
CEF_V8_REQUIRE_VALID_RETURN(rv);
v8::HandleScope handle_scope;
GetCefString(
v8::Handle<v8::String>::Cast(GetHandle()->GetScriptNameOrSourceURL()),
@ -1431,6 +1605,7 @@ CefString CefV8StackFrameImpl::GetScriptNameOrSourceURL() {
CefString CefV8StackFrameImpl::GetFunctionName() {
CefString rv;
CEF_REQUIRE_UI_THREAD(rv);
CEF_V8_REQUIRE_VALID_RETURN(rv);
v8::HandleScope handle_scope;
GetCefString(
v8::Handle<v8::String>::Cast(GetHandle()->GetFunctionName()), rv);
@ -1439,24 +1614,28 @@ CefString CefV8StackFrameImpl::GetFunctionName() {
int CefV8StackFrameImpl::GetLineNumber() {
CEF_REQUIRE_UI_THREAD(0);
CEF_V8_REQUIRE_VALID_RETURN(0);
v8::HandleScope handle_scope;
return GetHandle()->GetLineNumber();
}
int CefV8StackFrameImpl::GetColumn() {
CEF_REQUIRE_UI_THREAD(0);
CEF_V8_REQUIRE_VALID_RETURN(0);
v8::HandleScope handle_scope;
return GetHandle()->GetColumn();
}
bool CefV8StackFrameImpl::IsEval() {
CEF_REQUIRE_UI_THREAD(false);
CEF_V8_REQUIRE_VALID_RETURN(false);
v8::HandleScope handle_scope;
return GetHandle()->IsEval();
}
bool CefV8StackFrameImpl::IsConstructor() {
CEF_REQUIRE_UI_THREAD(false);
CEF_V8_REQUIRE_VALID_RETURN(false);
v8::HandleScope handle_scope;
return GetHandle()->IsConstructor();
}

73
cef1/libcef/v8_impl.h
View File

@ -19,25 +19,65 @@ namespace WebKit {
class WebFrame;
};
// Call to detach all handles associated with the specified contxt.
void CefV8ReleaseContext(v8::Handle<v8::Context> context);
// Used to detach handles when the associated context is released.
class CefV8ContextState : public base::RefCounted<CefV8ContextState> {
public:
CefV8ContextState() : valid_(true) {}
virtual ~CefV8ContextState() {}
bool IsValid() { return valid_; }
void Detach() { valid_ = false; }
private:
bool valid_;
};
// Base class for V8 Handle types.
class CefV8HandleBase :
public base::RefCountedThreadSafe<CefV8HandleBase,
CefThread::DeleteOnUIThread> {
public:
virtual ~CefV8HandleBase() {}
// Returns true if there is no underlying context or if the underlying context
// is valid.
bool IsValid() {
return (!context_state_.get() || context_state_->IsValid());
}
protected:
// |context| is the context that owns this handle. If empty the current
// context will be used.
explicit CefV8HandleBase(v8::Handle<v8::Context> context);
private:
scoped_refptr<CefV8ContextState> context_state_;
};
// Template for V8 Handle types. This class is used to ensure that V8 objects
// are only released on the UI thread.
template <typename v8class>
class CefV8Handle :
public base::RefCountedThreadSafe<CefV8Handle<v8class>,
CefThread::DeleteOnUIThread> {
class CefV8Handle : public CefV8HandleBase {
public:
typedef v8::Handle<v8class> handleType;
typedef v8::Persistent<v8class> persistentType;
CefV8Handle(handleType v)
: handle_(persistentType::New(v)) {
CefV8Handle(v8::Handle<v8::Context> context, handleType v)
: CefV8HandleBase(context),
handle_(persistentType::New(v)) {
}
~CefV8Handle() {
virtual ~CefV8Handle() {
handle_.Dispose();
handle_.Clear();
}
handleType GetHandle() { return handle_; }
handleType GetHandle() {
DCHECK(IsValid());
return handle_;
}
protected:
persistentType handle_;
@ -57,6 +97,7 @@ class CefV8ContextImpl : public CefV8Context {
explicit CefV8ContextImpl(v8::Handle<v8::Context> context);
virtual ~CefV8ContextImpl();
virtual bool IsValid() OVERRIDE;
virtual CefRefPtr<CefBrowser> GetBrowser() OVERRIDE;
virtual CefRefPtr<CefFrame> GetFrame() OVERRIDE;
virtual CefRefPtr<CefV8Value> GetGlobal() OVERRIDE;
@ -90,6 +131,7 @@ class CefV8ValueImpl : public CefV8Value {
CefV8ValueImpl(v8::Handle<v8::Value> value, CefTrackNode* tracker = NULL);
virtual ~CefV8ValueImpl();
virtual bool IsValid() OVERRIDE;
virtual bool IsUndefined() OVERRIDE;
virtual bool IsNull() OVERRIDE;
virtual bool IsBool() OVERRIDE;
@ -147,19 +189,22 @@ class CefV8ValueImpl : public CefV8Value {
// Test for and record any exception.
bool HasCaught(v8::TryCatch& try_catch);
class Handle :
public base::RefCountedThreadSafe<Handle, CefThread::DeleteOnUIThread> {
class Handle : public CefV8HandleBase {
public:
typedef v8::Handle<v8::Value> handleType;
typedef v8::Persistent<v8::Value> persistentType;
Handle(handleType v, CefTrackNode* tracker)
: handle_(persistentType::New(v)),
Handle(v8::Handle<v8::Context> context, handleType v, CefTrackNode* tracker)
: CefV8HandleBase(context),
handle_(persistentType::New(v)),
tracker_(tracker) {
}
~Handle();
virtual ~Handle();
handleType GetHandle() { return handle_; }
handleType GetHandle() {
DCHECK(IsValid());
return handle_;
}
private:
persistentType handle_;
@ -184,6 +229,7 @@ class CefV8StackTraceImpl : public CefV8StackTrace {
explicit CefV8StackTraceImpl(v8::Handle<v8::StackTrace> handle);
virtual ~CefV8StackTraceImpl();
virtual bool IsValid() OVERRIDE;
virtual int GetFrameCount() OVERRIDE;
virtual CefRefPtr<CefV8StackFrame> GetFrame(int index) OVERRIDE;
@ -202,6 +248,7 @@ class CefV8StackFrameImpl : public CefV8StackFrame {
explicit CefV8StackFrameImpl(v8::Handle<v8::StackFrame> handle);
virtual ~CefV8StackFrameImpl();
virtual bool IsValid() OVERRIDE;
virtual CefString GetScriptName() OVERRIDE;
virtual CefString GetScriptNameOrSourceURL() OVERRIDE;
virtual CefString GetFunctionName() OVERRIDE;

15
cef1/libcef_dll/cpptoc/v8context_cpptoc.cc
View File

@ -52,6 +52,20 @@ CEF_EXPORT int cef_v8context_in_context() {
// MEMBER FUNCTIONS - Body may be edited by hand.
int CEF_CALLBACK v8context_is_valid(struct _cef_v8context_t* self) {
// AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
DCHECK(self);
if (!self)
return 0;
// Execute
bool _retval = CefV8ContextCppToC::Get(self)->IsValid();
// Return type: bool
return _retval;
}
cef_browser_t* CEF_CALLBACK v8context_get_browser(
struct _cef_v8context_t* self) {
// AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
@ -212,6 +226,7 @@ int CEF_CALLBACK v8context_eval(struct _cef_v8context_t* self,
CefV8ContextCppToC::CefV8ContextCppToC(CefV8Context* cls)
: CefCppToC<CefV8ContextCppToC, CefV8Context, cef_v8context_t>(cls) {
struct_.struct_.is_valid = v8context_is_valid;
struct_.struct_.get_browser = v8context_get_browser;
struct_.struct_.get_frame = v8context_get_frame;
struct_.struct_.get_global = v8context_get_global;

15
cef1/libcef_dll/cpptoc/v8stack_frame_cpptoc.cc
View File

@ -15,6 +15,20 @@
// MEMBER FUNCTIONS - Body may be edited by hand.
int CEF_CALLBACK v8stack_frame_is_valid(struct _cef_v8stack_frame_t* self) {
// AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
DCHECK(self);
if (!self)
return 0;
// Execute
bool _retval = CefV8StackFrameCppToC::Get(self)->IsValid();
// Return type: bool
return _retval;
}
cef_string_userfree_t CEF_CALLBACK v8stack_frame_get_script_name(
struct _cef_v8stack_frame_t* self) {
// AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
@ -125,6 +139,7 @@ int CEF_CALLBACK v8stack_frame_is_constructor(
CefV8StackFrameCppToC::CefV8StackFrameCppToC(CefV8StackFrame* cls)
: CefCppToC<CefV8StackFrameCppToC, CefV8StackFrame, cef_v8stack_frame_t>(
cls) {
struct_.struct_.is_valid = v8stack_frame_is_valid;
struct_.struct_.get_script_name = v8stack_frame_get_script_name;
struct_.struct_.get_script_name_or_source_url =
v8stack_frame_get_script_name_or_source_url;

15
cef1/libcef_dll/cpptoc/v8stack_trace_cpptoc.cc
View File

@ -30,6 +30,20 @@ CEF_EXPORT cef_v8stack_trace_t* cef_v8stack_trace_get_current(int frame_limit) {
// MEMBER FUNCTIONS - Body may be edited by hand.
int CEF_CALLBACK v8stack_trace_is_valid(struct _cef_v8stack_trace_t* self) {
// AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
DCHECK(self);
if (!self)
return 0;
// Execute
bool _retval = CefV8StackTraceCppToC::Get(self)->IsValid();
// Return type: bool
return _retval;
}
int CEF_CALLBACK v8stack_trace_get_frame_count(
struct _cef_v8stack_trace_t* self) {
// AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
@ -68,6 +82,7 @@ struct _cef_v8stack_frame_t* CEF_CALLBACK v8stack_trace_get_frame(
CefV8StackTraceCppToC::CefV8StackTraceCppToC(CefV8StackTrace* cls)
: CefCppToC<CefV8StackTraceCppToC, CefV8StackTrace, cef_v8stack_trace_t>(
cls) {
struct_.struct_.is_valid = v8stack_trace_is_valid;
struct_.struct_.get_frame_count = v8stack_trace_get_frame_count;
struct_.struct_.get_frame = v8stack_trace_get_frame;
}

15
cef1/libcef_dll/cpptoc/v8value_cpptoc.cc
View File

@ -167,6 +167,20 @@ CEF_EXPORT cef_v8value_t* cef_v8value_create_function(const cef_string_t* name,
// MEMBER FUNCTIONS - Body may be edited by hand.
int CEF_CALLBACK v8value_is_valid(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)->IsValid();
// Return type: bool
return _retval;
}
int CEF_CALLBACK v8value_is_undefined(struct _cef_v8value_t* self) {
// AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
@ -903,6 +917,7 @@ struct _cef_v8value_t* CEF_CALLBACK v8value_execute_function_with_context(
CefV8ValueCppToC::CefV8ValueCppToC(CefV8Value* cls)
: CefCppToC<CefV8ValueCppToC, CefV8Value, cef_v8value_t>(cls) {
struct_.struct_.is_valid = v8value_is_valid;
struct_.struct_.is_undefined = v8value_is_undefined;
struct_.struct_.is_null = v8value_is_null;
struct_.struct_.is_bool = v8value_is_bool;

13
cef1/libcef_dll/ctocpp/v8context_ctocpp.cc
View File

@ -52,6 +52,19 @@ bool CefV8Context::InContext() {
// VIRTUAL METHODS - Body may be edited by hand.
bool CefV8ContextCToCpp::IsValid() {
if (CEF_MEMBER_MISSING(struct_, is_valid))
return false;
// AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
// Execute
int _retval = struct_->is_valid(struct_);
// Return type: bool
return _retval?true:false;
}
CefRefPtr<CefBrowser> CefV8ContextCToCpp::GetBrowser() {
if (CEF_MEMBER_MISSING(struct_, get_browser))
return NULL;

1
cef1/libcef_dll/ctocpp/v8context_ctocpp.h
View File

@ -32,6 +32,7 @@ class CefV8ContextCToCpp
virtual ~CefV8ContextCToCpp() {}
// CefV8Context methods
virtual bool IsValid() OVERRIDE;
virtual CefRefPtr<CefBrowser> GetBrowser() OVERRIDE;
virtual CefRefPtr<CefFrame> GetFrame() OVERRIDE;
virtual CefRefPtr<CefV8Value> GetGlobal() OVERRIDE;

13
cef1/libcef_dll/ctocpp/v8stack_frame_ctocpp.cc
View File

@ -15,6 +15,19 @@
// VIRTUAL METHODS - Body may be edited by hand.
bool CefV8StackFrameCToCpp::IsValid() {
if (CEF_MEMBER_MISSING(struct_, is_valid))
return false;
// AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
// Execute
int _retval = struct_->is_valid(struct_);
// Return type: bool
return _retval?true:false;
}
CefString CefV8StackFrameCToCpp::GetScriptName() {
if (CEF_MEMBER_MISSING(struct_, get_script_name))
return CefString();

1
cef1/libcef_dll/ctocpp/v8stack_frame_ctocpp.h
View File

@ -34,6 +34,7 @@ class CefV8StackFrameCToCpp
virtual ~CefV8StackFrameCToCpp() {}
// CefV8StackFrame methods
virtual bool IsValid() OVERRIDE;
virtual CefString GetScriptName() OVERRIDE;
virtual CefString GetScriptNameOrSourceURL() OVERRIDE;
virtual CefString GetFunctionName() OVERRIDE;

13
cef1/libcef_dll/ctocpp/v8stack_trace_ctocpp.cc
View File

@ -30,6 +30,19 @@ CefRefPtr<CefV8StackTrace> CefV8StackTrace::GetCurrent(int frame_limit) {
// VIRTUAL METHODS - Body may be edited by hand.
bool CefV8StackTraceCToCpp::IsValid() {
if (CEF_MEMBER_MISSING(struct_, is_valid))
return false;
// AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
// Execute
int _retval = struct_->is_valid(struct_);
// Return type: bool
return _retval?true:false;
}
int CefV8StackTraceCToCpp::GetFrameCount() {
if (CEF_MEMBER_MISSING(struct_, get_frame_count))
return 0;

1
cef1/libcef_dll/ctocpp/v8stack_trace_ctocpp.h
View File

@ -34,6 +34,7 @@ class CefV8StackTraceCToCpp
virtual ~CefV8StackTraceCToCpp() {}
// CefV8StackTrace methods
virtual bool IsValid() OVERRIDE;
virtual int GetFrameCount() OVERRIDE;
virtual CefRefPtr<CefV8StackFrame> GetFrame(int index) OVERRIDE;
};

13
cef1/libcef_dll/ctocpp/v8value_ctocpp.cc
View File

@ -159,6 +159,19 @@ CefRefPtr<CefV8Value> CefV8Value::CreateFunction(const CefString& name,
// VIRTUAL METHODS - Body may be edited by hand.
bool CefV8ValueCToCpp::IsValid() {
if (CEF_MEMBER_MISSING(struct_, is_valid))
return false;
// AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
// Execute
int _retval = struct_->is_valid(struct_);
// Return type: bool
return _retval?true:false;
}
bool CefV8ValueCToCpp::IsUndefined() {
if (CEF_MEMBER_MISSING(struct_, is_undefined))
return false;

1
cef1/libcef_dll/ctocpp/v8value_ctocpp.h
View File

@ -33,6 +33,7 @@ class CefV8ValueCToCpp
virtual ~CefV8ValueCToCpp() {}
// CefV8Value methods
virtual bool IsValid() OVERRIDE;
virtual bool IsUndefined() OVERRIDE;
virtual bool IsNull() OVERRIDE;
virtual bool IsBool() OVERRIDE;

2
cef1/tests/cefclient/cefclient.cpp
View File

@ -259,6 +259,8 @@ void AppGetSettings(CefSettings& settings, CefRefPtr<CefApp>& app) {
g_command_line->HasSwitch(cefclient::kPackLoadingDisabled);
settings.uncaught_exception_stack_size = GetIntValue(
g_command_line->GetSwitchValue(cefclient::kUncaughtExceptionStackSize));
settings.context_safety_implementation = GetIntValue(
g_command_line->GetSwitchValue(cefclient::kContextSafetyImplementation));
// Retrieve command-line proxy configuration, if any.
bool has_proxy = false;

1
cef1/tests/cefclient/cefclient_switches.cpp
View File

@ -36,6 +36,7 @@ const char kResourcesDirPath[] = "resources-dir-path";
const char kLocalesDirPath[] = "locales-dir-path";
const char kPackLoadingDisabled[] = "pack-loading-disabled";
const char kUncaughtExceptionStackSize[] = "uncaught-exception-stack-size";
const char kContextSafetyImplementation[] = "context-safety-implementation";
// CefBrowserSettings attributes.
const char kDragDropDisabled[] = "drag-drop-disabled";

1
cef1/tests/cefclient/cefclient_switches.h
View File

@ -38,6 +38,7 @@ extern const char kResourcesDirPath[];
extern const char kLocalesDirPath[];
extern const char kPackLoadingDisabled[];
extern const char kUncaughtExceptionStackSize[];
extern const char kContextSafetyImplementation[];
// CefBrowserSettings attributes.
extern const char kDragDropDisabled[];

6
cef1/tests/cefclient/performance_test.cpp
View File

@ -13,7 +13,13 @@
namespace performance_test {
// Use more interations for a Release build.
#ifdef NDEBUG
const size_t kDefaultIterations = 100000;
#else
const size_t kDefaultIterations = 10000;
#endif
const char kTestUrl[] = "http://tests/performance";
namespace {

19
cef1/tests/unittests/test_suite.cc
View File

@ -3,6 +3,9 @@
// can be found in the LICENSE file.
#include "tests/unittests/test_suite.h"
#include <cstdlib>
#include "tests/cefclient/cefclient_switches.h"
#include "base/command_line.h"
#include "base/logging.h"
@ -16,6 +19,18 @@
#include "base/test/test_timeouts.h"
#endif
namespace {
// Return the int representation of the specified string.
int GetIntValue(const std::string& str) {
if (str.empty())
return 0;
return atoi(str.c_str());
}
} // namespace
CommandLine* CefTestSuite::commandline_ = NULL;
CefTestSuite::CefTestSuite(int argc, char** argv)
@ -127,6 +142,10 @@ void CefTestSuite::GetSettings(CefSettings& settings) {
// Necessary for V8Test.OnUncaughtException tests.
settings.uncaught_exception_stack_size = 10;
settings.context_safety_implementation = GetIntValue(
commandline_->GetSwitchValueASCII(
cefclient::kContextSafetyImplementation));
}
// static

63
cef1/tests/unittests/v8_unittest.cc
View File

@ -18,12 +18,13 @@
namespace {
// Unique values for V8 tests.
const char* kV8TestUrl = "http://tests/V8Test.Test";
const char* kV8BindingTestUrl = "http://tests/V8Test.BindingTest";
const char* kV8ContextParentTestUrl = "http://tests/V8Test.ContextParentTest";
const char* kV8ContextChildTestUrl = "http://tests/V8Test.ContextChildTest";
const char* kV8OnUncaughtExceptionTestUrl =
const char kV8TestUrl[] = "http://tests/V8Test.Test";
const char kV8BindingTestUrl[] = "http://tests/V8Test.BindingTest";
const char kV8ContextParentTestUrl[] = "http://tests/V8Test.ContextParentTest";
const char kV8ContextChildTestUrl[] = "http://tests/V8Test.ContextChildTest";
const char kV8OnUncaughtExceptionTestUrl[] =
"http://tests/V8Test.OnUncaughtException";
const char kV8NavTestUrl[] = "http://tests/V8Test.NavTest";
enum V8TestMode {
V8TEST_NULL_CREATE = 0,
@ -57,6 +58,7 @@ enum V8TestMode {
V8TEST_CONTEXT_EVAL,
V8TEST_CONTEXT_EVAL_EXCEPTION,
V8TEST_CONTEXT_ENTERED,
V8TEST_CONTEXT_INVALID,
V8TEST_BINDING,
V8TEST_STACK_TRACE,
V8TEST_ON_UNCAUGHT_EXCEPTION,
@ -73,11 +75,14 @@ class V8TestHandler : public TestHandler {
}
virtual void RunTest() OVERRIDE {
// Nested script tag forces creation of the V8 context.
if (test_mode_ == V8TEST_CONTEXT_ENTERED) {
AddResource(kV8ContextParentTestUrl, "<html><body><iframe src=\"" +
AddResource(kV8ContextParentTestUrl, "<html><body>"
"<script>var i = 0;</script><iframe src=\"" +
std::string(kV8ContextChildTestUrl) + "\" id=\"f\"></iframe></body>"
"</html>", "text/html");
AddResource(kV8ContextChildTestUrl, "<html><body>CHILD</body></html>",
AddResource(kV8ContextChildTestUrl, "<html><body>"
"<script>var i = 0;</script>CHILD</body></html>",
"text/html");
CreateBrowser(kV8ContextParentTestUrl);
} else if (test_mode_ == V8TEST_ON_UNCAUGHT_EXCEPTION ||
@ -92,8 +97,14 @@ class V8TestHandler : public TestHandler {
"text/html");
CreateBrowser(kV8OnUncaughtExceptionTestUrl);
} else {
if (test_mode_ == V8TEST_CONTEXT_INVALID) {
AddResource(kV8NavTestUrl, "<html><body>"
"<script>var i = 0;</script>TEST</body></html>", "text/html");
}
EXPECT_TRUE(test_url_ != NULL);
AddResource(test_url_, "<html><body>TEST</body></html>", "text/html");
AddResource(test_url_, "<html><body>"
"<script>var i = 0;</script>TEST</body></html>", "text/html");
CreateBrowser(test_url_);
}
}
@ -194,6 +205,10 @@ class V8TestHandler : public TestHandler {
case V8TEST_CONTEXT_ENTERED:
RunContextEnteredTest();
break;
case V8TEST_CONTEXT_INVALID:
// The test is triggered when the context is released.
GetBrowser()->GetMainFrame()->LoadURL(kV8NavTestUrl);
break;
case V8TEST_BINDING:
RunBindingTest();
break;
@ -1545,14 +1560,14 @@ class V8TestHandler : public TestHandler {
}
void RunOnUncaughtExceptionTest() {
on_uncaught_exception_context_ =
test_context_ =
GetBrowser()->GetMainFrame()->GetV8Context();
GetBrowser()->GetMainFrame()->ExecuteJavaScript("test()",
CefString(), 0);
}
void RunOnUncaughtExceptionDevToolsTest() {
on_uncaught_exception_context_ =
test_context_ =
GetBrowser()->GetMainFrame()->GetV8Context();
GetBrowser()->ShowDevTools();
}
@ -1566,7 +1581,7 @@ class V8TestHandler : public TestHandler {
if (test_mode_ == V8TEST_ON_UNCAUGHT_EXCEPTION ||
test_mode_ == V8TEST_ON_UNCAUGHT_EXCEPTION_DEV_TOOLS) {
EXPECT_TRUE(on_uncaught_exception_context_->IsSame(context));
EXPECT_TRUE(test_context_->IsSame(context));
EXPECT_STREQ("Uncaught ReferenceError: asd is not defined",
exception->GetMessage().ToString().c_str());
std::ostringstream stackFormatted;
@ -1587,7 +1602,8 @@ class V8TestHandler : public TestHandler {
virtual void OnLoadEnd(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
int httpStatusCode) OVERRIDE {
if (frame->IsMain())
std::string url = frame->GetURL();
if (frame->IsMain() && url != kV8NavTestUrl)
RunTest(test_mode_);
if (test_mode_ == V8TEST_ON_UNCAUGHT_EXCEPTION_DEV_TOOLS &&
browser->IsPopup()) {
@ -1654,8 +1670,25 @@ class V8TestHandler : public TestHandler {
}
}
virtual void OnContextReleased(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
CefRefPtr<CefV8Context> context) OVERRIDE {
std::string url = frame->GetURL();
if (test_mode_ == V8TEST_CONTEXT_INVALID && url == test_url_) {
test_context_ = context;
test_object_ = CefV8Value::CreateArray(10);
CefPostTask(TID_UI,
NewCefRunnableMethod(this, &V8TestHandler::DestroyTest));
}
}
virtual void DestroyTest() OVERRIDE {
if (test_mode_ == V8TEST_ON_UNCAUGHT_EXCEPTION ||
if (test_mode_ == V8TEST_CONTEXT_INVALID) {
// Verify that objects related to a particular context are not valid after
// OnContextReleased is called for that context.
EXPECT_FALSE(test_context_->IsValid());
EXPECT_FALSE(test_object_->IsValid());
} else if (test_mode_ == V8TEST_ON_UNCAUGHT_EXCEPTION ||
test_mode_ == V8TEST_ON_UNCAUGHT_EXCEPTION_DEV_TOOLS) {
EXPECT_TRUE(got_on_uncaught_exception_);
}
@ -1674,7 +1707,8 @@ class V8TestHandler : public TestHandler {
V8TestMode test_mode_;
const char* test_url_;
CefRefPtr<CefV8Context> on_uncaught_exception_context_;
CefRefPtr<CefV8Context> test_context_;
CefRefPtr<CefV8Value> test_object_;
TrackCallback got_destroy_test_;
TrackCallback got_on_uncaught_exception_;
@ -1728,6 +1762,7 @@ V8_TEST(FunctionHandlerWithContext, V8TEST_FUNCTION_HANDLER_WITH_CONTEXT);
V8_TEST(ContextEval, V8TEST_CONTEXT_EVAL);
V8_TEST(ContextEvalException, V8TEST_CONTEXT_EVAL_EXCEPTION);
V8_TEST_EX(ContextEntered, V8TEST_CONTEXT_ENTERED, NULL);
V8_TEST(ContextInvalid, V8TEST_CONTEXT_INVALID);
V8_TEST_EX(Binding, V8TEST_BINDING, kV8BindingTestUrl);
V8_TEST(StackTrace, V8TEST_STACK_TRACE);
V8_TEST(OnUncaughtException, V8TEST_ON_UNCAUGHT_EXCEPTION);