[DevTools] Copy objects from debugger context to inspected context properly.

third_party/WebKit/Source/platform/v8_inspector/V8Debugger.cpp

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "platform/v8_inspector/V8Debugger.h"
 
 #include "platform/v8_inspector/DebuggerScript.h"
 #include "platform/v8_inspector/ScriptBreakpoint.h"
 #include "platform/v8_inspector/V8Compat.h"
 #include "platform/v8_inspector/V8DebuggerAgentImpl.h"
@@ skipping 10 matching lines @@
 const char stepOutV8MethodName[] = "stepOutOfFunction";
 static const char v8AsyncTaskEventEnqueue[] = "enqueue";
 static const char v8AsyncTaskEventWillHandle[] = "willHandle";
 static const char v8AsyncTaskEventDidHandle[] = "didHandle";
 
 inline v8::Local<v8::Boolean> v8Boolean(bool value, v8::Isolate* isolate)
 {
     return value ? v8::True(isolate) : v8::False(isolate);
 }
 
+v8::Local<v8::Value> createInternalLocation(v8::Isolate* isolate, v8::Local<v8::Context> context, v8::Local<v8::String> scriptId, v8::Local<v8::Number> lineNumber, v8::Local<v8::Number> columnNumber)
+{
+    v8::Local<v8::Object> location = v8::Object::New(isolate);
+    if (!location->SetPrototype(context, v8::Null(isolate)).FromMaybe(false))
+        return v8::Null(isolate);
+    if (!location->Set(context, toV8StringInternalized(isolate, "scriptId"), scriptId).FromMaybe(false))
+        return v8::Null(isolate);
+    if (!location->Set(context, toV8StringInternalized(isolate, "lineNumber"), lineNumber).FromMaybe(false))
+        return v8::Null(isolate);
+    if (!location->Set(context, toV8StringInternalized(isolate, "columnNumber"), columnNumber).FromMaybe(false))
+        return v8::Null(isolate);
+    if (!markAsInternal(context, location, V8InternalValueType::kLocation))
+        return v8::Null(isolate);
+    return location;
+}
+
+v8::Local<v8::Value> createInternalLocation(v8::Isolate* isolate, v8::Local<v8::Context> fromContext, v8::Local<v8::Context> toContext, v8::Local<v8::Object> location)
+{
+    v8::Local<v8::Value> scriptId;
+    if (!location->Get(fromContext, toV8StringInternalized(isolate, "scriptId")).ToLocal(&scriptId) || !scriptId->IsString())
+        return v8::Null(isolate);
+    v8::Local<v8::Value> lineNumber;
+    if (!location->Get(fromContext, toV8StringInternalized(isolate, "lineNumber")).ToLocal(&lineNumber) || !lineNumber->IsNumber())
+        return v8::Null(isolate);
+    v8::Local<v8::Value> columnNumber;
+    if (!location->Get(fromContext, toV8StringInternalized(isolate, "columnNumber")).ToLocal(&columnNumber) || !columnNumber->IsNumber())
+        return v8::Null(isolate);
+    return createInternalLocation(isolate, toContext, scriptId.As<v8::String>(), lineNumber.As<v8::Number>(), columnNumber.As<v8::Number>());
+}
+
 }
 
 static bool inLiveEditScope = false;
 
 v8::MaybeLocal<v8::Value> V8Debugger::callDebuggerMethod(const char* functionName, int argc, v8::Local<v8::Value> argv[])
 {
     v8::MicrotasksScope microtasks(m_isolate, v8::MicrotasksScope::kDoNotRunMicrotasks);
     v8::Local<v8::Object> debuggerScript = m_debuggerScript.Get(m_isolate);
     v8::Local<v8::Function> function = v8::Local<v8::Function>::Cast(debuggerScript->Get(toV8StringInternalized(m_isolate, functionName)));
     DCHECK(m_isolate->InContext());
@@ skipping 533 matching lines @@
     DCHECK(value->IsObject());
     m_debuggerScript.Reset(m_isolate, value.As<v8::Object>());
 }
 
 v8::Local<v8::Context> V8Debugger::debuggerContext() const
 {
     DCHECK(!m_debuggerContext.IsEmpty());
     return m_debuggerContext.Get(m_isolate);
 }
 
