vm-service: Add optional 'scope' parameter to 'evaluate' and 'evaluateInFrame'.

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"
 
 #include "vm/compiler.h"
 #include "vm/cpu.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_api_state.h"
 #include "vm/dart_entry.h"
 #include "vm/debugger.h"
 #include "vm/isolate.h"
+#include "vm/kernel_isolate.h"
 #include "vm/lockers.h"
 #include "vm/malloc_hooks.h"
 #include "vm/message.h"
 #include "vm/message_handler.h"
+#include "vm/native_arguments.h"
 #include "vm/native_entry.h"
-#include "vm/native_arguments.h"
 #include "vm/native_symbol.h"
 #include "vm/object.h"
 #include "vm/object_graph.h"
 #include "vm/object_id_ring.h"
 #include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/port.h"
 #include "vm/profiler_service.h"
 #include "vm/reusable_handles.h"
 #include "vm/safepoint.h"
 #include "vm/service_event.h"
 #include "vm/service_isolate.h"
 #include "vm/source_report.h"
 #include "vm/stack_frame.h"
 #include "vm/symbols.h"
 #include "vm/timeline.h"
 #include "vm/type_table.h"
 #include "vm/unicode.h"
 #include "vm/version.h"
-#include "vm/kernel_isolate.h"
 
 namespace dart {
 
 #define Z (T->zone())
 
 
 DECLARE_FLAG(bool, trace_service);
 DECLARE_FLAG(bool, trace_service_pause_events);
 DECLARE_FLAG(bool, profile_vm);
 DEFINE_FLAG(charp,
@@ skipping 2160 matching lines @@
   result.PrintJSON(js, true);
   return true;
 }
 
 
 static const MethodParameter* evaluate_params[] = {
     RUNNABLE_ISOLATE_PARAMETER, NULL,
 };
 
 
+static bool IsAlpha(char c) {
+  return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z');
+}
+static bool IsAlphaNum(char c) {
+  return (c >= '0' && c <= '9') || IsAlpha(c);
+}
+static bool IsWhitespace(char c) {
+  return c <= ' ';

[siva, 2017/05/18 20:56:48]

should this also include tab?

[rmacnak, 2017/05/19 00:56:44]

This includes tab.

+}
+static bool IsObjectIdChar(char c) {
+  return IsAlphaNum(c) || c == '/' || c == '-' || c == '@' || c == '%';
+}
+
+
+// TODO(vm-service): Consider whether we should pass structured objects in
+// service messages instead of always flattening them to C strings.
+static bool ParseScope(const char* scope,
+                       const GrowableObjectArray& names,
+                       const GrowableObjectArray& values) {
+  const char* c = scope;
+  if (*c++ != '{') return false;
+
+  String& str = String::Handle();
+  for (;;) {
+    while (IsWhitespace(*c)) {
+      c++;
+    }
+
+    if (*c == '}') return true;
+
+    const char* name = c;
+    if (!IsAlpha(*c)) return false;
+    while (IsAlphaNum(*c)) {
+      c++;
+    }
+    str = String::FromUTF8(reinterpret_cast<const uint8_t*>(name), c - name);

[siva, 2017/05/18 20:56:48]

Is this really a UTF8 array or can you just use OneByteString::New(...) here or
maybe String::FromLatin1(...)

[rmacnak, 2017/05/19 00:56:44]

The input came from a String::ToCString(). But switched to keeping C strings as
suggested below.

+    names.Add(str);
+
+    while (IsWhitespace(*c)) {
+      c++;
+    }
+
+    if (*c++ != ':') return false;
+
+    while (IsWhitespace(*c)) {
+      c++;
+    }
+
+    const char* id = c;
+    if (!IsObjectIdChar(*c)) return false;
+    while (IsObjectIdChar(*c)) {
+      c++;
+    }
+    str = String::FromUTF8(reinterpret_cast<const uint8_t*>(id), c - id);

[siva, 2017/05/18 20:56:49]

Ditto comment here.

Also why do we need to create a GrowableObjectArray for the values here, convert
the C string to a Dart string and again convert it back to a C string when doing
the lookup? Why not just store a GrowableArray<const char*> here and create the
GrowableObjectArray in BuildScope after the lookup is done.

+    values.Add(str);
+
+    while (IsWhitespace(*c)) {
+      c++;
+    }
+    if (*c == ',') c++;
+  }
+
+  return false;
+}
+
+
+static bool BuildScope(Thread* thread,
+                       JSONStream* js,
+                       const GrowableObjectArray& names,
+                       const GrowableObjectArray& values) {
+  const char* scope = js->LookupParam("scope");
+  if (scope != NULL) {
+    if (!ParseScope(scope, names, values)) {
+      PrintInvalidParamError(js, "scope");
+      return true;
+    }
+    String& id = String::Handle();
+    Object& obj = Object::Handle();
+    for (intptr_t i = 0; i < values.Length(); i++) {
+      id ^= values.At(i);
+      ObjectIdRing::LookupResult lookup_result;
+      obj = LookupHeapObject(thread, id.ToCString(), &lookup_result);
+      if (obj.raw() == Object::sentinel().raw()) {
+        if (lookup_result == ObjectIdRing::kCollected) {
+          PrintSentinel(js, kCollectedSentinel);
+        } else if (lookup_result == ObjectIdRing::kExpired) {
+          PrintSentinel(js, kExpiredSentinel);
+        } else {
+          PrintInvalidParamError(js, "targetId");
+        }
+        return true;
+      }
+      if ((!obj.IsInstance() && !obj.IsNull()) || ContainsNonInstance(obj)) {
+        js->PrintError(kInvalidParams,
+                       "%s: invalid scope 'targetId' parameter: "
+                       "Cannot evaluate against a VM-internal object",
+                       js->method());
+        return true;
+      }
+      values.SetAt(i, obj);
+    }
+  }
+  return false;
+}
+
+
 static bool Evaluate(Thread* thread, JSONStream* js) {
   if (!thread->isolate()->compilation_allowed()) {
     js->PrintError(kFeatureDisabled,
                    "Cannot evaluate when running a precompiled program.");
     return true;
   }
   const char* target_id = js->LookupParam("targetId");
   if (target_id == NULL) {
     PrintMissingParamError(js, "targetId");
     return true;
   }
   const char* expr = js->LookupParam("expression");
   if (expr == NULL) {
     PrintMissingParamError(js, "expression");
     return true;
   }
+
   Zone* zone = thread->zone();
+  const GrowableObjectArray& names =
+      GrowableObjectArray::Handle(zone, GrowableObjectArray::New());
+  const GrowableObjectArray& values =
+      GrowableObjectArray::Handle(zone, GrowableObjectArray::New());
+  if (BuildScope(thread, js, names, values)) {
+    return true;
+  }
+  const Array& names_array = Array::Handle(zone, Array::MakeArray(names));
+  const Array& values_array = Array::Handle(zone, Array::MakeArray(values));
+
   const String& expr_str = String::Handle(zone, String::New(expr));
   ObjectIdRing::LookupResult lookup_result;
   Object& obj =
       Object::Handle(zone, LookupHeapObject(thread, target_id, &lookup_result));
   if (obj.raw() == Object::sentinel().raw()) {
     if (lookup_result == ObjectIdRing::kCollected) {
       PrintSentinel(js, kCollectedSentinel);
     } else if (lookup_result == ObjectIdRing::kExpired) {
       PrintSentinel(js, kExpiredSentinel);
     } else {
       PrintInvalidParamError(js, "targetId");
     }
     return true;
   }
   if (obj.IsLibrary()) {
     const Library& lib = Library::Cast(obj);
-    const Object& result = Object::Handle(
-        zone,
-        lib.Evaluate(expr_str, Array::empty_array(), Array::empty_array()));
+    const Object& result =
+        Object::Handle(zone, lib.Evaluate(expr_str, names_array, values_array));
     result.PrintJSON(js, true);
     return true;
   }
   if (obj.IsClass()) {
     const Class& cls = Class::Cast(obj);
-    const Object& result = Object::Handle(
-        zone,
-        cls.Evaluate(expr_str, Array::empty_array(), Array::empty_array()));
+    const Object& result =
+        Object::Handle(zone, cls.Evaluate(expr_str, names_array, values_array));
     result.PrintJSON(js, true);
     return true;
   }
   if ((obj.IsInstance() || obj.IsNull()) && !ContainsNonInstance(obj)) {
     // We don't use Instance::Cast here because it doesn't allow null.
     Instance& instance = Instance::Handle(zone);
     instance ^= obj.raw();
     const Class& receiver_cls = Class::Handle(zone, instance.clazz());
     const Object& result = Object::Handle(
-        zone, instance.Evaluate(receiver_cls, expr_str, Array::empty_array(),
-                                Array::empty_array()));
+        zone,
+        instance.Evaluate(receiver_cls, expr_str, names_array, values_array));
     result.PrintJSON(js, true);
     return true;
   }
   js->PrintError(kInvalidParams,
                  "%s: invalid 'targetId' parameter: "
                  "Cannot evaluate against a VM-internal object",
                  js->method());
   return true;
 }
 
