[DevTools] Move evaluateOnCallFrame to native

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

 // Copyright 2015 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/V8DebuggerAgentImpl.h"
 
 #include "platform/inspector_protocol/String16.h"
 #include "platform/inspector_protocol/Values.h"
 #include "platform/v8_inspector/IgnoreExceptionsScope.h"
 #include "platform/v8_inspector/InjectedScript.h"
@@ skipping 702 matching lines @@
     }
 
     v8::Local<v8::Object> detailsObject;
     v8::Local<v8::Value> detailsValue = debugger().generatorObjectDetails(object);
     if (!detailsValue->IsObject() || !detailsValue->ToObject(context).ToLocal(&detailsObject)) {
         *errorString = "Internal error";
         return;
     }
 
     String16 groupName = injectedScript->objectGroupName(*remoteId);
-    if (!injectedScript->wrapObjectProperty(errorString, detailsObject, toV8String(m_isolate, "function"), groupName, false))
+    if (!injectedScript->wrapObjectProperty(errorString, detailsObject, toV8String(m_isolate, "function"), groupName, false, true))

[dgozman, 2016/03/17 19:16:12]

true -> false

[kozy, 2016/03/17 20:48:56]

Done.

         return;
 
     protocol::ErrorSupport errors;
     OwnPtr<GeneratorObjectDetails> protocolDetails = GeneratorObjectDetails::parse(toProtocolValue(context, detailsObject).get(), &errors);
     if (!protocolDetails) {
         *errorString = "Internal error";
         return;
     }
     *outDetails = protocolDetails.release();
 }
@@ skipping 185 matching lines @@
         *errorString = "Attempt to access callframe when debugger is not on pause";
         return;
     }
     OwnPtr<RemoteCallFrameId> remoteId = RemoteCallFrameId::parse(errorString, callFrameId);
     if (!remoteId)
         return;
     InjectedScript* injectedScript = m_injectedScriptManager->findInjectedScript(errorString, remoteId.get());
     if (!injectedScript)
         return;
 
-    v8::HandleScope scope(m_isolate);
-    v8::Local<v8::Object> callStack = m_currentCallStack.Get(m_isolate);
+    v8::HandleScope scope(injectedScript->isolate());
 
-    IgnoreExceptionsScope ignoreExceptionsScope(doNotPauseOnExceptionsAndMuteConsole.fromMaybe(false) ? m_debugger : nullptr);
-    injectedScript->evaluateOnCallFrame(errorString, callStack, callFrameId, expression, objectGroup.fromMaybe(""), includeCommandLineAPI.fromMaybe(false), returnByValue.fromMaybe(false), generatePreview.fromMaybe(false), result, wasThrown, exceptionDetails);
+    if (!injectedScript->canAccessInspectedWindow()) {
+        *errorString = "Can not access given context";
+        return;
+    }
+
+    OwnPtr<JavaScriptCallFrame> javaScriptCallFrame = debugger().callFrameNoScopes(remoteId->frameOrdinal());
+    if (!javaScriptCallFrame) {
+        *errorString = "Could not find call frame with given id";
+        return;
+    }
+
+    InjectedScriptManager::InjectScopeExtensionByName scopeExtension(errorString, injectedScript, true, includeCommandLineAPI.fromMaybe(false) ? "commandLineAPI" : String16());
+    if (scopeExtension.hasError())
+        return;
+
+    v8::TryCatch tryCatch(injectedScript->isolate());
+
+    v8::Local<v8::Value> resultValue;
+    bool success = javaScriptCallFrame->evaluateWithExceptionDetails(toV8String(injectedScript->isolate(), expression)).ToLocal(&resultValue);

[dgozman, 2016/03/17 19:16:12]

Let's pass Maybe further and forget about ToLocal here.

[kozy, 2016/03/17 20:48:56]

Done.

+    ALLOW_UNUSED_LOCAL(success);
+
+    injectedScript = m_injectedScriptManager->findInjectedScript(errorString, remoteId.get());

[dgozman, 2016/03/17 19:16:12]

