Devtools: Move runMessageLoopOnPause and other methods on ScriptDebugServer::Client

Source/bindings/core/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 62 matching lines @@
 };
 
 v8::MaybeLocal<v8::Value> ScriptDebugServer::callDebuggerMethod(const char* functionName, int argc, v8::Local<v8::Value> argv[])
 {
     v8::Local<v8::Object> debuggerScript = debuggerScriptLocal();
     v8::Local<v8::Function> function = v8::Local<v8::Function>::Cast(debuggerScript->Get(v8InternalizedString(functionName)));
     ASSERT(m_isolate->InContext());
     return V8ScriptRunner::callInternalFunction(function, debuggerScript, argc, argv, m_isolate);
 }
 
-ScriptDebugServer::ScriptDebugServer(v8::Isolate* isolate, PassOwnPtr<Client> client)
+ScriptDebugServer::ScriptDebugServer(v8::Isolate* isolate, Client* client)
     : m_isolate(isolate)
     , m_client(client)
     , m_breakpointsActivated(true)
     , m_runningNestedMessageLoop(false)
     , m_taskQueue(adoptPtr(new ThreadSafeTaskQueue))
 {
 }
 
 ScriptDebugServer::~ScriptDebugServer()
 {
@@ skipping 172 matching lines @@
         m_breakProgramCallbackTemplate.Reset(m_isolate, templ);
     }
 
     v8::Local<v8::Function> breakProgramFunction = v8::Local<v8::FunctionTemplate>::New(m_isolate, m_breakProgramCallbackTemplate)->GetFunction();
     v8::Debug::Call(breakProgramFunction);
 }
 
 void ScriptDebugServer::continueProgram()
 {
     if (isPaused())
-        quitMessageLoopOnPause();
+        m_client->quitMessageLoopOnPause();
     m_pausedScriptState.clear();
     m_executionState.Clear();
 }
 
 void ScriptDebugServer::stepIntoStatement()
 {
     ASSERT(isPaused());
     ASSERT(!m_executionState.IsEmpty());
     v8::HandleScope handleScope(m_isolate);
     v8::Local<v8::Value> argv[] = { m_executionState };
@@ skipping 228 matching lines @@
     v8::Local<v8::Array> hitBreakpoints;
     thisPtr->handleProgramBreak(pausedScriptState, v8::Local<v8::Object>::Cast(info[0]), exception, hitBreakpoints);
 }
 
 void ScriptDebugServer::handleProgramBreak(ScriptState* pausedScriptState, v8::Local<v8::Object> executionState, v8::Local<v8::Value> exception, v8::Local<v8::Array> hitBreakpointNumbers, bool isPromiseRejection)
 {
     // Don't allow nested breaks.
     if (m_runningNestedMessageLoop)
         return;
 
-    ScriptDebugListener* listener = getDebugListenerForContext(pausedScriptState->context());
+    ScriptDebugListener* listener = m_client->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::Local<v8::Value> hitBreakpointNumber = hitBreakpointNumbers->Get(i);
             ASSERT(!hitBreakpointNumber.IsEmpty() && hitBreakpointNumber->IsInt32());
             breakpointIds[i] = String::number(hitBreakpointNumber->Int32Value());
         }
     }
 
     m_pausedScriptState = pausedScriptState;
     m_executionState = executionState;
     ScriptDebugListener::SkipPauseRequest result = listener->didPause(pausedScriptState, currentCallFrames(), ScriptValue(pausedScriptState, exception), breakpointIds, isPromiseRejection);
     if (result == ScriptDebugListener::NoSkip) {
         m_runningNestedMessageLoop = true;
-        runMessageLoopOnPause(pausedScriptState->context());
+        m_client->runMessageLoopOnPause(pausedScriptState->context());
         m_runningNestedMessageLoop = false;
     }
     m_pausedScriptState.clear();
     m_executionState.Clear();
 
     if (result == ScriptDebugListener::StepFrame) {
         v8::Local<v8::Value> argv[] = { executionState };
         callDebuggerMethod("stepFrameStatement", 1, argv);
     } else if (result == ScriptDebugListener::StepInto) {
         v8::Local<v8::Value> argv[] = { executionState };
@@ skipping 27 matching lines @@
 {
     if (!enabled())
         return;
     v8::DebugEvent event = eventDetails.GetEvent();
     if (event != v8::AsyncTaskEvent && event != v8::Break && event != v8::Exception && event != v8::AfterCompile && event != v8::BeforeCompile && event != v8::CompileError && event != v8::PromiseEvent)
         return;
 
     v8::Local<v8::Context> eventContext = eventDetails.GetEventContext();
     ASSERT(!eventContext.IsEmpty());
 
-    ScriptDebugListener* listener = getDebugListenerForContext(eventContext);
+    ScriptDebugListener* listener = m_client->getDebugListenerForContext(eventContext);
     if (listener) {
         v8::HandleScope scope(m_isolate);
         if (event == v8::AfterCompile || event == v8::CompileError) {
             v8::Context::Scope contextScope(debuggerContext());
             v8::Local<v8::Value> argv[] = { eventDetails.GetEventData() };
             v8::Local<v8::Value> value = callDebuggerMethod("getAfterCompileScript", 1, argv).ToLocalChecked();
             ASSERT(value->IsObject());
             v8::Local<v8::Object> object = v8::Local<v8::Object>::Cast(value);
             dispatchDidParseSource(listener, object, event != v8::AfterCompile ? CompileError : CompileSuccess);
         } else if (event == v8::Exception) {
@@ skipping 155 matching lines @@
     return callDebuggerMethod("setFunctionVariableValue", 4, argv);
 }
 
 
 bool ScriptDebugServer::isPaused()
 {
     return m_pausedScriptState;
 }
 
 } // namespace blink