@@ skipping 13 matching lines @@
   }
   DebuggerStackTrace* stack = isolate->debugger()->StackTrace();
   intptr_t framePos = UIntParameter::Parse(js->LookupParam("frameIndex"));
   if (framePos >= stack->Length()) {
     PrintInvalidParamError(js, "frameIndex");
     return true;
   }
   ActivationFrame* frame = stack->FrameAt(framePos);
 
   Zone* zone = thread->zone();
+  const GrowableObjectArray& names =
+      GrowableObjectArray::Handle(zone, GrowableObjectArray::New());
+  const GrowableObjectArray& values =
+      GrowableObjectArray::Handle(zone, GrowableObjectArray::New());
+  if (BuildScope(thread, js, names, values)) {
+    return true;
+  }
+
   const char* expr = js->LookupParam("expression");
   const String& expr_str = String::Handle(zone, String::New(expr));
 
-  const Object& result = Object::Handle(zone, frame->Evaluate(expr_str));
+  const Object& result =
+      Object::Handle(zone, frame->Evaluate(expr_str, names, values));
   result.PrintJSON(js, true);
   return true;
 }
 
 
 class GetInstancesVisitor : public ObjectGraph::Visitor {
  public:
   GetInstancesVisitor(const Class& cls, const Array& storage)
       : cls_(cls), storage_(storage), count_(0) {}
 
@@ skipping 596 matching lines @@
 }
 
 static const char* const timeline_streams_enum_names[] = {
     "all",
 #define DEFINE_NAME(name, unused) #name,
     TIMELINE_STREAM_LIST(DEFINE_NAME)
 #undef DEFINE_NAME
         NULL};
 
 static const MethodParameter* set_vm_timeline_flags_params[] = {
-    NO_ISOLATE_PARAMETER, new EnumListParameter("recordedStreams",
-                                                false,
-                                                timeline_streams_enum_names),
+    NO_ISOLATE_PARAMETER,
+    new EnumListParameter("recordedStreams",
+                          false,
+                          timeline_streams_enum_names),
     NULL,
 };
 
 
 static bool HasStream(const char** recorded_streams, const char* stream) {
   while (*recorded_streams != NULL) {
     if ((strstr(*recorded_streams, "all") != NULL) ||
         (strstr(*recorded_streams, stream) != NULL)) {
       return true;
     }
@@ skipping 657 matching lines @@
 
   void Append(FinalizablePersistentHandle* weak_persistent_handle) {
     if (!weak_persistent_handle->raw()->IsHeapObject()) {
       return;  // Free handle.
     }
 
     JSONObject obj(handles_);
     obj.AddProperty("type", "_WeakPersistentHandle");
     const Object& object = Object::Handle(weak_persistent_handle->raw());
     obj.AddProperty("object", object);
-    obj.AddPropertyF("peer", "0x%" Px "", reinterpret_cast<uintptr_t>(
-                                              weak_persistent_handle->peer()));
+    obj.AddPropertyF(
+        "peer", "0x%" Px "",
+        reinterpret_cast<uintptr_t>(weak_persistent_handle->peer()));
     obj.AddPropertyF(
         "callbackAddress", "0x%" Px "",
         reinterpret_cast<uintptr_t>(weak_persistent_handle->callback()));
     // Attempt to include a native symbol name.
     char* name = NativeSymbolResolver::LookupSymbolName(
         reinterpret_cast<uintptr_t>(weak_persistent_handle->callback()), NULL);
     obj.AddProperty("callbackSymbolName", (name == NULL) ? "" : name);
     if (name != NULL) {
       NativeSymbolResolver::FreeSymbolName(name);
     }
@@ skipping 580 matching lines @@
     if (strcmp(method_name, method.name) == 0) {
       return &method;
     }
   }
   return NULL;
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart