Merge DevTools Refactor CL to Blink36

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 12 matching lines @@
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (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/dart/DartDebugServer.h"
+#include "bindings/common/StackTrace.h"
+#include "bindings/dart/DartScriptDebugServer.h"
 #include "bindings/v8/ScopedPersistent.h"
+#include "bindings/v8/ScriptCallStackFactory.h"
 #include "bindings/v8/ScriptController.h"
 #include "bindings/v8/ScriptObject.h"
 #include "bindings/v8/ScriptSourceCode.h"
 #include "bindings/v8/V8Binding.h"
 #include "bindings/v8/V8ScriptRunner.h"
 #include "core/inspector/JavaScriptCallFrame.h"
+#include "core/inspector/ScriptCallFrame.h"
 #include "core/inspector/ScriptDebugListener.h"
 #include "platform/JSONValues.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/Vector.h"
 #include "wtf/dtoa/utils.h"
 #include "wtf/text/CString.h"
 
 namespace WebCore {
 
 namespace {
@@ skipping 111 matching lines @@
 
     v8::Handle<v8::Value> argv[] = { v8::Int32::New(m_isolate, pauseOnExceptionsState) };
     callDebuggerMethod("setPauseOnExceptionsState", 1, argv);
 }
 
 void ScriptDebugServer::setPauseOnNextStatement(bool pause)
 {
     if (isPaused())
         return;
     if (pause) {
-        DartDebugServer::shared().debugBreak();
         v8::Debug::DebugBreak(m_isolate);
     } else {
-        DartDebugServer::shared().cancelDebugBreak();
         v8::Debug::CancelDebugBreak(m_isolate);
     }
 }
 
 bool ScriptDebugServer::canBreakProgram()
 {
     if (!m_breakpointsActivated)
         return false;
     v8::HandleScope scope(m_isolate);
     return !m_isolate->GetCurrentContext().IsEmpty();
@@ skipping 47 matching lines @@
 
     v8::Handle<v8::Value> argv[] = {
         m_executionState.newLocal(m_isolate),
         callFrame
     };
 
     callDebuggerMethod(functionName, 2, argv);
     continueProgram();
 }
 
-void ScriptDebugServer::stepOverStatement(const ScriptValue& frame)
+void ScriptDebugServer::stepOverStatement(const ActivationFrame& frame)
 {
-    stepCommandWithFrame("stepOverStatement", frame);
+    ASSERT(frame.isJavaScript());
+    stepCommandWithFrame("stepOverStatement", frame.asJavaScript());
 }
 
-void ScriptDebugServer::stepOutOfFunction(const ScriptValue& frame)
+void ScriptDebugServer::stepOutOfFunction(const ActivationFrame& frame)
 {
-    stepCommandWithFrame(stepOutV8MethodName, frame);
+    ASSERT(frame.isJavaScript());
+    stepCommandWithFrame(stepOutV8MethodName, frame.asJavaScript());
 }
 
-bool ScriptDebugServer::setScriptSource(const String& sourceID, const String& newContent, bool preview, String* error, RefPtr<TypeBuilder::Debugger::SetScriptSourceError>& errorData, ScriptValue* newCallFrames, RefPtr<JSONObject>* result)
+bool ScriptDebugServer::setScriptSource(const String& sourceID, const String& newContent, bool preview, String* error, RefPtr<TypeBuilder::Debugger::SetScriptSourceError>& errorData, StackTrace* newCallFrames, RefPtr<JSONObject>& result)
 {
     class EnableLiveEditScope {
     public:
         explicit EnableLiveEditScope(v8::Isolate* isolate) : m_isolate(isolate) { v8::Debug::SetLiveEditEnabled(m_isolate, true); }
         ~EnableLiveEditScope() { v8::Debug::SetLiveEditEnabled(m_isolate, false); }
     private:
         v8::Isolate* m_isolate;
     };
 
     ensureDebuggerScriptCompiled();
@@ skipping 23 matching lines @@
     }
     ASSERT(!v8result.IsEmpty());
     v8::Local<v8::Object> resultTuple = v8result->ToObject();
     int code = static_cast<int>(resultTuple->Get(0)->ToInteger()->Value());
     switch (code) {
     case 0:
         {
             v8::Local<v8::Value> normalResult = resultTuple->Get(1);
             RefPtr<JSONValue> jsonResult = v8ToJSONValue(m_isolate, normalResult, JSONValue::maxDepth);
             if (jsonResult)
-                *result = jsonResult->asObject();
+                result = jsonResult->asObject();
             // Call stack may have changed after if the edited function was on the stack.
             if (!preview && isPaused())
                 *newCallFrames = currentCallFrames();
             return true;
         }
     // Compile error.
     case 1:
         {
             RefPtr<TypeBuilder::Debugger::SetScriptSourceError::CompileError> compileError =
                 TypeBuilder::Debugger::SetScriptSourceError::CompileError::create()
@@ skipping 24 matching lines @@
     } else {
         v8::Handle<v8::Value> argv[] = { executionState, v8::Integer::New(m_isolate, data) };
         currentCallFrameV8 = callDebuggerMethod("currentCallFrame", WTF_ARRAY_LENGTH(argv), argv);
     }
     ASSERT(!currentCallFrameV8.IsEmpty());
     if (!currentCallFrameV8->IsObject())
         return PassRefPtr<JavaScriptCallFrame>();
     return JavaScriptCallFrame::create(v8::Debug::GetDebugContext(), v8::Handle<v8::Object>::Cast(currentCallFrameV8));
 }
 
-ScriptValue ScriptDebugServer::currentCallFramesInner(ScopeInfoDetails scopeDetails)
+StackTrace ScriptDebugServer::currentCallFramesInner(ScopeInfoDetails scopeDetails)
 {
     v8::HandleScope scope(m_isolate);
     v8::Handle<v8::Context> pausedContext = m_pausedContext.IsEmpty() ? m_isolate->GetCurrentContext() : m_pausedContext;
     if (pausedContext.IsEmpty())
-        return ScriptValue();
+        return StackTrace(ScriptValue());
 
     RefPtr<JavaScriptCallFrame> currentCallFrame = wrapCallFrames(m_executionState.newLocal(m_isolate), 0, scopeDetails);
     if (!currentCallFrame)
-        return ScriptValue();
+        return StackTrace(ScriptValue());
 
     v8::Context::Scope contextScope(pausedContext);
-    return ScriptValue(V8ScriptState::from(pausedContext), toV8(currentCallFrame.release(), v8::Handle<v8::Object>(), pausedContext->GetIsolate()));
+    return StackTrace(ScriptValue(V8ScriptState::from(pausedContext), toV8(currentCallFrame.release(), v8::Handle<v8::Object>(), pausedContext->GetIsolate())));
 }
 
-ScriptValue ScriptDebugServer::currentCallFrames()
+StackTrace ScriptDebugServer::currentCallFrames()
 {
     return currentCallFramesInner(AllScopes);
 }
 
-ScriptValue ScriptDebugServer::currentCallFramesForAsyncStack()
+StackTrace ScriptDebugServer::currentCallFramesForAsyncStack()
 {
     return currentCallFramesInner(FastAsyncScopes);
 }
 
 void ScriptDebugServer::interruptAndRun(PassOwnPtr<Task> task, v8::Isolate* isolate)
 {
     v8::Debug::DebugBreakForCommand(isolate, new ClientDataImpl(task));
 }
 
 void ScriptDebugServer::runPendingTasks()
@@ skipping 111 matching lines @@
             if (!stackTrace->GetFrameCount()) {
                 // FIXME: we would prefer to remove the outer check for whether
                 // the V8 stack trace is empty and instead just perform the
                 // following check which works correctly for both V8 and Dart.
                 v8::Handle<v8::Value> argv[] = { eventDetails.GetExecutionState() };
                 v8::Handle<v8::Value> currentCallFrame = callDebuggerMethod("currentCallFrame", 1, argv);
                 ASSERT(!currentCallFrame.IsEmpty());
                 if (!currentCallFrame->IsObject())
                     return;
             }
-            RefPtr<JavaScriptCallFrame> topFrame = wrapCallFrames(eventDetails.GetExecutionState(), 1, NoScopes);
-            if (executeSkipPauseRequest(listener->shouldSkipExceptionPause(topFrame), eventDetails.GetExecutionState()))
+
+            if (stackTrace->GetFrameCount() && executeSkipPauseRequest(listener->shouldSkipExceptionPause(toScriptCallFrame(stackTrace->GetFrame(0))), eventDetails.GetExecutionState()))
                 return;
             v8::Handle<v8::Object> eventData = eventDetails.GetEventData();
             v8::Handle<v8::Value> exceptionGetterValue = eventData->Get(v8AtomicString(m_isolate, "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(v8AtomicString(m_isolate, "getBreakpointNumbers")));
             v8::Handle<v8::Value> argv[] = { eventDetails.GetEventData() };
             v8::Handle<v8::Value> hitBreakpoints = V8ScriptRunner::callInternalFunction(getBreakpointNumbersFunction, debuggerScript, WTF_ARRAY_LENGTH(argv), argv, m_isolate);
             ASSERT(hitBreakpoints->IsArray());
-            RefPtr<JavaScriptCallFrame> topFrame = wrapCallFrames(eventDetails.GetExecutionState(), 1, NoScopes);
+            v8::Local<v8::StackTrace> stackTrace = v8::StackTrace::CurrentStackTrace(m_isolate, 1);
+            ScriptCallFrame topCallFrame = toScriptCallFrame(stackTrace->GetFrame(0));
+
             ScriptDebugListener::SkipPauseRequest skipRequest;
             if (v8::Handle<v8::Array>::Cast(hitBreakpoints)->Length())
-                skipRequest = listener->shouldSkipBreakpointPause(topFrame);
+                skipRequest = listener->shouldSkipBreakpointPause(topCallFrame);
             else
-                skipRequest = listener->shouldSkipStepPause(topFrame);
+                skipRequest = listener->shouldSkipStepPause(topCallFrame);
             if (executeSkipPauseRequest(skipRequest, eventDetails.GetExecutionState()))
                 return;
             handleProgramBreak(eventDetails, v8::Handle<v8::Value>(), hitBreakpoints.As<v8::Array>());
         }
     }
 }
 
 void ScriptDebugServer::dispatchDidParseSource(ScriptDebugListener* listener, v8::Handle<v8::Object> object)
 {
     v8::Handle<v8::Value> id = object->Get(v8AtomicString(m_isolate, "id"));
@@ skipping 130 matching lines @@
 {
     return PassOwnPtr<ScriptSourceCode>();
 }
 
 String ScriptDebugServer::preprocessEventListener(LocalFrame*, const String& source, const String& url, const String& functionName)
 {
     return source;
 }
 
 } // namespace WebCore