Introduce remote objects in Debugger protocol

runtime/vm/debugger_api_impl.cc

 // Copyright (c) 2012, 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 "include/dart_debugger_api.h"
 
 #include "vm/dart_api_impl.h"
 #include "vm/dart_api_state.h"
 #include "vm/debugger.h"
 #include "vm/isolate.h"
@@ skipping 25 matching lines @@
   type* var = reinterpret_cast<type*>(param);
 
 
 #define CHECK_NOT_NULL(param)                                                 \
   if (param == NULL) {                                                        \
     return Api::NewError("%s expects argument '%s' to be non-null.",          \
                          CURRENT_FUNC, #param);                               \
   }
 
 
+DART_EXPORT intptr_t Dart_CacheObject(Dart_Handle object_in) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  const Object& obj = Object::Handle(Api::UnwrapHandle(object_in));
+  if (obj.IsApiError()) {
+    return -1;

[siva, 2012/05/22 01:49:09]

Since this is part of the API it might be better to have a named constant for
-1.

[hausner, 2012/05/22 18:03:57]

I'd rather solve this by documenting that -1 is an error value, similar to file
handles in Unix/Posix.

+  }
+  return isolate->debugger()->CacheObject(obj);
+}
+
+
+DART_EXPORT Dart_Handle Dart_GetCachedObject(intptr_t obj_id) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  if (!isolate->debugger()->IsValidObjectId(obj_id)) {
+    return Api::NewError("%s: object id %d is invalid", CURRENT_FUNC, obj_id);
+  }
+  return Api::NewHandle(isolate, isolate->debugger()->GetCachedObject(obj_id));
+}
+
+
 DART_EXPORT Dart_Handle Dart_StackTraceLength(
                             Dart_StackTrace trace,
                             intptr_t* length) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   CHECK_NOT_NULL(length);
   CHECK_AND_CAST(DebuggerStackTrace, stack_trace, trace);
   *length = stack_trace->Length();
   return Api::True(isolate);
 }
@@ skipping 301 matching lines @@
 
 DART_EXPORT Dart_Handle Dart_GetObjClass(Dart_Handle object_in) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   Instance& obj = Instance::Handle();
   UNWRAP_AND_CHECK_PARAM(Instance, obj, object_in);
   return Api::NewHandle(isolate, obj.clazz());
 }
 
 
+DART_EXPORT Dart_Handle Dart_GetObjClassId(Dart_Handle object_in,
+                                           intptr_t* class_id) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  Instance& obj = Instance::Handle();
+  UNWRAP_AND_CHECK_PARAM(Instance, obj, object_in);

[siva, 2012/05/22 01:49:09]

  if (class_id == NULL) {
    return Api::NewError("%s expects argument 'class_id' to be non-null.",
                         CURRENT_FUNC);
  }
  *class_id = Class::Handle(....);

[hausner, 2012/05/22 18:03:57]

It's kind of non-sensical to call this function with a NULL class_id, but is it
an error? Done. 

+  if (class_id != NULL) {
+    *class_id = Class::Handle(obj.clazz()).index();
+  }
+  return Api::True(isolate);
+}
+
+
 DART_EXPORT Dart_Handle Dart_GetSuperclass(Dart_Handle cls_in) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   Class& cls = Class::Handle();
   UNWRAP_AND_CHECK_PARAM(Class, cls, cls_in);
   return Api::NewHandle(isolate, cls.SuperClass());
 }
 
 
+DART_EXPORT Dart_Handle Dart_GetClassInfo(
+                            intptr_t cls_id,
+                            Dart_Handle* class_name,
+                            Dart_Handle* library,
+                            intptr_t* super_class_id,
+                            Dart_Handle* static_fields) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  if (!isolate->class_table()->IsValidIndex(cls_id)) {
+    return Api::NewError("%s: %d is not a valid class id",
+                         CURRENT_FUNC, cls_id);
+  }
+  Class& cls = Class::Handle(isolate->class_table()->At(cls_id));
+  if (class_name != NULL) {
+    *class_name = Api::NewHandle(isolate, cls.Name());
+  }
+  if (library != NULL) {
+    *library = Api::NewHandle(isolate, cls.library());
+  }
+  if (super_class_id != NULL) {
+    *super_class_id = 0;
+    cls = cls.SuperClass();
+    if (!cls.IsNull()) {
+      *super_class_id = cls.index();
+    }
+  }
+  if (static_fields != NULL) {
+    *static_fields =
+        Api::NewHandle(isolate, isolate->debugger()->GetStaticFields(cls));
+  }

[siva, 2012/05/22 01:49:09]

Ditto Api::NewError return values here for NULL pointer values....

[hausner, 2012/05/22 18:03:57]

Not in this case. I want the caller to be able to get only part of the info. For
example, retrieving the static field values is an expensive operation. If the
caller isn't interested in the fields, it saves time and memory when passing
NULL for that parameter.

On 2012/05/22 01:49:09, asiva wrote:

+  return Api::True(isolate);
+}
+
+
 DART_EXPORT Dart_Handle Dart_GetScriptSource(
                             Dart_Handle library_url_in,
                             Dart_Handle script_url_in) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   String& library_url = String::Handle();
   UNWRAP_AND_CHECK_PARAM(String, library_url, library_url_in);
   String& script_url = String::Handle();
   UNWRAP_AND_CHECK_PARAM(String, script_url, script_url_in);
 
@@ skipping 61 matching lines @@
   for (int i = 0; i < num_libs; i++) {
     ASSERT(!lib.IsNull());
     lib_url = lib.url();
     library_list.SetAt(i, lib_url);
     lib = lib.next_registered();
   }
   return Api::NewHandle(isolate, library_list.raw());
 }
 
 }  // namespace dart