[inspector] handle context destroyed after console.log

src/inspector/InjectedScript.cpp

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 108 matching lines @@
 
 InjectedScript::~InjectedScript() {}
 
 void InjectedScript::getProperties(
     ErrorString* errorString, v8::Local<v8::Object> object,
     const String16& groupName, bool ownProperties, bool accessorPropertiesOnly,
     bool generatePreview,
     std::unique_ptr<Array<PropertyDescriptor>>* properties,
     Maybe<protocol::Runtime::ExceptionDetails>* exceptionDetails) {
   v8::HandleScope handles(m_context->isolate());
+  v8::Local<v8::Context> context = m_context->context();
   V8FunctionCall function(m_context->inspector(), m_context->context(),
                           v8Value(), "getProperties");
   function.appendArgument(object);
   function.appendArgument(groupName);
   function.appendArgument(ownProperties);
   function.appendArgument(accessorPropertiesOnly);
   function.appendArgument(generatePreview);
 
   v8::TryCatch tryCatch(m_context->isolate());
   v8::Local<v8::Value> resultValue = function.callWithoutExceptionHandling();
   if (tryCatch.HasCaught()) {
     *exceptionDetails = createExceptionDetails(errorString, tryCatch, groupName,
                                                generatePreview);
     // FIXME: make properties optional
     *properties = Array<PropertyDescriptor>::create();
     return;
   }
 
   std::unique_ptr<protocol::Value> protocolValue =
-      toProtocolValue(m_context->context(), resultValue);
+      toProtocolValue(context, resultValue);
   if (hasInternalError(errorString, !protocolValue)) return;
   protocol::ErrorSupport errors(errorString);
   std::unique_ptr<Array<PropertyDescriptor>> result =
       Array<PropertyDescriptor>::parse(protocolValue.get(), &errors);
   if (!hasInternalError(errorString, errors.hasErrors()))
     *properties = std::move(result);
 }
 
 void InjectedScript::releaseObject(const String16& objectId) {
   std::unique_ptr<protocol::Value> parsedObjectId =
       protocol::parseJSON(objectId);
   if (!parsedObjectId) return;
   protocol::DictionaryValue* object =
       protocol::DictionaryValue::cast(parsedObjectId.get());
   if (!object) return;
   int boundId = 0;
   if (!object->getInteger("id", &boundId)) return;
   m_native->unbind(boundId);
 }
 
 std::unique_ptr<protocol::Runtime::RemoteObject> InjectedScript::wrapObject(
     ErrorString* errorString, v8::Local<v8::Value> value,
     const String16& groupName, bool forceValueType,
     bool generatePreview) const {
   v8::HandleScope handles(m_context->isolate());
   v8::Local<v8::Value> wrappedObject;
+  v8::Local<v8::Context> context = m_context->context();
   if (!wrapValue(errorString, value, groupName, forceValueType, generatePreview)
            .ToLocal(&wrappedObject))
     return nullptr;
   protocol::ErrorSupport errors;
   std::unique_ptr<protocol::Runtime::RemoteObject> remoteObject =
       protocol::Runtime::RemoteObject::parse(
-          toProtocolValue(m_context->context(), wrappedObject).get(), &errors);
+          toProtocolValue(context, wrappedObject).get(), &errors);
   if (!remoteObject) *errorString = "Object has too long reference chain";
   return remoteObject;
 }
 
 bool InjectedScript::wrapObjectProperty(ErrorString* errorString,
                                         v8::Local<v8::Object> object,
                                         v8::Local<v8::Name> key,
                                         const String16& groupName,
                                         bool forceValueType,
                                         bool generatePreview) const {
   v8::Local<v8::Value> property;
-  if (hasInternalError(
-          errorString,
-          !object->Get(m_context->context(), key).ToLocal(&property)))
+  v8::Local<v8::Context> context = m_context->context();
+  if (hasInternalError(errorString,
+                       !object->Get(context, key).ToLocal(&property)))
     return false;
   v8::Local<v8::Value> wrappedProperty;
   if (!wrapValue(errorString, property, groupName, forceValueType,
                  generatePreview)
            .ToLocal(&wrappedProperty))
     return false;
   v8::Maybe<bool> success =
-      createDataProperty(m_context->context(), object, key, wrappedProperty);
+      createDataProperty(context, object, key, wrappedProperty);
   if (hasInternalError(errorString, success.IsNothing() || !success.FromJust()))
     return false;
   return true;
 }
 
 bool InjectedScript::wrapPropertyInArray(ErrorString* errorString,
                                          v8::Local<v8::Array> array,
                                          v8::Local<v8::String> property,
                                          const String16& groupName,
                                          bool forceValueType,
@@ skipping 39 matching lines @@
   bool hadException = false;
   v8::Local<v8::Value> r = function.call(hadException);
   if (hasInternalError(errorString, hadException || r.IsEmpty()))
     return v8::MaybeLocal<v8::Value>();
   return r;
 }
 
 std::unique_ptr<protocol::Runtime::RemoteObject> InjectedScript::wrapTable(
     v8::Local<v8::Value> table, v8::Local<v8::Value> columns) const {
   v8::HandleScope handles(m_context->isolate());
-  V8FunctionCall function(m_context->inspector(), m_context->context(),
-                          v8Value(), "wrapTable");
+  v8::Local<v8::Context> context = m_context->context();
+  V8FunctionCall function(m_context->inspector(), context, v8Value(),
+                          "wrapTable");
   function.appendArgument(table);
   if (columns.IsEmpty())
     function.appendArgument(false);
   else
     function.appendArgument(columns);
   bool hadException = false;
   v8::Local<v8::Value> r = function.call(hadException);
   if (hadException) return nullptr;
   protocol::ErrorSupport errors;
   return protocol::Runtime::RemoteObject::parse(
-      toProtocolValue(m_context->context(), r).get(), &errors);
+      toProtocolValue(context, r).get(), &errors);
 }
 
 bool InjectedScript::findObject(ErrorString* errorString,
                                 const RemoteObjectId& objectId,
                                 v8::Local<v8::Value>* outObject) const {
   *outObject = m_native->objectForId(objectId.id());
   if (outObject->IsEmpty())
     *errorString = "Could not find object with given id";
   return !outObject->IsEmpty();
 }
@@ skipping 273 matching lines @@
 void InjectedScript::CallFrameScope::findInjectedScript(
     V8InspectorSessionImpl* session) {
   std::unique_ptr<RemoteCallFrameId> remoteId =
       RemoteCallFrameId::parse(m_errorString, m_remoteCallFrameId);
   if (!remoteId) return;
   m_frameOrdinal = static_cast<size_t>(remoteId->frameOrdinal());
   m_injectedScript = session->findInjectedScript(m_errorString, remoteId.get());
 }
 
 }  // namespace v8_inspector