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

git-svn-id: https://chromiumembedded.googlecode.com/svn/trunk@881 5089003a-bbd8-11dd-ad1f-f1f9622dbc98

include/capi/cef_v8_capi.h

@@ -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.
   ///
@@ -316,6 +322,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.
   ///
@@ -710,6 +722,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.
   ///
@@ -740,6 +758,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.
   ///

include/cef_v8.h

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

include/internal/cef_types.h

@@ -252,6 +252,25 @@ typedef struct _cef_settings_t {
   // Chrome browser window.
   ///
   int remote_debugging_port;
+
+  ///
+  // 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;
 
 ///

include/internal/cef_types_wrappers.h

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

libcef/browser/content_browser_client.cc

@@ -277,6 +277,7 @@ void CefContentBrowserClient::AppendExtraCommandLineSwitches(
     // Propagate the following switches to the renderer command line (along with
     // any associated values) if present in the browser command line.
     static const char* const kSwitchNames[] = {
+      switches::kContextSafetyImplementation,
       switches::kProductVersion,
     };
     command_line->CopySwitchesFrom(browser_cmd, kSwitchNames,

libcef/common/cef_switches.cc

@@ -30,4 +30,7 @@ const char kLocalesDirPath[]          = "locales-dir-path";
 // Path to locales directory.
 const char kPackLoadingDisabled[]     = "pack-loading-disabled";
 
+// Context safety implementation type.
+const char kContextSafetyImplementation[] = "context-safety-implementation";
+
 }  // namespace switches

libcef/common/cef_switches.h

@@ -22,6 +22,7 @@ extern const char kLogSeverity_Disable[];
 extern const char kResourcesDirPath[];
 extern const char kLocalesDirPath[];
 extern const char kPackLoadingDisabled[];
+extern const char kContextSafetyImplementation[];
 
 }  // namespace switches
 

libcef/common/main_delegate.cc

@@ -252,6 +252,11 @@ bool CefMainDelegate::BasicStartupComplete(int* exit_code) {
           base::IntToString(settings.remote_debugging_port));
     }
 
+    if (settings.context_safety_implementation != 0) {
+      command_line->AppendSwitchASCII(switches::kContextSafetyImplementation,
+          base::IntToString(settings.context_safety_implementation));
+    }
+
     // TODO(cef): Figure out how to support the sandbox.
     if (!command_line->HasSwitch(switches::kNoSandbox))
       command_line->AppendSwitch(switches::kNoSandbox);

libcef/renderer/content_renderer_client.cc

@@ -227,12 +227,16 @@ void CefContentRendererClient::WillReleaseScriptContext(
 
   CefRefPtr<CefFrameImpl> framePtr = browserPtr->GetWebFrameImpl(frame);
 
-  v8::HandleScope handle_scope;
+  {
-  v8::Context::Scope scope(context);
+    v8::HandleScope handle_scope;
-  WebCore::V8RecursionScope recursion_scope(
+    v8::Context::Scope scope(context);
-      WebCore::getScriptExecutionContext());
+    WebCore::V8RecursionScope recursion_scope(
+        WebCore::getScriptExecutionContext());
 
-  CefRefPtr<CefV8Context> contextPtr(new CefV8ContextImpl(context));
+    CefRefPtr<CefV8Context> contextPtr(new CefV8ContextImpl(context));
 
-  handler->OnContextReleased(browserPtr.get(), framePtr.get(), contextPtr);
+    handler->OnContextReleased(browserPtr.get(), framePtr.get(), contextPtr);
+  }
+
+  CefV8ReleaseContext(context);
 }

libcef/renderer/v8_impl.cc

@@ -2,8 +2,10 @@
 // reserved. Use of this source code is governed by a BSD-style license that
 // can be found in the LICENSE file.
 
+#include <map>
 #include <string>
 
+#include "base/command_line.h"
 #include "base/compiler_specific.h"
 
 #include "third_party/WebKit/Source/WebCore/config.h"
@@ -18,12 +20,14 @@ MSVC_POP_WARNING();
 
 #include "libcef/renderer/v8_impl.h"
 
