blob: d02dbe285e216c34bdd400322584ac5532c44593 [file] [log] [blame]
// Copyright (c) 2015, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
#ifndef RUNTIME_VM_SERVICE_EVENT_H_
#define RUNTIME_VM_SERVICE_EVENT_H_
#include "vm/globals.h"
#include "vm/heap/heap.h"
namespace dart {
class ActivationFrame;
class Breakpoint;
class Instance;
class Isolate;
class Object;
class StreamInfo;
class String;
class TimelineEventBlock;
class ServiceEvent {
public:
enum EventKind {
kVMUpdate, // VM identity information has changed
kVMFlagUpdate, // VM flags updated
kIsolateStart, // New isolate has started
kIsolateRunnable, // Isolate is ready to run
kIsolateExit, // Isolate has exited
kIsolateUpdate, // Isolate identity information has changed
kIsolateReload, // Result of a reload request
kServiceExtensionAdded, // A service extension was registered
kPauseStart, // --pause-isolates-on-start
kPauseExit, // --pause-isolates-on-exit
kPauseBreakpoint,
kPauseInterrupted,
kPauseException,
kPausePostRequest, // isolate is paused after a service request.
kNone, // isolate has not been made runnable yet.
kResume,
kBreakpointAdded,
kBreakpointResolved,
kBreakpointRemoved,
kInspect,
kDebuggerSettingsUpdate,
kGC,
kEmbedder,
kLogging,
kExtension,
kTimelineEvents,
// Sent when SetVMTimelineFlags is called.
kTimelineStreamSubscriptionsUpdate,
kIllegal,
};
struct LogRecord {
int64_t sequence_number;
int64_t timestamp;
intptr_t level;
const String* name;
const String* message;
const Instance* zone;
const Object* error;
const Instance* stack_trace;
};
struct ExtensionEvent {
const String* event_kind;
const String* event_data;
};
ServiceEvent(Isolate* isolate, EventKind event_kind);
Isolate* isolate() const { return isolate_; }
// Used by the C embedding api.
Dart_Port isolate_id() const { return isolate_->main_port(); }
EventKind kind() const { return kind_; }
bool IsPause() const {
switch (kind()) {
case kPauseStart:
case kPauseExit:
case kPauseBreakpoint:
case kPauseInterrupted:
case kPauseException:
case kPausePostRequest:
return true;
default:
return false;
}
}
const char* flag_name() const { return flag_name_; }
void set_flag_name(const char* flag) { flag_name_ = flag; }
const char* flag_new_value() const { return flag_new_value_; }
void set_flag_new_value(const char* value) { flag_new_value_ = value; }
const char* embedder_kind() const { return embedder_kind_; }
const char* KindAsCString() const;
void set_embedder_kind(const char* embedder_kind) {
embedder_kind_ = embedder_kind;
}
const StreamInfo* stream_info() const;
const char* stream_id() const;
void set_embedder_stream_id(const char* stream_id) {
embedder_stream_id_ = stream_id;
}
Breakpoint* breakpoint() const { return breakpoint_; }
void set_breakpoint(Breakpoint* bpt) {
ASSERT(kind() == kPauseBreakpoint || kind() == kBreakpointAdded ||
kind() == kBreakpointResolved || kind() == kBreakpointRemoved);
breakpoint_ = bpt;
}
ActivationFrame* top_frame() const { return top_frame_; }
void set_top_frame(ActivationFrame* frame) {
ASSERT(kind() == kPauseBreakpoint || kind() == kPauseInterrupted ||
kind() == kPauseException || kind() == kPausePostRequest ||
kind() == kResume);
top_frame_ = frame;
}
const String* extension_rpc() const { return extension_rpc_; }
void set_extension_rpc(const String* extension_rpc) {
extension_rpc_ = extension_rpc;
}
const Object* exception() const { return exception_; }
void set_exception(const Object* exception) {
ASSERT(kind_ == kPauseException);
exception_ = exception;
}
const Error* reload_error() const {
ASSERT(kind_ == kIsolateReload);
return reload_error_;
}
void set_reload_error(const Error* error) {
ASSERT(kind_ == kIsolateReload);
reload_error_ = error;
}
bool at_async_jump() const { return at_async_jump_; }
void set_at_async_jump(bool value) { at_async_jump_ = value; }
const Object* inspectee() const { return inspectee_; }
void set_inspectee(const Object* inspectee) {
ASSERT(kind_ == kInspect);
inspectee_ = inspectee;
}
const Heap::GCStats* gc_stats() const { return gc_stats_; }
void set_gc_stats(const Heap::GCStats* gc_stats) { gc_stats_ = gc_stats; }
const uint8_t* bytes() const { return bytes_; }
intptr_t bytes_length() const { return bytes_length_; }
void set_bytes(const uint8_t* bytes, intptr_t bytes_length) {
bytes_ = bytes;
bytes_length_ = bytes_length;
}
void set_log_record(const LogRecord& log_record) { log_record_ = log_record; }
void set_extension_event(const ExtensionEvent& extension_event) {
extension_event_ = extension_event;
}
void UpdateTimestamp();
int64_t timestamp() const { return timestamp_; }
const TimelineEventBlock* timeline_event_block() const {
return timeline_event_block_;
}
void set_timeline_event_block(const TimelineEventBlock* block) {
ASSERT(kind() == kTimelineEvents);
timeline_event_block_ = block;
}
void PrintJSON(JSONStream* js) const;
void PrintJSONHeader(JSONObject* jsobj) const;
private:
Isolate* isolate_;
EventKind kind_;
const char* flag_name_;
const char* flag_new_value_;
const char* embedder_kind_;
const char* embedder_stream_id_;
Breakpoint* breakpoint_;
ActivationFrame* top_frame_;
const TimelineEventBlock* timeline_event_block_;
const String* extension_rpc_;
const Object* exception_;
const Error* reload_error_;
const String* spawn_token_;
const String* spawn_error_;
bool at_async_jump_;
const Object* inspectee_;
const Heap::GCStats* gc_stats_;
const uint8_t* bytes_;
intptr_t bytes_length_;
LogRecord log_record_;
ExtensionEvent extension_event_;
int64_t timestamp_;
};
} // namespace dart
#endif // RUNTIME_VM_SERVICE_EVENT_H_