Timeline service protocol support with Observatory UI

runtime/vm/service.cc

 // Copyright (c) 2013, 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.
 
 #include "vm/service.h"
 
 #include "include/dart_api.h"
 #include "include/dart_native_api.h"
 #include "platform/globals.h"
 
@@ skipping 2474 matching lines @@
 
 static bool GetVMMetric(Thread* thread, JSONStream* js) {
   const char* metric_id = js->LookupParam("metricId");
   if (metric_id == NULL) {
     PrintMissingParamError(js, "metricId");
   }
   return false;
 }
 
 
+static const MethodParameter* set_vm_timeline_flag_params[] = {
+  NO_ISOLATE_PARAMETER,
+  new MethodParameter("_record", true),
+  NULL,
+};
+
+
+static bool SetVMTimelineFlag(Thread* thread, JSONStream* js) {
+  Isolate* isolate = thread->isolate();
+  ASSERT(isolate != NULL);
+  StackZone zone(thread);
+
+  bool recording = strcmp(js->LookupParam("_record"), "all") == 0;
+  Timeline::SetStreamAPIEnabled(recording);
+  Timeline::SetStreamCompilerEnabled(recording);
+  Timeline::SetStreamDartEnabled(recording);
+  Timeline::SetStreamDebuggerEnabled(recording);
+  Timeline::SetStreamEmbedderEnabled(recording);
+  Timeline::SetStreamGCEnabled(recording);
+  Timeline::SetStreamIsolateEnabled(recording);
+
+  PrintSuccess(js);
+
+  return true;
+}
+
+
+static const MethodParameter* get_vm_timeline_flag_params[] = {
+  NO_ISOLATE_PARAMETER,
+  new MethodParameter("_record", false),
+  NULL,
+};
+
+
+static bool GetVMTimelineFlag(Thread* thread, JSONStream* js) {
+  Isolate* isolate = thread->isolate();
+  ASSERT(isolate != NULL);
+  StackZone zone(thread);
+
+  js->PrintError(kFeatureDisabled, "TODO(johnmccutchan)");
+  return true;
+}
+
+
+static const MethodParameter* clear_vm_timeline_params[] = {
+  NO_ISOLATE_PARAMETER,
+  NULL,
+};
+
+
+static bool ClearVMTimeline(Thread* thread, JSONStream* js) {
+  Isolate* isolate = thread->isolate();
+  ASSERT(isolate != NULL);
+  StackZone zone(thread);
+
+  Timeline::Clear();
+
+  PrintSuccess(js);
+
+  return true;
+}
+
+
+static const MethodParameter* get_vm_timeline_params[] = {
+  NO_ISOLATE_PARAMETER,
+  NULL,
+};
+
+
+static bool GetVMTimeline(Thread* thread, JSONStream* js) {
+  Isolate* isolate = thread->isolate();
+  ASSERT(isolate != NULL);
+  StackZone zone(thread);
+  Timeline::ReclaimCachedBlocksFromThreads();
+  TimelineEventRecorder* timeline_recorder = Timeline::recorder();
+  // TODO(johnmccutchan): Return an error.
+  ASSERT(timeline_recorder != NULL);
+  TimelineEventFilter filter;
+  timeline_recorder->PrintJSON(js, &filter);
+
+  return true;
+}
+
+
 static const MethodParameter* resume_params[] = {
   ISOLATE_PARAMETER,
   NULL,
 };
 
 
 static bool Resume(Thread* thread, JSONStream* js) {
   const char* step_param = js->LookupParam("step");
   Isolate* isolate = thread->isolate();
   if (isolate->message_handler()->paused_on_start()) {
@@ skipping 821 matching lines @@
   { "addBreakpoint", AddBreakpoint,
     add_breakpoint_params },
   { "addBreakpointWithScriptUri", AddBreakpointWithScriptUri,
     add_breakpoint_with_script_uri_params },
   { "addBreakpointAtEntry", AddBreakpointAtEntry,
     add_breakpoint_at_entry_params },
   { "_addBreakpointAtActivation", AddBreakpointAtActivation,
     add_breakpoint_at_activation_params },
   { "_clearCpuProfile", ClearCpuProfile,
     clear_cpu_profile_params },
+  { "_clearVMTimeline", ClearVMTimeline,
+    clear_vm_timeline_params, },
   { "evaluate", Evaluate,
     evaluate_params },
   { "evaluateInFrame", EvaluateInFrame,
     evaluate_in_frame_params },
   { "_getAllocationProfile", GetAllocationProfile,
     get_allocation_profile_params },
   { "_getAllocationSamples", GetAllocationSamples,
       get_allocation_samples_params },
   { "_getCallSiteData", GetCallSiteData,
     get_call_site_data_params },
@@ skipping 34 matching lines @@
   { "_getTypeArgumentsList", GetTypeArgumentsList,
     get_type_arguments_list_params },
   { "getVersion", GetVersion,
     get_version_params },
   { "getVM", GetVM,
     get_vm_params },
   { "_getVMMetric", GetVMMetric,
     get_vm_metric_params },
   { "_getVMMetricList", GetVMMetricList,
     get_vm_metric_list_params },
+  { "_getVMTimeline", GetVMTimeline,
+    get_vm_timeline_params },
+  { "_getVMTimelineFlag", GetVMTimelineFlag,
+    get_vm_timeline_flag_params },
   { "pause", Pause,
     pause_params },
   { "removeBreakpoint", RemoveBreakpoint,
     remove_breakpoint_params },
   { "_restartVM", RestartVM,
     restart_vm_params },
   { "resume", Resume,
     resume_params },
   { "_requestHeapSnapshot", RequestHeapSnapshot,
     request_heap_snapshot_params },
   { "setExceptionPauseMode", SetExceptionPauseMode,
     set_exception_pause_mode_params },
   { "_setFlag", SetFlag,
     set_flags_params },
   { "setLibraryDebuggable", SetLibraryDebuggable,
     set_library_debuggable_params },
   { "setName", SetName,
     set_name_params },
   { "_setTraceClassAllocation", SetTraceClassAllocation,
     set_trace_class_allocation_params },
   { "setVMName", SetVMName,
     set_vm_name_params },
+  { "_setVMTimelineFlag", SetVMTimelineFlag,
+    set_vm_timeline_flag_params },
 };
 
 
 ServiceMethodDescriptor* FindMethod(const char* method_name) {
   intptr_t num_methods = sizeof(service_methods_) /
                          sizeof(service_methods_[0]);
   for (intptr_t i = 0; i < num_methods; i++) {
     ServiceMethodDescriptor& method = service_methods_[i];
     if (strcmp(method_name, method.name) == 0) {
       return &method;
     }
   }
   return NULL;
 }
 
 
 }  // namespace dart