+#include "libcef/common/cef_switches.h"
 #include "libcef/common/tracker.h"
 #include "libcef/renderer/browser_impl.h"
 #include "libcef/renderer/thread_util.h"
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
+#include "base/string_number_conversions.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebKit.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebScriptController.h"
@@ -31,10 +35,116 @@ 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()
+      : context_safety_impl_(IMPL_HASH) {
+    const CommandLine& command_line = *CommandLine::ForCurrentProcess();
+    if (command_line.HasSwitch(switches::kContextSafetyImplementation)) {
+      std::string value = command_line.GetSwitchValueASCII(
+          switches::kContextSafetyImplementation);
+      int mode;
+      if (base::StringToInt(value, &mode)) {
+        if (mode < 0)
+          context_safety_impl_ = IMPL_DISABLED;
+        else if (mode == 1)
+          context_safety_impl_ = IMPL_VALUE;
+      }
+    }
+  }
+
+  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:
@@ -138,6 +248,7 @@ void TrackDestructor(v8::Persistent<v8::Value> object, void* parameter) {
   object.Clear();
 }
 
+
 // Convert a CefString to a V8::String.
 v8::Handle<v8::String> GetV8String(const CefString& str) {
 #if defined(CEF_STRING_TYPE_UTF16)
@@ -385,6 +496,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) {
@@ -404,6 +519,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
@@ -437,26 +559,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
@@ -467,9 +598,15 @@ CefV8ContextImpl::~CefV8ContextImpl() {
   DLOG_ASSERT(0 == enter_count_);
 }
 
+bool CefV8ContextImpl::IsValid() {
+  CEF_REQUIRE_RT_RETURN(false);
+  return handle_->IsValid();
+}
+
 CefRefPtr<CefBrowser> CefV8ContextImpl::GetBrowser() {
   CefRefPtr<CefBrowser> browser;
   CEF_REQUIRE_RT_RETURN(browser);
+  CEF_V8_REQUIRE_VALID_RETURN(browser);
 
   WebKit::WebFrame* webframe = GetWebFrame();
   if (webframe)
@@ -481,6 +618,7 @@ CefRefPtr<CefBrowser> CefV8ContextImpl::GetBrowser() {
 CefRefPtr<CefFrame> CefV8ContextImpl::GetFrame() {
   CefRefPtr<CefFrame> frame;
   CEF_REQUIRE_RT_RETURN(frame);
+  CEF_V8_REQUIRE_VALID_RETURN(frame);
 
   WebKit::WebFrame* webframe = GetWebFrame();
   if (webframe) {
@@ -494,6 +632,7 @@ CefRefPtr<CefFrame> CefV8ContextImpl::GetFrame() {
 
 CefRefPtr<CefV8Value> CefV8ContextImpl::GetGlobal() {
   CEF_REQUIRE_RT_RETURN(NULL);
+  CEF_V8_REQUIRE_VALID_RETURN(NULL);
 
   v8::HandleScope handle_scope;
   v8::Context::Scope context_scope(GetHandle());
@@ -502,6 +641,8 @@ CefRefPtr<CefV8Value> CefV8ContextImpl::GetGlobal() {
 
 bool CefV8ContextImpl::Enter() {
   CEF_REQUIRE_RT_RETURN(false);
+  CEF_V8_REQUIRE_VALID_RETURN(false);
+
   WebCore::V8PerIsolateData::current()->incrementRecursionLevel();
   GetHandle()->Enter();
 #ifndef NDEBUG
@@ -512,6 +653,8 @@ bool CefV8ContextImpl::Enter() {
 
 bool CefV8ContextImpl::Exit() {
   CEF_REQUIRE_RT_RETURN(false);
+  CEF_V8_REQUIRE_VALID_RETURN(false);
+
   DLOG_ASSERT(enter_count_ > 0);
   GetHandle()->Exit();
   WebCore::V8PerIsolateData::current()->decrementRecursionLevel();
@@ -523,6 +666,7 @@ bool CefV8ContextImpl::Exit() {
 
 bool CefV8ContextImpl::IsSame(CefRefPtr<CefV8Context> that) {
   CEF_REQUIRE_RT_RETURN(false);
+  CEF_V8_REQUIRE_VALID_RETURN(false);
 
   v8::HandleScope handle_scope;
 
@@ -540,6 +684,7 @@ bool CefV8ContextImpl::Eval(const CefString& code,
                             CefRefPtr<CefV8Value>& retval,
                             CefRefPtr<CefV8Exception>& exception) {
   CEF_REQUIRE_RT_RETURN(false);
+  CEF_V8_REQUIRE_VALID_RETURN(false);
 
   if (code.empty()) {
     NOTREACHED() << "invalid input parameter";
@@ -774,71 +919,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_RT_RETURN(false);
+  return handle_->IsValid();
+}
+
 bool CefV8ValueImpl::IsUndefined() {
   CEF_REQUIRE_RT_RETURN(false);
+  CEF_V8_REQUIRE_VALID_RETURN(false);
   return GetHandle()->IsUndefined();
 }
 
 bool CefV8ValueImpl::IsNull() {
   CEF_REQUIRE_RT_RETURN(false);
+  CEF_V8_REQUIRE_VALID_RETURN(false);
   return GetHandle()->IsNull();
 }
 
 bool CefV8ValueImpl::IsBool() {
   CEF_REQUIRE_RT_RETURN(false);
+  CEF_V8_REQUIRE_VALID_RETURN(false);
   return (GetHandle()->IsBoolean() || GetHandle()->IsTrue()
              || GetHandle()->IsFalse());
 }
 
 bool CefV8ValueImpl::IsInt() {
   CEF_REQUIRE_RT_RETURN(false);
+  CEF_V8_REQUIRE_VALID_RETURN(false);
   return GetHandle()->IsInt32();
 }
 
 bool CefV8ValueImpl::IsUInt() {
   CEF_REQUIRE_RT_RETURN(false);
+  CEF_V8_REQUIRE_VALID_RETURN(false);
   return GetHandle()->IsUint32();
 }
 
 bool CefV8ValueImpl::IsDouble() {
   CEF_REQUIRE_RT_RETURN(false);
+  CEF_V8_REQUIRE_VALID_RETURN(false);
   return GetHandle()->IsNumber();
 }
 
 bool CefV8ValueImpl::IsDate() {
   CEF_REQUIRE_RT_RETURN(false);
+  CEF_V8_REQUIRE_VALID_RETURN(false);
   return GetHandle()->IsDate();
 }
 
 bool CefV8ValueImpl::IsString() {
   CEF_REQUIRE_RT_RETURN(false);
+  CEF_V8_REQUIRE_VALID_RETURN(false);
   return GetHandle()->IsString();
 }
 
 bool CefV8ValueImpl::IsObject() {
   CEF_REQUIRE_RT_RETURN(false);
+  CEF_V8_REQUIRE_VALID_RETURN(false);
   return GetHandle()->IsObject();
 }
 
 bool CefV8ValueImpl::IsArray() {
   CEF_REQUIRE_RT_RETURN(false);
+  CEF_V8_REQUIRE_VALID_RETURN(false);
   return GetHandle()->IsArray();
 }
 
 bool CefV8ValueImpl::IsFunction() {
   CEF_REQUIRE_RT_RETURN(false);
+  CEF_V8_REQUIRE_VALID_RETURN(false);
   return GetHandle()->IsFunction();
 }
 
 bool CefV8ValueImpl::IsSame(CefRefPtr<CefV8Value> that) {
   CEF_REQUIRE_RT_RETURN(false);
+  CEF_V8_REQUIRE_VALID_RETURN(false);
 
   v8::HandleScope handle_scope;
 
@@ -854,6 +1017,7 @@ bool CefV8ValueImpl::IsSame(CefRefPtr<CefV8Value> that) {
 
 bool CefV8ValueImpl::GetBoolValue() {
   CEF_REQUIRE_RT_RETURN(false);
+  CEF_V8_REQUIRE_VALID_RETURN(false);
   if (GetHandle()->IsTrue()) {
     return true;
   } else if (GetHandle()->IsFalse()) {
@@ -867,6 +1031,7 @@ bool CefV8ValueImpl::GetBoolValue() {
 
 int32 CefV8ValueImpl::GetIntValue() {
   CEF_REQUIRE_RT_RETURN(0);
+  CEF_V8_REQUIRE_VALID_RETURN(0);
   v8::HandleScope handle_scope;
   v8::Local<v8::Int32> val = GetHandle()->ToInt32();
   return val->Value();
@@ -874,6 +1039,7 @@ int32 CefV8ValueImpl::GetIntValue() {
 
 uint32 CefV8ValueImpl::GetUIntValue() {
   CEF_REQUIRE_RT_RETURN(0);
+  CEF_V8_REQUIRE_VALID_RETURN(0);
   v8::HandleScope handle_scope;
   v8::Local<v8::Uint32> val = GetHandle()->ToUint32();
   return val->Value();
@@ -881,6 +1047,7 @@ uint32 CefV8ValueImpl::GetUIntValue() {
 
 double CefV8ValueImpl::GetDoubleValue() {
   CEF_REQUIRE_RT_RETURN(0.);
+  CEF_V8_REQUIRE_VALID_RETURN(0.);
   v8::HandleScope handle_scope;
   v8::Local<v8::Number> val = GetHandle()->ToNumber();
   return val->Value();
@@ -888,6 +1055,7 @@ double CefV8ValueImpl::GetDoubleValue() {
 
 CefTime CefV8ValueImpl::GetDateValue() {
   CEF_REQUIRE_RT_RETURN(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.
@@ -897,6 +1065,7 @@ CefTime CefV8ValueImpl::GetDateValue() {
 CefString CefV8ValueImpl::GetStringValue() {
   CefString rv;
   CEF_REQUIRE_RT_RETURN(rv);
+  CEF_V8_REQUIRE_VALID_RETURN(rv);
   v8::HandleScope handle_scope;
   GetCefString(GetHandle()->ToString(), rv);
   return rv;
@@ -1320,6 +1489,7 @@ bool CefV8ValueImpl::HasCaught(v8::TryCatch& try_catch) {
 CefRefPtr<CefV8StackTrace> CefV8StackTrace::GetCurrent(int frame_limit) {
   CEF_REQUIRE_RT_RETURN(NULL);
 
+  v8::HandleScope handle_scope;
   v8::Handle<v8::StackTrace> stackTrace =
         v8::StackTrace::CurrentStackTrace(
             frame_limit, v8::StackTrace::kDetailed);
@@ -1332,20 +1502,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_RT_RETURN(false);
+  return handle_->IsValid();
+}
+
 int CefV8StackTraceImpl::GetFrameCount() {
   CEF_REQUIRE_RT_RETURN(0);
+  CEF_V8_REQUIRE_VALID_RETURN(0);
   v8::HandleScope handle_scope;
   return GetHandle()->GetFrameCount();
 }
 
 CefRefPtr<CefV8StackFrame> CefV8StackTraceImpl::GetFrame(int index) {
   CEF_REQUIRE_RT_RETURN(NULL);
+  CEF_V8_REQUIRE_VALID_RETURN(NULL);
   v8::HandleScope handle_scope;
   v8::Handle<v8::StackFrame> stackFrame = GetHandle()->GetFrame(index);
   if (stackFrame.IsEmpty())
@@ -1357,15 +1534,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_RT_RETURN(false);
+  return handle_->IsValid();
+}
+
 CefString CefV8StackFrameImpl::GetScriptName() {
   CefString rv;
   CEF_REQUIRE_RT_RETURN(rv);
+  CEF_V8_REQUIRE_VALID_RETURN(rv);
   v8::HandleScope handle_scope;
   GetCefString(v8::Handle<v8::String>::Cast(GetHandle()->GetScriptName()), rv);
   return rv;
@@ -1374,6 +1557,7 @@ CefString CefV8StackFrameImpl::GetScriptName() {
 CefString CefV8StackFrameImpl::GetScriptNameOrSourceURL() {
   CefString rv;
   CEF_REQUIRE_RT_RETURN(rv);
+  CEF_V8_REQUIRE_VALID_RETURN(rv);
   v8::HandleScope handle_scope;
   GetCefString(
       v8::Handle<v8::String>::Cast(GetHandle()->GetScriptNameOrSourceURL()),
@@ -1384,6 +1568,7 @@ CefString CefV8StackFrameImpl::GetScriptNameOrSourceURL() {
 CefString CefV8StackFrameImpl::GetFunctionName() {
   CefString rv;
   CEF_REQUIRE_RT_RETURN(rv);
+  CEF_V8_REQUIRE_VALID_RETURN(rv);
   v8::HandleScope handle_scope;
   GetCefString(
       v8::Handle<v8::String>::Cast(GetHandle()->GetFunctionName()), rv);
@@ -1392,24 +1577,28 @@ CefString CefV8StackFrameImpl::GetFunctionName() {
 
 int CefV8StackFrameImpl::GetLineNumber() {
   CEF_REQUIRE_RT_RETURN(0);
+  CEF_V8_REQUIRE_VALID_RETURN(0);
   v8::HandleScope handle_scope;
   return GetHandle()->GetLineNumber();
 }
 
 int CefV8StackFrameImpl::GetColumn() {
   CEF_REQUIRE_RT_RETURN(0);
+  CEF_V8_REQUIRE_VALID_RETURN(0);
   v8::HandleScope handle_scope;
   return GetHandle()->GetColumn();
 }
 
 bool CefV8StackFrameImpl::IsEval() {
   CEF_REQUIRE_RT_RETURN(false);
+  CEF_V8_REQUIRE_VALID_RETURN(false);
   v8::HandleScope handle_scope;
   return GetHandle()->IsEval();
 }
 
 bool CefV8StackFrameImpl::IsConstructor() {
   CEF_REQUIRE_RT_RETURN(false);
+  CEF_V8_REQUIRE_VALID_RETURN(false);
   v8::HandleScope handle_scope;
   return GetHandle()->IsConstructor();
 }

libcef/renderer/v8_impl.h

@@ -20,25 +20,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,
+                                      CefDeleteOnRenderThread> {
+ 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 render thread.
 template <typename v8class>
-class CefV8Handle :
+class CefV8Handle : public CefV8HandleBase {
-    public base::RefCountedThreadSafe<CefV8Handle<v8class>,
-                                      CefDeleteOnRenderThread> {
  public:
   typedef v8::Handle<v8class> handleType;
   typedef v8::Persistent<v8class> persistentType;
 
-  CefV8Handle(handleType v)
+  CefV8Handle(v8::Handle<v8::Context> context, handleType v)
-      : handle_(persistentType::New(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_;
@@ -58,6 +98,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;
@@ -91,6 +132,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;
@@ -148,19 +190,22 @@ class CefV8ValueImpl : public CefV8Value {
   // Test for and record any exception.
   bool HasCaught(v8::TryCatch& try_catch);
 
-  class Handle :
+  class Handle : public CefV8HandleBase {
-      public base::RefCountedThreadSafe<Handle, CefDeleteOnRenderThread> {
    public:
     typedef v8::Handle<v8::Value> handleType;
     typedef v8::Persistent<v8::Value> persistentType;
 
-    Handle(handleType v, CefTrackNode* tracker)
+    Handle(v8::Handle<v8::Context> context, handleType v, CefTrackNode* tracker)
-        : handle_(persistentType::New(v)),
+        : CefV8HandleBase(context),
+          handle_(persistentType::New(v)),
           tracker_(tracker) {
     }
-    ~Handle();
+    virtual ~Handle();
 
-    handleType GetHandle() { return handle_; }
+    handleType GetHandle() {
+      DCHECK(IsValid());
+      return handle_;
+    }
 
    private:
     persistentType handle_;
@@ -185,6 +230,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;
 
@@ -203,6 +249,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;

libcef_dll/cpptoc/v8context_cpptoc.cc

@@ -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;

libcef_dll/cpptoc/v8stack_frame_cpptoc.cc

@@ -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;

libcef_dll/cpptoc/v8stack_trace_cpptoc.cc

@@ -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;
 }

libcef_dll/cpptoc/v8value_cpptoc.cc

@@ -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;

libcef_dll/ctocpp/v8context_ctocpp.cc

@@ -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;

libcef_dll/ctocpp/v8context_ctocpp.h

@@ -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;

libcef_dll/ctocpp/v8stack_frame_ctocpp.cc

@@ -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();

libcef_dll/ctocpp/v8stack_frame_ctocpp.h

@@ -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;

libcef_dll/ctocpp/v8stack_trace_ctocpp.cc

@@ -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;

libcef_dll/ctocpp/v8stack_trace_ctocpp.h

@@ -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;
 };

libcef_dll/ctocpp/v8value_ctocpp.cc

@@ -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;

libcef_dll/ctocpp/v8value_ctocpp.h

@@ -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;

tests/cefclient/performance_test.cpp

@@ -13,7 +13,12 @@
 
 namespace performance_test {
 
+// Use more interations for a Release build.
+#ifdef NDEBUG
+const size_t kDefaultIterations = 100000;
+#else
 const size_t kDefaultIterations = 10000;
+#endif
 
 namespace {
 

tests/unittests/v8_unittest.cc

@@ -20,12 +20,13 @@
 namespace {
 
 // Unique values for V8 tests.
-const char* kV8TestUrl = "http://tests/V8Test.Test";
+const char kV8TestUrl[] = "http://tests/V8Test.Test";
-const char* kV8BindingTestUrl = "http://tests/V8Test.BindingTest";
+const char kV8BindingTestUrl[] = "http://tests/V8Test.BindingTest";
-const char* kV8ContextParentTestUrl = "http://tests/V8Test.ContextParentTest";
+const char kV8ContextParentTestUrl[] = "http://tests/V8Test.ContextParentTest";
-const char* kV8ContextChildTestUrl = "http://tests/V8Test.ContextChildTest";
+const char kV8ContextChildTestUrl[] = "http://tests/V8Test.ContextChildTest";
-const char* kV8TestMsg = "V8Test.Test";
+const char kV8NavTestUrl[] = "http://tests/V8Test.NavTest";
-const char* kV8TestCmdArg = "v8-test";
+const char kV8TestMsg[] = "V8Test.Test";
+const char kV8TestCmdArg[] = "v8-test";
 
 enum V8TestMode {
   V8TEST_NONE = 0,
@@ -60,6 +61,7 @@ enum V8TestMode {
   V8TEST_CONTEXT_EVAL,
   V8TEST_CONTEXT_EVAL_EXCEPTION,
   V8TEST_CONTEXT_ENTERED,
+  V8TEST_CONTEXT_INVALID,
   V8TEST_BINDING,
   V8TEST_STACK_TRACE,
   V8TEST_EXTENSION,
@@ -194,6 +196,10 @@ class V8RendererTest : public ClientApp::RenderDelegate {
       case V8TEST_CONTEXT_ENTERED:
         RunContextEnteredTest();
         break;
+      case V8TEST_CONTEXT_INVALID:
+        // The test is triggered when the context is released.
+        browser_->GetMainFrame()->LoadURL(kV8NavTestUrl);
+        break;
       case V8TEST_BINDING:
         RunBindingTest();
         break;
@@ -1659,16 +1665,37 @@ class V8RendererTest : public ClientApp::RenderDelegate {
           V8_PROPERTY_ATTRIBUTE_NONE));
     }
 
-    if (test_mode_ > V8TEST_NONE) {
+    if (test_mode_ > V8TEST_NONE && url != kV8NavTestUrl) {
       // Run the test asynchronously.
       CefPostTask(TID_RENDERER,
                   NewCefRunnableMethod(this, &V8RendererTest::RunTest));
     }
   }
 
+  virtual void OnContextReleased(CefRefPtr<ClientApp> app,
+                                 CefRefPtr<CefBrowser> browser,
+                                 CefRefPtr<CefFrame> frame,
+                                 CefRefPtr<CefV8Context> context) OVERRIDE {
+    if (test_mode_ == V8TEST_CONTEXT_INVALID &&
+        frame->GetURL().ToString() != kV8NavTestUrl) {
+      test_context_ =
+          browser_->GetMainFrame()->GetV8Context();
+      test_object_ = CefV8Value::CreateArray(10);
+      CefPostTask(TID_RENDERER,
+          NewCefRunnableMethod(this, &V8RendererTest::DestroyTest));
+    }
+  }
+
  protected:
   // Return from the test.
   void DestroyTest() {
+    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());
+    }
+
     // Check if the test has failed.
     bool result = !TestFailed();
 
@@ -1693,6 +1720,9 @@ class V8RendererTest : public ClientApp::RenderDelegate {
   CefRefPtr<CefBrowser> browser_;
   V8TestMode test_mode_;
 
+  CefRefPtr<CefV8Context> test_context_;
+  CefRefPtr<CefV8Value> test_object_;
+
   // Used by startup tests to indicate success.
   TrackCallback startup_test_success_;
 
@@ -1816,6 +1846,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(Extension, V8TEST_EXTENSION);