Apply ScriptPreprocessor 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"
 #include "wtf/text/CString.h"
 
@@ skipping 13 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 222 matching lines @@
     return false;
 }
 
 
 void ScriptDebugServer::updateCallStack(ScriptValue* callFrame)
 {
     if (isPaused())
         *callFrame = currentCallFrame();
 }
 
-
-void ScriptDebugServer::setScriptPreprocessor(const String& preprocessorBody)
+ScriptController* ScriptDebugServer::scriptController(v8::Handle<v8::Context> context)
 {
-    m_scriptPreprocessor.clear();
-    if (!preprocessorBody.isEmpty())
-        m_scriptPreprocessor = adoptPtr(new ScriptPreprocessor(preprocessorBody, m_isolate));
+    return 0;
 }
 
 PassRefPtr<JavaScriptCallFrame> ScriptDebugServer::wrapCallFrames(v8::Handle<v8::Object> executionState, int maximumLimit)
 {
     v8::Handle<v8::Value> argv[] = { executionState, v8::Integer::New(maximumLimit) };
     v8::Handle<v8::Value> currentCallFrameV8 = callDebuggerMethod("currentCallFrame", 2, argv);
 
     ASSERT(!currentCallFrameV8.IsEmpty());
     if (!currentCallFrameV8->IsObject())
         return PassRefPtr<JavaScriptCallFrame>();
@@ skipping 23 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 44 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();
+            ScriptController* controller = scriptController(eventContext);
+            if (controller)
+                controller->preprocessEval(this, 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::Value> argv[] = { eventDetails.GetEventData() };
             v8::Handle<v8::Value> value = V8ScriptRunner::callInternalFunction(getAfterCompileScript, debuggerScript, WTF_ARRAY_LENGTH(argv), argv, m_isolate);
             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);
@@ skipping 141 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