blob: eefe991809c7d095da7a02935f91ed18f0858ea1 [file] [log] [blame]
// Copyright 2016 The Cobalt Authors. All Rights Reserved.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// See the License for the specific language governing permissions and
// limitations under the License.
#include <memory>
#include <set>
#include <string>
#include <vector>
#include "base/values.h"
#include "cobalt/script/call_frame.h"
#include "cobalt/script/source_provider.h"
namespace cobalt {
namespace script {
class GlobalEnvironment;
// Engine-independent pure virtual interface to a JavaScript debugger.
// Used as an opaque interface to the specific debugger implementation,
// e.g. JSCDebugger.
// Only pure virtual or static methods should be added to this class.
// No data members should be added to this class.
class ScriptDebugger {
// Ideally, we want the delegate to do as much as possible, as its
// implementation can be independent of the specific JS engine.
class Delegate {
// Called when the script debugger wants to pause script execution.
virtual void OnScriptDebuggerPause() = 0;
// Called when the script debugger wants to resume script execution, both
// after a pause and to start running after the devtools frontend connects.
virtual void OnScriptDebuggerResume() = 0;
// Called with the response to a previously dispatched protocol message.
virtual void OnScriptDebuggerResponse(const std::string& response) = 0;
// Called when a debugging protocol event occurs.
virtual void OnScriptDebuggerEvent(const std::string& event) = 0;
// Receives trace events from the JS engine in the JSON Trace Event Format.
class TraceDelegate {
virtual ~TraceDelegate() {}
virtual void AppendTraceEvent(const std::string& trace_event_json) = 0;
virtual void FlushTraceEvents() = 0;
// Possible pause on exceptions states.
enum PauseOnExceptionsState { kAll, kNone, kUncaught };
// Used to temporarily override the pause on exceptions state, e.g. to
// disable it when executing devtools backend scripts.
class ScopedPauseOnExceptionsState {
ScopedPauseOnExceptionsState(ScriptDebugger* script_debugger,
PauseOnExceptionsState state)
: script_debugger_(script_debugger) {
stored_state_ = script_debugger_->SetPauseOnExceptions(state);
~ScopedPauseOnExceptionsState() {
ScriptDebugger* script_debugger_;
PauseOnExceptionsState stored_state_;
// Factory method to create an engine-specific instance. Implementation to be
// provided by derived class.
static std::unique_ptr<ScriptDebugger> CreateDebugger(
GlobalEnvironment* global_environment, Delegate* delegate);
// Attach/detach the script debugger. Saved state can be passed between
// instances as an opaque string..
virtual void Attach(const std::string& state) = 0;
virtual std::string Detach() = 0;
// Evaluate JavaScript code that is part of the debugger implementation, such
// that it does not get reported as debuggable source. Returns true on
// success, false if there is an exception. If out_result_utf8 is non-NULL, it
// will be set to hold the result of the script evaluation if the script
// succeeds, or an exception message if it fails.
virtual bool EvaluateDebuggerScript(const std::string& js_code,
std::string* out_result_utf8) = 0;
// For engines like V8 that directly handle protocol commands.
virtual std::set<std::string> SupportedProtocolDomains() = 0;
virtual bool DispatchProtocolMessage(const std::string& method,
const std::string& message) = 0;
// Creates a JSON representation of an object.
virtual std::string CreateRemoteObject(const ValueHandleHolder& object,
const std::string& group) = 0;
// Lookup the object ID that was in the JSON from |CreateRemoteObject| and
// return the JavaScript object that it refers to.
virtual const script::ValueHandleHolder* LookupRemoteObjectId(
const std::string& object_id) = 0;
// For performance tracing of JavaScript methods.
virtual void StartTracing(const std::vector<std::string>& categories,
TraceDelegate* trace_delegate) = 0;
virtual void StopTracing() = 0;
virtual PauseOnExceptionsState SetPauseOnExceptions(
PauseOnExceptionsState state) = 0; // Returns the previous state.
// Record the JavaScript stack on the WebModule thread at the point a task is
// initiated that will run at a later time (on the same thread), allowing it
// to be seen as the originator when breaking in the asynchronous task.
virtual void AsyncTaskScheduled(const void* task, const std::string& name,
bool recurring) = 0;
// A scheduled task is starting to run.
virtual void AsyncTaskStarted(const void* task) = 0;
// A scheduled task has finished running.
virtual void AsyncTaskFinished(const void* task) = 0;
// A scheduled task will no longer be run, and resources associated with it
// may be released.
virtual void AsyncTaskCanceled(const void* task) = 0;
// All scheduled tasks will no longer be run, and resources associated with
// them may be released.
virtual void AllAsyncTasksCanceled() = 0;
virtual ~ScriptDebugger() {}
friend std::unique_ptr<ScriptDebugger>::deleter_type;
} // namespace script
} // namespace cobalt