-v8::MaybeLocal<v8::Value> V8Debugger::functionScopes(v8::Local<v8::Function> function)
+v8::MaybeLocal<v8::Value> V8Debugger::functionScopes(v8::Local<v8::Context> context, v8::Local<v8::Function> function)
 {
     if (!enabled()) {
         NOTREACHED();
         return v8::Local<v8::Value>::New(m_isolate, v8::Undefined(m_isolate));
     }
     v8::Local<v8::Value> argv[] = { function };
     v8::Local<v8::Value> scopesValue;
     if (!callDebuggerMethod("getFunctionScopes", 1, argv).ToLocal(&scopesValue) || !scopesValue->IsArray())
         return v8::MaybeLocal<v8::Value>();
     v8::Local<v8::Array> scopes = scopesValue.As<v8::Array>();
-    v8::Local<v8::Context> context = m_debuggerContext.Get(m_isolate);
-    if (!markAsInternal(context, scopes, V8InternalValueType::kScopeList))
+
+    v8::Local<v8::Array> result = v8::Array::New(m_isolate, scopes->Length());

[pfeldman, 2016/08/16 17:07:36]

This is too fragile and adhock. You leak one array and compromise the entire
context.

[dgozman, 2016/08/17 00:58:32]

Updated.

+    if (!result->SetPrototype(context, v8::Null(m_isolate)).FromMaybe(false))
         return v8::MaybeLocal<v8::Value>();
-    if (!markArrayEntriesAsInternal(context, scopes, V8InternalValueType::kScope))
+    if (!markAsInternal(context, result, V8InternalValueType::kScopeList))
         return v8::MaybeLocal<v8::Value>();
-    if (!scopes->SetPrototype(context, v8::Null(m_isolate)).FromMaybe(false))
-        return v8::Undefined(m_isolate);
-    return scopes;
+
+    for (size_t i = 0; i < scopes->Length(); ++i) {
+        v8::Local<v8::Value> scopeValue;
+        if (!scopes->Get(debuggerContext(), i).ToLocal(&scopeValue) || !scopeValue->IsObject())
+            return v8::MaybeLocal<v8::Value>();
+        v8::Local<v8::Object> scope = scopeValue.As<v8::Object>();
+
+        v8::Local<v8::Object> resultScope = v8::Object::New(m_isolate);
+        if (!resultScope->SetPrototype(context, v8::Null(m_isolate)).FromMaybe(false))
+            return v8::MaybeLocal<v8::Value>();
+        if (!markAsInternal(context, resultScope, V8InternalValueType::kScope))
+            return v8::MaybeLocal<v8::Value>();
+
+        v8::Local<v8::Value> type;
+        if (!scope->Get(debuggerContext(), toV8StringInternalized(m_isolate, "type")).ToLocal(&type) || !type->IsString())
+            return v8::MaybeLocal<v8::Value>();
+        if (!resultScope->Set(context, toV8StringInternalized(m_isolate, "type"), type).FromMaybe(false))
+            return v8::MaybeLocal<v8::Value>();
+
+        v8::Local<v8::Value> object;
+        if (!scope->Get(debuggerContext(), toV8StringInternalized(m_isolate, "object")).ToLocal(&object) || !object->IsObject())
+            return v8::MaybeLocal<v8::Value>();
+        if (!resultScope->Set(context, toV8StringInternalized(m_isolate, "object"), object).FromMaybe(false))
+            return v8::MaybeLocal<v8::Value>();
+
+        if (scope->HasOwnProperty(debuggerContext(), toV8StringInternalized(m_isolate, "name")).FromMaybe(false)) {
+            v8::Local<v8::Value> name;
+            if (!scope->Get(debuggerContext(), toV8StringInternalized(m_isolate, "name")).ToLocal(&name) || !name->IsString())
+                return v8::MaybeLocal<v8::Value>();
+            if (!resultScope->Set(context, toV8StringInternalized(m_isolate, "name"), name).FromMaybe(false))
+                return v8::MaybeLocal<v8::Value>();
+        }
+
+        if (scope->HasOwnProperty(debuggerContext(), toV8StringInternalized(m_isolate, "startLocation")).FromMaybe(false)) {
+            v8::Local<v8::Value> startLocation;
+            if (!scope->Get(debuggerContext(), toV8StringInternalized(m_isolate, "startLocation")).ToLocal(&startLocation) || !startLocation->IsObject())
+                return v8::MaybeLocal<v8::Value>();
+            v8::Local<v8::Object> startLocationObject = startLocation.As<v8::Object>();
+            v8::Local<v8::Value> resultStartLocation = createInternalLocation(m_isolate, debuggerContext(), context, startLocationObject);
+            if (resultStartLocation->IsNull() || !resultScope->Set(context, toV8StringInternalized(m_isolate, "startLocation"), resultStartLocation).FromMaybe(false))
+                return v8::MaybeLocal<v8::Value>();
+        }
+
+        if (scope->HasOwnProperty(debuggerContext(), toV8StringInternalized(m_isolate, "endLocation")).FromMaybe(false)) {
+            v8::Local<v8::Value> endLocation;
+            if (!scope->Get(debuggerContext(), toV8StringInternalized(m_isolate, "endLocation")).ToLocal(&endLocation) || !endLocation->IsObject())
+                return v8::MaybeLocal<v8::Value>();
+            v8::Local<v8::Object> endLocationObject = endLocation.As<v8::Object>();
+            v8::Local<v8::Value> resultEndLocation = createInternalLocation(m_isolate, debuggerContext(), context, endLocationObject);
+            if (resultEndLocation->IsNull() || !resultScope->Set(context, toV8StringInternalized(m_isolate, "endLocation"), resultEndLocation).FromMaybe(false))
+                return v8::MaybeLocal<v8::Value>();
+        }
+
+        if (!result->Set(context, i, resultScope).FromMaybe(false))
+            return v8::MaybeLocal<v8::Value>();
+    }
+    return result;
 }
 
 v8::MaybeLocal<v8::Array> V8Debugger::internalProperties(v8::Local<v8::Context> context, v8::Local<v8::Value> value)
 {
     v8::Local<v8::Array> properties;
     if (!v8::Debug::GetInternalProperties(m_isolate, value).ToLocal(&properties))
         return v8::MaybeLocal<v8::Array>();
     if (value->IsFunction()) {
         v8::Local<v8::Function> function = value.As<v8::Function>();
         v8::Local<v8::Value> location = functionLocation(context, function);
         if (location->IsObject()) {
             properties->Set(properties->Length(), toV8StringInternalized(m_isolate, "[[FunctionLocation]]"));
             properties->Set(properties->Length(), location);
         }
         if (function->IsGeneratorFunction()) {
             properties->Set(properties->Length(), toV8StringInternalized(m_isolate, "[[IsGenerator]]"));
             properties->Set(properties->Length(), v8::True(m_isolate));
         }
     }
     if (!enabled())
         return properties;
     if (value->IsMap() || value->IsWeakMap() || value->IsSet() || value->IsWeakSet() || value->IsSetIterator() || value->IsMapIterator()) {
         v8::Local<v8::Value> entries = collectionEntries(context, v8::Local<v8::Object>::Cast(value));
         if (entries->IsArray()) {
             properties->Set(properties->Length(), toV8StringInternalized(m_isolate, "[[Entries]]"));
             properties->Set(properties->Length(), entries);
         }
     }
     if (value->IsGeneratorObject()) {
-        v8::Local<v8::Value> location = generatorObjectLocation(v8::Local<v8::Object>::Cast(value));
+        v8::Local<v8::Value> location = generatorObjectLocation(context, v8::Local<v8::Object>::Cast(value));
         if (location->IsObject()) {
             properties->Set(properties->Length(), toV8StringInternalized(m_isolate, "[[GeneratorLocation]]"));
             properties->Set(properties->Length(), location);
         }
     }
     if (value->IsFunction()) {
         v8::Local<v8::Function> function = value.As<v8::Function>();
         v8::Local<v8::Value> boundFunction = function->GetBoundFunction();
         v8::Local<v8::Value> scopes;
-        if (boundFunction->IsUndefined() && functionScopes(function).ToLocal(&scopes)) {
+        if (boundFunction->IsUndefined() && functionScopes(context, function).ToLocal(&scopes)) {
             properties->Set(properties->Length(), toV8StringInternalized(m_isolate, "[[Scopes]]"));
             properties->Set(properties->Length(), scopes);
         }
     }
     return properties;
 }
 
 v8::Local<v8::Value> V8Debugger::collectionEntries(v8::Local<v8::Context> context, v8::Local<v8::Object> object)
 {
     if (!enabled()) {
         NOTREACHED();
         return v8::Undefined(m_isolate);
     }
     v8::Local<v8::Value> argv[] = { object };
     v8::Local<v8::Value> entriesValue = callDebuggerMethod("getCollectionEntries", 1, argv).ToLocalChecked();
     if (!entriesValue->IsArray())
         return v8::Undefined(m_isolate);
     v8::Local<v8::Array> entries = entriesValue.As<v8::Array>();
-    if (!markArrayEntriesAsInternal(context, entries, V8InternalValueType::kEntry))
+
+    v8::Local<v8::Array> result = v8::Array::New(m_isolate, entries->Length());
+    if (!result->SetPrototype(context, v8::Null(m_isolate)).FromMaybe(false))
         return v8::Undefined(m_isolate);
-    if (!entries->SetPrototype(context, v8::Null(m_isolate)).FromMaybe(false))
-        return v8::Undefined(m_isolate);
-    return entries;
+
+    for (size_t i = 0; i < entries->Length(); ++i) {
+        v8::Local<v8::Value> entryValue;
+        if (!entries->Get(debuggerContext(), i).ToLocal(&entryValue) || !entryValue->IsObject())
+            return v8::Undefined(m_isolate);
+        v8::Local<v8::Object> entry = entryValue.As<v8::Object>();
+
+        v8::Local<v8::Object> resultEntry = v8::Object::New(m_isolate);
+        if (!resultEntry->SetPrototype(context, v8::Null(m_isolate)).FromMaybe(false))
+            return v8::Undefined(m_isolate);
+        if (!markAsInternal(context, resultEntry, V8InternalValueType::kEntry))
+            return v8::Undefined(m_isolate);
+
+        v8::Local<v8::Value> value;
+        if (!entry->Get(debuggerContext(), toV8StringInternalized(m_isolate, "value")).ToLocal(&value))
+            return v8::Undefined(m_isolate);
+        if (!resultEntry->Set(context, toV8StringInternalized(m_isolate, "value"), value).FromMaybe(false))
+            return v8::Undefined(m_isolate);
+
+        if (entry->HasOwnProperty(debuggerContext(), toV8StringInternalized(m_isolate, "key")).FromMaybe(false)) {
+            v8::Local<v8::Value> key;
+            if (!entry->Get(debuggerContext(), toV8StringInternalized(m_isolate, "key")).ToLocal(&key))
+                return v8::Undefined(m_isolate);
+            if (!resultEntry->Set(context, toV8StringInternalized(m_isolate, "key"), key).FromMaybe(false))
+                return v8::Undefined(m_isolate);
+        }
+
+        if (!result->Set(context, i, resultEntry).FromMaybe(false))
+            return v8::Undefined(m_isolate);
+    }
+    return result;
 }
 
-v8::Local<v8::Value> V8Debugger::generatorObjectLocation(v8::Local<v8::Object> object)
+v8::Local<v8::Value> V8Debugger::generatorObjectLocation(v8::Local<v8::Context> context, v8::Local<v8::Object> object)
 {
     if (!enabled()) {
         NOTREACHED();
         return v8::Null(m_isolate);
     }
     v8::Local<v8::Value> argv[] = { object };
-    v8::Local<v8::Value> location = callDebuggerMethod("getGeneratorObjectLocation", 1, argv).ToLocalChecked();
-    if (!location->IsObject())
+    v8::Local<v8::Value> locationValue = callDebuggerMethod("getGeneratorObjectLocation", 1, argv).ToLocalChecked();
+    if (!locationValue->IsObject())
         return v8::Null(m_isolate);
-    v8::Local<v8::Context> context = m_debuggerContext.Get(m_isolate);
-    if (!markAsInternal(context, v8::Local<v8::Object>::Cast(location), V8InternalValueType::kLocation))
-        return v8::Null(m_isolate);
-    return location;
+    v8::Local<v8::Object> location = locationValue.As<v8::Object>();
+    return createInternalLocation(m_isolate, debuggerContext(), context, location);
 }
 
 v8::Local<v8::Value> V8Debugger::functionLocation(v8::Local<v8::Context> context, v8::Local<v8::Function> function)
 {
     int scriptId = function->ScriptId();
     if (scriptId == v8::UnboundScript::kNoScriptId)
         return v8::Null(m_isolate);
     int lineNumber = function->GetScriptLineNumber();
     int columnNumber = function->GetScriptColumnNumber();
     if (lineNumber == v8::Function::kLineOffsetNotFound || columnNumber == v8::Function::kLineOffsetNotFound)
         return v8::Null(m_isolate);
-    v8::Local<v8::Object> location = v8::Object::New(m_isolate);
-    if (!location->Set(context, toV8StringInternalized(m_isolate, "scriptId"), toV8String(m_isolate, String16::fromInteger(scriptId))).FromMaybe(false))
-        return v8::Null(m_isolate);
-    if (!location->Set(context, toV8StringInternalized(m_isolate, "lineNumber"), v8::Integer::New(m_isolate, lineNumber)).FromMaybe(false))
-        return v8::Null(m_isolate);
-    if (!location->Set(context, toV8StringInternalized(m_isolate, "columnNumber"), v8::Integer::New(m_isolate, columnNumber)).FromMaybe(false))
-        return v8::Null(m_isolate);
-    if (!markAsInternal(context, location, V8InternalValueType::kLocation))
-        return v8::Null(m_isolate);
-    return location;
+    return createInternalLocation(m_isolate, context, toV8String(m_isolate, String16::fromInteger(scriptId)), v8::Integer::New(m_isolate, lineNumber), v8::Integer::New(m_isolate, columnNumber));
 }
 
 bool V8Debugger::isPaused()
 {
     return !m_pausedContext.IsEmpty();
 }
 
 std::unique_ptr<V8StackTraceImpl> V8Debugger::createStackTrace(v8::Local<v8::StackTrace> stackTrace)
 {
     int contextGroupId = m_isolate->InContext() ? getGroupId(m_isolate->GetCurrentContext()) : 0;
@@ skipping 117 matching lines @@
         return nullptr;
 
     size_t stackSize = fullStack ? V8StackTraceImpl::maxCallStackSizeToCapture : 1;
     if (m_inspector->enabledRuntimeAgentForGroup(contextGroupId))
         stackSize = V8StackTraceImpl::maxCallStackSizeToCapture;
 
     return V8StackTraceImpl::capture(this, contextGroupId, stackSize);
 }
 
 } // namespace blink