Introduce Runtime_GetAllScopesDetails to get all scopes at once for a frame.

src/runtime.cc

Index: src/runtime.cc
diff --git a/src/runtime.cc b/src/runtime.cc
index 0caaa47bd57f79ba52b8b46959a590c9fe918041..d8448d80322be527bdfa12c8ab058ceb5e6fdabb 100644
--- a/src/runtime.cc
+++ b/src/runtime.cc
@@ -12298,6 +12298,48 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_GetScopeDetails) {
 }
 
 
+// Return an array of scope details
+// args[0]: number: break id
+// args[1]: number: frame index
+// args[2]: number: inlined frame index
+//
+// The array returned contains arrays with the following information:
+// 0: Scope type
+// 1: Scope object

[Yang, 2014/03/04 11:31:35]

Now this seems just a broader case of %GetScopeDetails. Just an idea that you
may dismiss: we could share code and use an unified runtime function that takes
an optional scope index to distinguish between the two use cases.

+RUNTIME_FUNCTION(MaybeObject*, Runtime_GetAllScopesDetails) {
+  HandleScope scope(isolate);
+  ASSERT(args.length() == 3);
+
+  // Check arguments.
+  Object* check;
+  { MaybeObject* maybe_check = Runtime_CheckExecutionState(
+      RUNTIME_ARGUMENTS(isolate, args));
+    if (!maybe_check->ToObject(&check)) return maybe_check;
+  }
+  CONVERT_SMI_ARG_CHECKED(wrapped_id, 1);
+  CONVERT_NUMBER_CHECKED(int, inlined_jsframe_index, Int32, args[2]);
+
+  // Get the frame where the debugging is performed.
+  StackFrame::Id id = UnwrapFrameId(wrapped_id);
+  JavaScriptFrameIterator frame_it(isolate, id);
+  JavaScriptFrame* frame = frame_it.frame();
+
+  List<Handle<Object> > result(4);
+  ScopeIterator it(isolate, frame, inlined_jsframe_index);

[ulan, 2014/03/04 10:41:59]

This code seems to work, but it is fragile because it mixes handlified code with
raw pointers. ScopeIterator can cause GC, so after this point any raw pointer to
v8 heap from above may become invalid.

[aandrey, 2014/03/04 11:04:19]

You mean the JavaScriptFrame* pointer?
I'm not an expert here, but this code, up to the point, is just a carbon copy of
the above Runtime_GetScopeDetails.

The JavaScriptFrame class is BASE_EMBEDDED. Should it care on GC being run?

[ulan, 2014/03/04 11:28:15]

That pointer should be fine. This code works, but becomes confusing because of
mixing handles with maybe_object below.

[Yang, 2014/03/04 11:31:35]

Seems fine to me.

+  for (; !it.Done(); it.Next()) {
+    MaybeObject* maybe_object = MaterializeScopeDetails(isolate, &it);

[ulan, 2014/03/04 10:41:59]

MaterializeScopeDetails looks already handlified, it could just return a handle,
instead of maybe_objects. The you wouldn't need checks and conversions below.

[aandrey, 2014/03/04 11:04:19]

As far as I understand, it may return a Failure which inherits MaybeObject and
not Object, thus the return type is MaybeObject*.

What syntax would you suggest for MaterializeScopeDetails?

[ulan, 2014/03/04 11:28:15]

Something like this:

Handle<Object> MaterializeScopeDetails(Isolate* isolate,     ScopeIterator* it).
It could return empty handle in the case where it is currently returning
Failure, then the caller could do

Handle<Object> scope_details = MaterializeScopeDetails(isolate, &it);
RETURN_IF_EMPTY_HANDLE(isolate, scope_details);
result.Add(scope_details, isolate);

This way it is clear that all the code is handlified.

[Yang, 2014/03/04 11:31:35]

I suggest changing MaterializedScopeDetails to return a Handle<JSObject>. If the
scope_object is an empty handle, use RETURN_IF_EMPTY_HANDLE_VALUE to propagate
that empty handle to the caller. The caller should then check with
RETURN_IF_EMPTY_HANDLE.

I know it's not actually caused by this CL, but I since we are moving towards
less code with MaybeObject, this would be a nice small clean up.

[aandrey, 2014/03/04 12:39:07]

Done.

+    if (maybe_object->IsFailure()) return maybe_object;
+    result.Add(handle(maybe_object->ToObjectUnchecked(), isolate));
+  }
+
+  Handle<FixedArray> array = isolate->factory()->NewFixedArray(result.length());
+  for (int i = 0; i < result.length(); ++i) {
+    array->set(i, *result[i]);
+  }
+  return *isolate->factory()->NewJSArrayWithElements(array);
+}
+
+
 RUNTIME_FUNCTION(MaybeObject*, Runtime_GetFunctionScopeCount) {
   HandleScope scope(isolate);
   ASSERT(args.length() == 1);