Replace Context::Scope with ScriptState::Scope

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 185 matching lines @@
     }
 
     v8::Handle<v8::Function> breakProgramFunction = m_breakProgramCallbackTemplate.newLocal(m_isolate)->GetFunction();
     v8::Debug::Call(breakProgramFunction);
 }
 
 void ScriptDebugServer::continueProgram()
 {
     if (isPaused())
         quitMessageLoopOnPause();
-    m_pausedContext.Clear();
+    m_pausedScriptState.clear();
     m_executionState.Clear();
 }
 
 void ScriptDebugServer::stepIntoStatement()
 {
     ASSERT(isPaused());
     ASSERT(!m_executionState.IsEmpty());
     v8::HandleScope handleScope(m_isolate);
     v8::Handle<v8::Value> argv[] = { m_executionState };
     callDebuggerMethod(stepIntoV8MethodName, 1, argv);
@@ skipping 113 matching lines @@
         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)
 {
-    v8::HandleScope scope(m_isolate);
-    v8::Handle<v8::Context> pausedContext = m_pausedContext.IsEmpty() ? m_isolate->GetCurrentContext() : m_pausedContext;
-    if (pausedContext.IsEmpty())
+    if (!m_isolate->InContext())
         return ScriptValue();
+    v8::HandleScope handleScope(m_isolate);
 
     RefPtr<JavaScriptCallFrame> currentCallFrame = wrapCallFrames(0, scopeDetails);
     if (!currentCallFrame)
         return ScriptValue();
 
-    v8::Context::Scope contextScope(pausedContext);
-    return ScriptValue(ScriptState::from(pausedContext), toV8(currentCallFrame.release(), pausedContext->Global(), pausedContext->GetIsolate()));
+    ScriptState* scriptState = m_pausedScriptState ? m_pausedScriptState.get() : ScriptState::current(m_isolate);
+    ScriptState::Scope scope(scriptState);
+    return ScriptValue(scriptState, toV8(currentCallFrame.release(), scriptState->context()->Global(), m_isolate));
 }
 
 ScriptValue ScriptDebugServer::currentCallFrames()
 {
     return currentCallFramesInner(AllScopes);
 }
 
 ScriptValue ScriptDebugServer::currentCallFramesForAsyncStack()
 {
     return currentCallFramesInner(FastAsyncScopes);
@@ 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>& info)
 {
     ASSERT(2 == info.Length());
     ScriptDebugServer* thisPtr = toScriptDebugServer(info.Data());
-    v8::Handle<v8::Context> pausedContext = thisPtr->m_isolate->GetCurrentContext();
+    ScriptState* pausedScriptState = ScriptState::current(thisPtr->m_isolate);
     v8::Handle<v8::Value> exception;
     v8::Handle<v8::Array> hitBreakpoints;
-    thisPtr->handleProgramBreak(pausedContext, v8::Handle<v8::Object>::Cast(info[0]), exception, hitBreakpoints);
+    thisPtr->handleProgramBreak(pausedScriptState, v8::Handle<v8::Object>::Cast(info[0]), exception, hitBreakpoints);
 }
 
