[DevTools] Move InjectedScript.lastResult to native

third_party/WebKit/Source/platform/v8_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 248 matching lines @@
     return !outObject->IsEmpty();
 }
 
 String16 InjectedScript::objectGroupName(const RemoteObjectId& objectId) const
 {
     return m_native->groupName(objectId.id());
 }
 
 void InjectedScript::releaseObjectGroup(const String16& objectGroup)
 {
-    v8::HandleScope handles(m_context->isolate());
     m_native->releaseObjectGroup(objectGroup);
-    if (objectGroup == "console") {
-        V8FunctionCall function(m_context->debugger(), m_context->context(), v8Value(), "clearLastEvaluationResult");
-        bool hadException = false;
-        function.call(hadException);
-        ASSERT(!hadException);
-    }
+    if (objectGroup == "console")
+        m_lastEvaluationResult.Reset();
 }
 
 void InjectedScript::setCustomObjectFormatterEnabled(bool enabled)
 {
     v8::HandleScope handles(m_context->isolate());
     V8FunctionCall function(m_context->debugger(), m_context->context(), v8Value(), "setCustomObjectFormatterEnabled");
     function.appendArgument(enabled);
     bool hadException = false;
     function.call(hadException);
     ASSERT(!hadException);
 }
 
 bool InjectedScript::canAccessInspectedWindow() const
 {
     v8::Local<v8::Context> callingContext = m_context->isolate()->GetCallingContext();
     if (callingContext.IsEmpty())
         return true;
     return m_context->debugger()->client()->callingContextCanAccessContext(callingContext, m_context->context());
 }
 
 v8::Local<v8::Value> InjectedScript::v8Value() const
 {
     return m_value.Get(m_context->isolate());
 }
 
-bool InjectedScript::setLastEvaluationResult(ErrorString* errorString, v8::Local<v8::Value> value)
+v8::Local<v8::Value> InjectedScript::lastEvaluationResult() const
 {
-    V8FunctionCall function(m_context->debugger(), m_context->context(), v8Value(), "setLastEvaluationResult");
-    function.appendArgument(value);
-    bool hadException = false;
-    function.call(hadException, false);
-    return !hasInternalError(errorString, hadException);
+    if (m_lastEvaluationResult.IsEmpty())
+        return v8::Undefined(m_context->isolate());
+    return m_lastEvaluationResult.Get(m_context->isolate());
 }
 
 v8::MaybeLocal<v8::Value> InjectedScript::resolveCallArgument(ErrorString* errorString, protocol::Runtime::CallArgument* callArgument)
 {
     if (callArgument->hasObjectId()) {
         OwnPtr<RemoteObjectId> remoteObjectId = RemoteObjectId::parse(errorString, callArgument->getObjectId(""));
         if (!remoteObjectId)
             return v8::MaybeLocal<v8::Value>();
         if (remoteObjectId->contextId() != m_context->contextId()) {
             *errorString = "Argument should belong to the same JavaScript world as target object";
@@ skipping 39 matching lines @@
 
 void InjectedScript::wrapEvaluateResult(ErrorString* errorString, v8::MaybeLocal<v8::Value> maybeResultValue, const v8::TryCatch& tryCatch, const String16& objectGroup, bool returnByValue, bool generatePreview, OwnPtr<protocol::Runtime::RemoteObject>* result, Maybe<bool>* wasThrown, Maybe<protocol::Runtime::ExceptionDetails>* exceptionDetails)
 {
     v8::Local<v8::Value> resultValue;
     if (!tryCatch.HasCaught()) {
         if (hasInternalError(errorString, !maybeResultValue.ToLocal(&resultValue)))
             return;
         OwnPtr<RemoteObject> remoteObject = wrapObject(errorString, resultValue, objectGroup, returnByValue, generatePreview);
         if (!remoteObject)
             return;
-        if (objectGroup == "console" && !setLastEvaluationResult(errorString, resultValue))
-            return;
+        if (objectGroup == "console")
+            m_lastEvaluationResult.Reset(m_context->isolate(), resultValue);
         *result = remoteObject.release();
         if (wasThrown)
             *wasThrown = false;
     } else {
         v8::Local<v8::Value> exception = tryCatch.Exception();
         OwnPtr<RemoteObject> remoteObject = wrapObject(errorString, exception, objectGroup, false, generatePreview && !exception->IsNativeError());
         if (!remoteObject)
             return;
         *result = remoteObject.release();
         if (exceptionDetails)
@@ skipping 29 matching lines @@
         return false;
     m_context = m_injectedScript->context()->context();
     m_context->Enter();
     return true;
 }
 
 bool InjectedScript::Scope::installCommandLineAPI()
 {
     ASSERT(m_injectedScript && !m_context.IsEmpty());
     V8FunctionCall function(m_debugger, m_context, m_injectedScript->v8Value(), "commandLineAPI");
-    return installGlobalObjectExtension(function);
+    v8::Local<v8::Object> extensionObject;
+    if (!installGlobalObjectExtension(function).ToLocal(&extensionObject))
+        return false;
+    return extensionObject->Set(m_context, toV8StringInternalized(m_context->GetIsolate(), "$_"), m_injectedScript->lastEvaluationResult()).FromMaybe(false);
 }
 
 bool InjectedScript::Scope::installRemoteObjectAPI(const String16& objectGroupName)
 {
     ASSERT(m_injectedScript && !m_context.IsEmpty());
     V8FunctionCall function(m_debugger, m_context, m_injectedScript->v8Value(), "remoteObjectAPI");
     function.appendArgument(objectGroupName);
-    return installGlobalObjectExtension(function);
+    v8::Local<v8::Object> extensionObject;
+    return installGlobalObjectExtension(function).ToLocal(&extensionObject);
 }
 
-bool InjectedScript::Scope::installGlobalObjectExtension(V8FunctionCall& function)
+v8::MaybeLocal<v8::Object> InjectedScript::Scope::installGlobalObjectExtension(V8FunctionCall& function)
 {
     bool hadException = false;
     v8::Local<v8::Value> extension = function.call(hadException, false);
-    if (hadException || extension.IsEmpty()) {
+    if (hadException || extension.IsEmpty() || !extension->IsObject()) {
         *m_errorString = "Internal error";
-        return false;
+        return v8::MaybeLocal<v8::Object>();
     }
 
     ASSERT(m_global.IsEmpty());
     m_extensionSymbol = V8Debugger::scopeExtensionSymbol(m_debugger->isolate());
     v8::Local<v8::Object> global = m_context->Global();
     if (!global->Set(m_context, m_extensionSymbol, extension).FromMaybe(false)) {
         *m_errorString = "Internal error";
-        return false;
+        return v8::MaybeLocal<v8::Object>();
     }
 
     m_global = global;
-    return true;
+    return extension.As<v8::Object>();
 }
 
 void InjectedScript::Scope::ignoreExceptionsAndMuteConsole()
 {
     ASSERT(!m_ignoreExceptionsAndMuteConsole);
     m_ignoreExceptionsAndMuteConsole = true;
     m_debugger->client()->muteConsole();
     m_previousPauseOnExceptionsState = setPauseOnExceptionsState(V8DebuggerImpl::DontPauseOnExceptions);
 }
 
@@ skipping 82 matching lines @@
 void InjectedScript::CallFrameScope::findInjectedScript(V8InspectorSessionImpl* session)
 {
     OwnPtr<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 blink