// InjectedScript may be gone after any evaluate call - find it again.

[kozy, 2016/03/17 20:48:56]

Done.

+    if (!injectedScript)
+        return;
+
+    V8RuntimeAgentImpl::wrapEvaluateResult(errorString,

[dgozman, 2016/03/17 19:16:12]

Let's make this an instance method on InjectedScript.

[kozy, 2016/03/17 20:48:56]

Done.

+        m_debugger,
+        injectedScript,
+        resultValue,
+        tryCatch,
+        objectGroup.fromMaybe(""),
+        returnByValue.fromMaybe(false),
+        generatePreview.fromMaybe(false),
+        result,
+        wasThrown,
+        exceptionDetails);
 }
 
 void V8DebuggerAgentImpl::setVariableValue(ErrorString* errorString,
     int scopeNumber,
     const String16& variableName,
     PassOwnPtr<protocol::Runtime::CallArgument> newValueArgument,
     const String16& callFrameId)
 {
     if (!checkEnabled(errorString))
         return;
@@ skipping 61 matching lines @@
         *errorString = "Promise tracking is disabled";
         return;
     }
     v8::HandleScope handles(m_isolate);
     v8::Local<v8::Object> value = m_promiseTracker->promiseById(promiseId);
     if (value.IsEmpty()) {
         *errorString = "Promise with specified ID not found.";
         return;
     }
     InjectedScript* injectedScript = m_injectedScriptManager->injectedScriptFor(value->CreationContext());
-    *promise = injectedScript->wrapObject(value, objectGroup.fromMaybe(""));
+    OwnPtr<RemoteObject> promiseObject = injectedScript->wrapObject(errorString, value, objectGroup.fromMaybe(""));

[dgozman, 2016/03/17 19:16:12]

Revert.

[kozy, 2016/03/17 20:48:56]

Done.

+    if (!promiseObject)
+        return;
+    *promise = promiseObject.release();
 }
 
 void V8DebuggerAgentImpl::didUpdatePromise(const String16& eventType, PassOwnPtr<protocol::Debugger::PromiseDetails> promise)
 {
     if (m_frontend)
         m_frontend->promiseUpdated(eventType, promise);
 }
 
 int V8DebuggerAgentImpl::traceAsyncOperationStarting(const String16& description)
 {
@@ skipping 389 matching lines @@
 
     ASSERT(m_pausedContext.IsEmpty());
     m_pausedContext.Reset(m_isolate, context);
     m_currentCallStack.Reset(m_isolate, callFrames);
     v8::HandleScope handles(m_isolate);
 
     if (!exception.IsEmpty()) {
         InjectedScript* injectedScript = m_injectedScriptManager->injectedScriptFor(context);
         if (injectedScript) {
             m_breakReason = isPromiseRejection ? protocol::Debugger::Paused::ReasonEnum::PromiseRejection : protocol::Debugger::Paused::ReasonEnum::Exception;
-            auto obj = injectedScript->wrapObject(exception, V8DebuggerAgentImpl::backtraceObjectGroup);
+            ErrorString errorString;
+            auto obj = injectedScript->wrapObject(&errorString, exception, V8DebuggerAgentImpl::backtraceObjectGroup);
             m_breakAuxData = obj ? obj->serialize() : nullptr;
             // m_breakAuxData might be null after this.
         }
     } else if (m_pausingOnAsyncOperation) {
         m_breakReason = protocol::Debugger::Paused::ReasonEnum::AsyncOperation;
         m_breakAuxData = protocol::DictionaryValue::create();
         m_breakAuxData->setNumber("operationId", m_currentAsyncOperationId);
     }
 
     OwnPtr<Array<String16>> hitBreakpointIds = Array<String16>::create();
@@ skipping 103 matching lines @@
     m_scripts.clear();
     m_blackboxedPositions.clear();
     m_breakpointIdToDebuggerBreakpointIds.clear();
     resetAsyncCallTracker();
     m_promiseTracker->clear();
     if (m_frontend)
         m_frontend->globalObjectCleared();
 }
 
 } // namespace blink