-void ScriptDebugServer::handleProgramBreak(v8::Handle<v8::Context> pausedContext, v8::Handle<v8::Object> executionState, v8::Handle<v8::Value> exception, v8::Handle<v8::Array> hitBreakpointNumbers)
+void ScriptDebugServer::handleProgramBreak(ScriptState* pausedScriptState, v8::Handle<v8::Object> executionState, v8::Handle<v8::Value> exception, v8::Handle<v8::Array> hitBreakpointNumbers)
 {
     // Don't allow nested breaks.
     if (isPaused())
         return;
 
-    ScriptDebugListener* listener = getDebugListenerForContext(pausedContext);
+    ScriptDebugListener* listener = getDebugListenerForContext(pausedScriptState->context());
     if (!listener)
         return;
 
     Vector<String> breakpointIds;
     if (!hitBreakpointNumbers.IsEmpty()) {
         breakpointIds.resize(hitBreakpointNumbers->Length());
         for (size_t i = 0; i < hitBreakpointNumbers->Length(); i++) {
             v8::Handle<v8::Value> hitBreakpointNumber = hitBreakpointNumbers->Get(i);
             ASSERT(!hitBreakpointNumber.IsEmpty() && hitBreakpointNumber->IsInt32());
             breakpointIds[i] = String::number(hitBreakpointNumber->Int32Value());
         }
     }
 
-    m_pausedContext = pausedContext;
+    m_pausedScriptState = pausedScriptState;
     m_executionState = executionState;
-    ScriptState* scriptState = ScriptState::from(pausedContext);
-    ScriptDebugListener::SkipPauseRequest result = listener->didPause(scriptState, currentCallFrames(), ScriptValue(scriptState, exception), breakpointIds);
+    ScriptDebugListener::SkipPauseRequest result = listener->didPause(pausedScriptState, currentCallFrames(), ScriptValue(pausedScriptState, exception), breakpointIds);
     if (result == ScriptDebugListener::NoSkip) {
         m_runningNestedMessageLoop = true;
-        runMessageLoopOnPause(pausedContext);
+        runMessageLoopOnPause(pausedScriptState->context());
         m_runningNestedMessageLoop = false;
     }
-    m_pausedContext.Clear();
+    m_pausedScriptState.clear();
     m_executionState.Clear();
 
     if (result == ScriptDebugListener::StepInto) {
         v8::Handle<v8::Value> argv[] = { executionState };
         callDebuggerMethod(stepIntoV8MethodName, 1, argv);
     } else if (result == ScriptDebugListener::StepOut) {
         v8::Handle<v8::Value> argv[] = { executionState };
         callDebuggerMethod(stepOutV8MethodName, 1, argv);
     }
 }
@@ skipping 36 matching lines @@
             dispatchDidParseSource(listener, object);
         } else if (event == v8::Exception) {
             v8::Local<v8::StackTrace> stackTrace = v8::StackTrace::CurrentStackTrace(m_isolate, 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(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(eventContext, eventDetails.GetExecutionState(), exception, v8::Handle<v8::Array>());
+            handleProgramBreak(ScriptState::from(eventContext), eventDetails.GetExecutionState(), 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());
-            handleProgramBreak(eventContext, eventDetails.GetExecutionState(), v8::Handle<v8::Value>(), hitBreakpoints.As<v8::Array>());
+            handleProgramBreak(ScriptState::from(eventContext), eventDetails.GetExecutionState(), 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"));
     ASSERT(!id.IsEmpty() && id->IsInt32());
     String sourceID = String::number(id->Int32Value());
 
@@ skipping 52 matching lines @@
         v8::Handle<v8::Value>(v8::Integer::New(debuggerContext->GetIsolate(), scopeNumber)),
         v8String(debuggerContext->GetIsolate(), variableName),
         newValue
     };
     return callDebuggerMethod("setFunctionVariableValue", 4, argv);
 }
 
 
 bool ScriptDebugServer::isPaused()
 {
-    return !m_pausedContext.IsEmpty();
+    return m_pausedScriptState;
 }
 
 void ScriptDebugServer::compileScript(ScriptState* scriptState, const String& expression, const String& sourceURL, String* scriptId, String* exceptionMessage)
 {
     if (scriptState->contextIsEmpty())
         return;
     ScriptState::Scope scope(scriptState);
 
     v8::Handle<v8::String> source = v8String(m_isolate, expression);
     v8::TryCatch tryCatch;
@@ skipping 48 matching lines @@
 {
     return PassOwnPtr<ScriptSourceCode>();
 }
 
 String ScriptDebugServer::preprocessEventListener(LocalFrame*, const String& source, const String& url, const String& functionName)
 {
     return source;
 }
 
 } // namespace WebCore