VM: Service isolate under precompilation.

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 1007 matching lines @@
 
 
 static const MethodParameter* get_stack_params[] = {
   ISOLATE_PARAMETER,
   new BoolParameter("_full", false),
   NULL,
 };
 
 
 static bool GetStack(Thread* thread, JSONStream* js) {
+  if (!thread->isolate()->compilation_allowed()) {
+    js->PrintError(kFeatureDisabled,
+        "Cannot get stack when running a precompiled program.");
+    return true;
+  }
   Isolate* isolate = thread->isolate();
   DebuggerStackTrace* stack = isolate->debugger()->StackTrace();
   // Do we want the complete script object and complete local variable objects?
   // This is true for dump requests.
   const bool full = BoolParameter::Parse(js->LookupParam("_full"), false);
   JSONObject jsobj(js);
   jsobj.AddProperty("type", "Stack");
   {
     JSONArray jsarr(&jsobj, "frames");
 
@@ skipping 1006 matching lines @@
                                const Class& cls,
                                const Function& func) const {
     return func.raw() == func_.raw();
   }
  private:
   const Function& func_;
 };
 
 
 static bool GetHitsOrSites(Thread* thread, JSONStream* js, bool as_sites) {
+  if (!thread->isolate()->compilation_allowed()) {
+    js->PrintError(kFeatureDisabled,
+        "Cannot get coverage data when running a precompiled program.");
+    return true;
+  }
   if (!js->HasParam("targetId")) {
     CodeCoverage::PrintJSON(thread, js, NULL, as_sites);
     return true;
   }
   const char* target_id = js->LookupParam("targetId");
   Object& obj = Object::Handle(LookupHeapObject(thread, target_id, NULL));
   if (obj.raw() == Object::sentinel().raw()) {
     PrintInvalidParamError(js, "targetId");
     return true;
   }
@@ skipping 47 matching lines @@
 
 
 static bool GetCallSiteData(Thread* thread, JSONStream* js) {
   return GetHitsOrSites(thread, js, true);
 }
 
 
 static bool AddBreakpointCommon(Thread* thread,
                                 JSONStream* js,
                                 const String& script_uri) {
+  if (!thread->isolate()->compilation_allowed()) {
+    js->PrintError(kFeatureDisabled,
+        "Cannot use breakpoints when running a precompiled program.");
+    return true;
+  }
   const char* line_param = js->LookupParam("line");
   intptr_t line = UIntParameter::Parse(line_param);
   const char* col_param = js->LookupParam("column");
   intptr_t col = -1;
   if (col_param != NULL) {
     col = UIntParameter::Parse(col_param);
     if (col == 0) {
       // Column number is 1-based.
       PrintInvalidParamError(js, "column");
       return true;
@@ skipping 17 matching lines @@
 static const MethodParameter* add_breakpoint_params[] = {
   ISOLATE_PARAMETER,
   new IdParameter("scriptId", true),
   new UIntParameter("line", true),
   new UIntParameter("column", false),
   NULL,
 };
 
 
 static bool AddBreakpoint(Thread* thread, JSONStream* js) {
+  if (!thread->isolate()->compilation_allowed()) {
+    js->PrintError(kFeatureDisabled,
+        "Cannot use breakpoints when running a precompiled program.");
+    return true;
+  }
   const char* script_id_param = js->LookupParam("scriptId");
   Object& obj = Object::Handle(LookupHeapObject(thread, script_id_param, NULL));
   if (obj.raw() == Object::sentinel().raw() || !obj.IsScript()) {
     PrintInvalidParamError(js, "scriptId");
     return true;
   }
   const Script& script = Script::Cast(obj);
   const String& script_uri = String::Handle(script.url());
   ASSERT(!script_uri.IsNull());
   return AddBreakpointCommon(thread, js, script_uri);
 }
 
 
 static const MethodParameter* add_breakpoint_with_script_uri_params[] = {
   ISOLATE_PARAMETER,
   new IdParameter("scriptUri", true),
   new UIntParameter("line", true),
   new UIntParameter("column", false),
   NULL,
 };
 
 
 static bool AddBreakpointWithScriptUri(Thread* thread, JSONStream* js) {
+  if (!thread->isolate()->compilation_allowed()) {
+    js->PrintError(kFeatureDisabled,
+        "Cannot use breakpoints when running a precompiled program.");
+    return true;
+  }
   const char* script_uri_param = js->LookupParam("scriptUri");
   const String& script_uri = String::Handle(String::New(script_uri_param));
   return AddBreakpointCommon(thread, js, script_uri);
 }
 
 
 static const MethodParameter* add_breakpoint_at_entry_params[] = {
   ISOLATE_PARAMETER,
   new IdParameter("functionId", true),
   NULL,
 };
 
 
 static bool AddBreakpointAtEntry(Thread* thread, JSONStream* js) {
+  if (!thread->isolate()->compilation_allowed()) {
+    js->PrintError(kFeatureDisabled,
+        "Cannot use breakpoints when running a precompiled program.");
+    return true;
+  }
   const char* function_id = js->LookupParam("functionId");
   Object& obj = Object::Handle(LookupHeapObject(thread, function_id, NULL));
   if (obj.raw() == Object::sentinel().raw() || !obj.IsFunction()) {
     PrintInvalidParamError(js, "functionId");
     return true;
   }
   const Function& function = Function::Cast(obj);
   Breakpoint* bpt =
       thread->isolate()->debugger()->SetBreakpointAtEntry(function, false);
   if (bpt == NULL) {
     js->PrintError(kCannotAddBreakpoint,
                    "%s: Cannot add breakpoint at function '%s'",
                    js->method(), function.ToCString());
     return true;
   }
   bpt->PrintJSON(js);
   return true;
 }
 
 
 static const MethodParameter* add_breakpoint_at_activation_params[] = {
   ISOLATE_PARAMETER,
   new IdParameter("objectId", true),
   NULL,
 };
 
 
 static bool AddBreakpointAtActivation(Thread* thread, JSONStream* js) {
+  if (!thread->isolate()->compilation_allowed()) {
+    js->PrintError(kFeatureDisabled,
+        "Cannot use breakpoints when running a precompiled program.");
+    return true;
+  }
   const char* object_id = js->LookupParam("objectId");
   Object& obj = Object::Handle(LookupHeapObject(thread, object_id, NULL));
   if (obj.raw() == Object::sentinel().raw() || !obj.IsInstance()) {
     PrintInvalidParamError(js, "objectId");
     return true;
   }
   const Instance& closure = Instance::Cast(obj);
   Breakpoint* bpt =
       thread->isolate()->debugger()->SetBreakpointAtActivation(closure);
   if (bpt == NULL) {
     js->PrintError(kCannotAddBreakpoint,
                    "%s: Cannot add breakpoint at activation",
                    js->method());
     return true;
   }
   bpt->PrintJSON(js);
   return true;
 }
 
 
 static const MethodParameter* remove_breakpoint_params[] = {
   ISOLATE_PARAMETER,
   NULL,
 };
 
 
 static bool RemoveBreakpoint(Thread* thread, JSONStream* js) {
+  if (!thread->isolate()->compilation_allowed()) {
+    js->PrintError(kFeatureDisabled,
+        "Cannot use breakpoints when running a precompiled program.");
+    return true;
+  }
   if (!js->HasParam("breakpointId")) {
     PrintMissingParamError(js, "breakpointId");
     return true;
   }
   const char* bpt_id = js->LookupParam("breakpointId");
   ObjectIdRing::LookupResult lookup_result;
   Isolate* isolate = thread->isolate();
   Breakpoint* bpt = LookupBreakpoint(isolate, bpt_id, &lookup_result);
   // TODO(turnidge): Should we return a different error for bpts whic
   // have been already removed?
@@ skipping 984 matching lines @@
 
 static const MethodParameter* set_trace_class_allocation_params[] = {
   ISOLATE_PARAMETER,
   new IdParameter("classId", true),
   new BoolParameter("enable", true),
   NULL,
 };
 
 
 static bool SetTraceClassAllocation(Thread* thread, JSONStream* js) {
+  if (!thread->isolate()->compilation_allowed()) {
+    js->PrintError(kFeatureDisabled,
+        "Cannot trace allocation when running a precompiled program.");
+    return true;
+  }
   const char* class_id = js->LookupParam("classId");
   const bool enable = BoolParameter::Parse(js->LookupParam("enable"));
   intptr_t cid = -1;
   GetPrefixedIntegerId(class_id, "classes/", &cid);
   Isolate* isolate = thread->isolate();
   if (!IsValidClassId(isolate, cid)) {
     PrintInvalidParamError(js, "classId");
     return true;
   }
   const Class& cls = Class::Handle(GetClassForId(isolate, cid));
@@ skipping 110 matching lines @@
     ServiceMethodDescriptor& method = service_methods_[i];
     if (strcmp(method_name, method.name) == 0) {
       return &method;
     }
   }
   return NULL;
 }
 
 
 }  // namespace dart