Apply script preprocessor to Web page scripts only.

Source/bindings/v8/ScriptDebugServer.cpp

 /*
  * Copyright (c) 2010-2011 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 16 matching lines @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "bindings/v8/ScriptDebugServer.h"
 
 #include "DebuggerScriptSource.h"
 #include "V8JavaScriptCallFrame.h"
 #include "bindings/v8/ScopedPersistent.h"
+#include "bindings/v8/ScriptController.h"
 #include "bindings/v8/ScriptObject.h"
 #include "bindings/v8/V8Binding.h"
 #include "bindings/v8/V8ScriptRunner.h"
 #include "core/inspector/JavaScriptCallFrame.h"
 #include "core/inspector/ScriptDebugListener.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/Vector.h"
 #include "wtf/dtoa/utils.h"
 
 namespace WebCore {
@@ skipping 12 matching lines @@
 }
 
 v8::Local<v8::Value> ScriptDebugServer::callDebuggerMethod(const char* functionName, int argc, v8::Handle<v8::Value> argv[])
 {
     v8::Handle<v8::Object> debuggerScript = m_debuggerScript.newLocal(m_isolate);
     v8::Handle<v8::Function> function = v8::Local<v8::Function>::Cast(debuggerScript->Get(v8::String::NewSymbol(functionName)));
     ASSERT(v8::Context::InContext());
     return V8ScriptRunner::callInternalFunction(function, debuggerScript, argc, argv, m_isolate);
 }
 
-class ScriptDebugServer::ScriptPreprocessor {
-    WTF_MAKE_NONCOPYABLE(ScriptPreprocessor);
-public:
-    ScriptPreprocessor(const String& preprocessorScript, v8::Isolate* isolate)
-        : m_isolate(isolate)
-    {
-        v8::HandleScope scope(m_isolate);
-
-        v8::Local<v8::Context> context = v8::Context::New(m_isolate);
-        if (context.IsEmpty())
-            return;
-        v8::Context::Scope contextScope(context);
-
-        String wrappedScript = "(" + preprocessorScript + ")";
-        v8::Handle<v8::String> preprocessor = v8::String::New(wrappedScript.utf8().data(), wrappedScript.utf8().length());
-
-        v8::Local<v8::Value> preprocessorFunction = V8ScriptRunner::compileAndRunInternalScript(preprocessor, m_isolate);
-        if (preprocessorFunction.IsEmpty() || !preprocessorFunction->IsFunction())
-            return;
-
-        m_utilityContext.set(isolate, context);
-        m_preprocessorFunction.set(isolate, v8::Handle<v8::Function>::Cast(preprocessorFunction));
-    }
-
-    String preprocessSourceCode(const String& sourceCode, const String& sourceName)
-    {
-        v8::HandleScope handleScope(m_isolate);
-
-        if (m_preprocessorFunction.isEmpty())
-            return sourceCode;
-
-        v8::Local<v8::Context> context = m_utilityContext.newLocal(m_isolate);
-        v8::Context::Scope contextScope(context);
-
-        v8::Handle<v8::String> sourceCodeString = v8::String::New(sourceCode.utf8().data(), sourceCode.utf8().length());
-
-        v8::Handle<v8::String> sourceNameString = v8::String::New(sourceName.utf8().data(), sourceName.utf8().length());
-        v8::Handle<v8::Value> argv[] = { sourceCodeString, sourceNameString };
-        v8::Handle<v8::Value> resultValue = V8ScriptRunner::callInternalFunction(m_preprocessorFunction.newLocal(m_isolate), context->Global(), WTF_ARRAY_LENGTH(argv), argv, m_isolate);
-
-        if (!resultValue.IsEmpty() && resultValue->IsString()) {
-            v8::String::Utf8Value utf8Value(resultValue);
-            return String::fromUTF8(*utf8Value, utf8Value.length());
-        }
-        return sourceCode;
-    }
-
-    ~ScriptPreprocessor()
-    {
-    }
-
-private:
-    ScopedPersistent<v8::Context> m_utilityContext;
-    String m_preprocessorBody;
-    ScopedPersistent<v8::Function> m_preprocessorFunction;
-    v8::Isolate* m_isolate;
-};
-
 ScriptDebugServer::ScriptDebugServer(v8::Isolate* isolate)
     : m_pauseOnExceptionsState(DontPauseOnExceptions)
     , m_breakpointsActivated(true)
     , m_runningNestedMessageLoop(false)
     , m_isolate(isolate)
 {
 }
 
 ScriptDebugServer::~ScriptDebugServer()
 {
@@ skipping 221 matching lines @@
     return false;
 }
 
 
 void ScriptDebugServer::updateCallStack(ScriptValue* callFrame)
 {
     if (isPaused())
         *callFrame = currentCallFrame();
 }
 
+ScriptController* ScriptDebugServer::scriptController(v8::Handle<v8::Context> context)
+{
+    return 0;
+}
 
-void ScriptDebugServer::setScriptPreprocessor(const String& preprocessorBody)
+void ScriptDebugServer::preprocessEval(v8::Handle<v8::Context> eventContext, v8::Handle<v8::Object> eventData)
 {
-    m_scriptPreprocessor.clear();
-    if (!preprocessorBody.isEmpty())
-        m_scriptPreprocessor = adoptPtr(new ScriptPreprocessor(preprocessorBody, m_isolate));
+    ScriptController* controller = scriptController(eventContext);
+    if (!controller)
+        return;
+
+    // Don't examine event unless we are preprocessing Web page code.
+    if (!controller->hasScriptPreprocessor() || controller->isPreprocessingScript())
+        return;
+
+    v8::Local<v8::Context> debugContext = v8::Debug::GetDebugContext();
+    v8::Context::Scope contextScope(debugContext);
+
+    // <script> tag source and attribute value source are preprocessed before we enter V8.
+    // Avoid preprocessing any internal scripts by processing only eval source in this V8 event handler.
+    v8::Handle<v8::Value> argvEventData[] = { eventData };
+    String typeInfo = toWebCoreStringWithUndefinedOrNullCheck(callDebuggerMethod("getScriptCompilationTypeInfo", WTF_ARRAY_LENGTH(argvEventData), argvEventData));
+    if (!typeInfo.startsWith("eval"))
+        return;
+
+    // The name and source are in the JS event data.
+    String scriptName = toWebCoreStringWithUndefinedOrNullCheck(callDebuggerMethod("getScriptName", WTF_ARRAY_LENGTH(argvEventData), argvEventData));
+    String script = toWebCoreStringWithUndefinedOrNullCheck(callDebuggerMethod("getScriptSource", WTF_ARRAY_LENGTH(argvEventData), argvEventData));
+
+    String patchedScript = controller->preprocess(script, scriptName);
+
+    v8::Handle<v8::Value> argvPatchedScript[] = { eventData, v8String(patchedScript, debugContext->GetIsolate()) };
+    callDebuggerMethod("setScriptSource", WTF_ARRAY_LENGTH(argvPatchedScript), argvPatchedScript);
 }
 
 ScriptValue ScriptDebugServer::currentCallFrame()
 {
     ASSERT(isPaused());
     v8::HandleScope handleScope(m_isolate);
     v8::Handle<v8::Value> argv[] = { m_executionState.newLocal(m_isolate) };
     v8::Handle<v8::Value> currentCallFrameV8 = callDebuggerMethod("currentCallFrame", 1, argv);
 
     ASSERT(!currentCallFrameV8.IsEmpty());
@@ skipping 17 matching lines @@
 
 static ScriptDebugServer* toScriptDebugServer(v8::Handle<v8::Value> data)
 {
     void* p = v8::Handle<v8::External>::Cast(data)->Value();
     return static_cast<ScriptDebugServer*>(p);
 }
 
 void ScriptDebugServer::breakProgramCallback(const v8::FunctionCallbackInfo<v8::Value>& args)
 {
     ASSERT(2 == args.Length());
-    
     ScriptDebugServer* thisPtr = toScriptDebugServer(args.Data());
     v8::Handle<v8::Value> exception;
     v8::Handle<v8::Array> hitBreakpoints;
     thisPtr->handleProgramBreak(v8::Handle<v8::Object>::Cast(args[0]), exception, hitBreakpoints);
 }
 
 void ScriptDebugServer::handleProgramBreak(v8::Handle<v8::Object> executionState, v8::Handle<v8::Value> exception, v8::Handle<v8::Array> hitBreakpointNumbers)
 {
     // Don't allow nested breaks.
     if (isPaused())
@@ skipping 43 matching lines @@
     }
 
     if (event != v8::Break && event != v8::Exception && event != v8::AfterCompile && event != v8::BeforeCompile)
         return;
 
     v8::Handle<v8::Context> eventContext = eventDetails.GetEventContext();
     ASSERT(!eventContext.IsEmpty());
 
     ScriptDebugListener* listener = getDebugListenerForContext(eventContext);
     if (listener) {
-        v8::HandleScope scope(m_isolate);
-        v8::Local<v8::Context> debugContext = v8::Debug::GetDebugContext();
-        v8::Handle<v8::Object> debuggerScript = m_debuggerScript.newLocal(m_isolate);
         if (event == v8::BeforeCompile) {
-
-            if (!m_scriptPreprocessor)
-                return;
-
-            OwnPtr<ScriptPreprocessor> preprocessor(m_scriptPreprocessor.release());
-            v8::Context::Scope contextScope(debugContext);
-            v8::Handle<v8::Function> getScriptSourceFunction = v8::Local<v8::Function>::Cast(debuggerScript->Get(v8::String::New("getScriptSource")));
-            v8::Handle<v8::Value> argv[] = { eventDetails.GetEventData() };
-            v8::Handle<v8::Value> script = V8ScriptRunner::callInternalFunction(getScriptSourceFunction, debuggerScript, WTF_ARRAY_LENGTH(argv), argv, m_isolate);
-
-            v8::Handle<v8::Function> getScriptNameFunction = v8::Local<v8::Function>::Cast(debuggerScript->Get(v8::String::New("getScriptName")));
-            v8::Handle<v8::Value> argv1[] = { eventDetails.GetEventData() };
-            v8::Handle<v8::Value> scriptName = V8ScriptRunner::callInternalFunction(getScriptNameFunction, debuggerScript, WTF_ARRAY_LENGTH(argv1), argv1, m_isolate);
-            v8::Handle<v8::Function> setScriptSourceFunction = v8::Local<v8::Function>::Cast(debuggerScript->Get(v8::String::New("setScriptSource")));
-            String patchedScript = preprocessor->preprocessSourceCode(toWebCoreStringWithUndefinedOrNullCheck(script), toWebCoreStringWithUndefinedOrNullCheck(scriptName));
-
-            v8::Handle<v8::Value> argv2[] = { eventDetails.GetEventData(), v8String(patchedScript, m_isolate) };
-            V8ScriptRunner::callInternalFunction(setScriptSourceFunction, debuggerScript, WTF_ARRAY_LENGTH(argv2), argv2, m_isolate);
-            m_scriptPreprocessor = preprocessor.release();
+            preprocessEval(eventContext, eventDetails.GetEventData());
         } else if (event == v8::AfterCompile) {
             v8::Context::Scope contextScope(v8::Debug::GetDebugContext());
-            v8::Handle<v8::Function> getAfterCompileScript = v8::Local<v8::Function>::Cast(debuggerScript->Get(v8::String::NewSymbol("getAfterCompileScript")));
+            v8::Handle<v8::Function> getAfterCompileScript = v8::Local<v8::Function>::Cast(m_debuggerScript.get()->Get(v8::String::NewSymbol("getAfterCompileScript")));

[haraken, 2013/07/11 01:13:59]

ScopedPersistent::get() returns an unsafe handle and is going to be deprecated
(as commented in ScopedPersistent). Please create a local handle and use it like
this:

  v8::Handle<v8::Object> debuggerScript = m_debuggerScript.newLocal(m_isolate);
  debuggerScript->Get(...);

[johnjbarton, 2013/07/11 19:14:42]

Done.

             v8::Handle<v8::Value> argv[] = { eventDetails.GetEventData() };
-            v8::Handle<v8::Value> value = V8ScriptRunner::callInternalFunction(getAfterCompileScript, debuggerScript, WTF_ARRAY_LENGTH(argv), argv, m_isolate);
+            v8::Handle<v8::Value> value = V8ScriptRunner::callInternalFunction(getAfterCompileScript, m_debuggerScript.get(), WTF_ARRAY_LENGTH(argv), argv, m_isolate);

[haraken, 2013/07/11 01:13:59]

Ditto.

[johnjbarton, 2013/07/11 19:14:42]

Done.

             ASSERT(value->IsObject());
             v8::Handle<v8::Object> object = v8::Handle<v8::Object>::Cast(value);
             dispatchDidParseSource(listener, object);
         } else if (event == v8::Exception) {
             v8::Local<v8::StackTrace> stackTrace = v8::StackTrace::CurrentStackTrace(1);
             // Stack trace is empty in case of syntax error. Silently continue execution in such cases.
             if (!stackTrace->GetFrameCount())
                 return;
             v8::Handle<v8::Object> eventData = eventDetails.GetEventData();
             v8::Handle<v8::Value> exceptionGetterValue = eventData->Get(v8::String::NewSymbol("exception"));
             ASSERT(!exceptionGetterValue.IsEmpty() && exceptionGetterValue->IsFunction());
             v8::Handle<v8::Value> exception = V8ScriptRunner::callInternalFunction(v8::Handle<v8::Function>::Cast(exceptionGetterValue), eventData, 0, 0, m_isolate);
             handleProgramBreak(eventDetails, exception, v8::Handle<v8::Array>());
         } else if (event == v8::Break) {
-            v8::Handle<v8::Function> getBreakpointNumbersFunction = v8::Local<v8::Function>::Cast(debuggerScript->Get(v8::String::NewSymbol("getBreakpointNumbers")));
+            v8::Handle<v8::Function> getBreakpointNumbersFunction = v8::Local<v8::Function>::Cast(m_debuggerScript.get()->Get(v8::String::NewSymbol("getBreakpointNumbers")));

[haraken, 2013/07/11 01:13:59]

Ditto.

[johnjbarton, 2013/07/11 19:14:42]

Done.

             v8::Handle<v8::Value> argv[] = { eventDetails.GetEventData() };
-            v8::Handle<v8::Value> hitBreakpoints = V8ScriptRunner::callInternalFunction(getBreakpointNumbersFunction, debuggerScript, WTF_ARRAY_LENGTH(argv), argv, m_isolate);
+            v8::Handle<v8::Value> hitBreakpoints = V8ScriptRunner::callInternalFunction(getBreakpointNumbersFunction, m_debuggerScript.get(), WTF_ARRAY_LENGTH(argv), argv, m_isolate);

[haraken, 2013/07/11 01:13:59]

Ditto.

[johnjbarton, 2013/07/11 19:14:42]

Done.

             ASSERT(hitBreakpoints->IsArray());
 
             handleProgramBreak(eventDetails, v8::Handle<v8::Value>(), hitBreakpoints.As<v8::Array>());
         }
     }
 }
 
 void ScriptDebugServer::dispatchDidParseSource(ScriptDebugListener* listener, v8::Handle<v8::Object> object)
 {
     String sourceID = toWebCoreStringWithUndefinedOrNullCheck(object->Get(v8::String::NewSymbol("id")));
@@ skipping 114 matching lines @@
         *wasThrown = true;
         *result = ScriptValue(tryCatch.Exception());
         v8::Local<v8::Message> message = tryCatch.Message();
         if (!message.IsEmpty())
             *exceptionMessage = toWebCoreStringWithUndefinedOrNullCheck(message->Get());
     } else
         *result = ScriptValue(value);
 }
 
 } // namespace WebCore