Support passing multiple handles in 'lookup' request

test/mjsunit/debug-handle.js

 // Copyright 2009 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 77 matching lines @@
 
 
 function listener(event, exec_state, event_data, data) {
   try {
   if (event == Debug.DebugEvent.Break) {
     // Get the debug command processor.
     var dcp = exec_state.debugCommandProcessor();
 
     // Test some illegal lookup requests.
     lookupRequest(dcp, void 0, false);
-    lookupRequest(dcp, '{"handle":"a"}', false);
-    lookupRequest(dcp, '{"handle":-1}', false);
+    lookupRequest(dcp, '{"handles":["a"]}', false);
+    lookupRequest(dcp, '{"handles":[-1]}', false);
 
     // Evaluate and get some handles.
     var handle_o = evaluateRequest(dcp, '{"expression":"o"}');
     var handle_p = evaluateRequest(dcp, '{"expression":"p"}');
     var handle_b = evaluateRequest(dcp, '{"expression":"a"}');
     var handle_a = evaluateRequest(dcp, '{"expression":"b","frame":1}');
     assertEquals(handle_o, handle_a);
     assertEquals(handle_a, handle_b);
     assertFalse(handle_o == handle_p, "o and p have he same handle");
 
     var response;
     var count;
-    response = lookupRequest(dcp, '{"handle":' + handle_o + '}', true);
-    assertEquals(handle_o, response.body.handle);
+    response = lookupRequest(dcp, '{"handles":[' + handle_o + ']}', true);
+    var obj = response.body[handle_o];
+    assertTrue(!!obj, 'Object not found: ' + handle_o);
+    assertEquals(handle_o, obj.handle);
     count = 0;
-    for (i in response.body.properties) {
-      switch (response.body.properties[i].name) {
+    for (i in obj.properties) {
+      switch (obj.properties[i].name) {
         case 'o':
-          response.body.properties[i].ref = handle_o;
+          obj.properties[i].ref = handle_o;
           count++;
           break;
         case 'p':
-          response.body.properties[i].ref = handle_p;
+          obj.properties[i].ref = handle_p;
           count++;
           break;
       }
     }
     assertEquals(2, count, 'Either "o" or "p" not found');
-    response = lookupRequest(dcp, '{"handle":' + handle_p + '}', true);
-    assertEquals(handle_p, response.body.handle);
+    response = lookupRequest(dcp, '{"handles":[' + handle_p + ']}', true);
+    obj = response.body[handle_p];
+    assertTrue(!!obj, 'Object not found: ' + handle_p);
+    assertEquals(handle_p, obj.handle);
 
     // Check handles for functions on the stack.
     var handle_f = evaluateRequest(dcp, '{"expression":"f"}');
     var handle_g = evaluateRequest(dcp, '{"expression":"g"}');
     var handle_caller = evaluateRequest(dcp, '{"expression":"f.caller"}');
 
     assertFalse(handle_f == handle_g, "f and g have he same handle");
     assertEquals(handle_g, handle_caller, "caller for f should be g");
 
-    response = lookupRequest(dcp, '{"handle":' + handle_f + '}', true);
-    assertEquals(handle_f, response.body.handle);
+    response = lookupRequest(dcp, '{"handles":[' + handle_f + ']}', true);
+    obj = response.body[handle_f];
+    assertEquals(handle_f, obj.handle);
+
     count = 0;
-    for (i in response.body.properties) {
-      var arguments = '{"handle":' + response.body.properties[i].ref + '}'
-      switch (response.body.properties[i].name) {
+    for (i in obj.properties) {
+      var ref = obj.properties[i].ref;
+      var arguments = '{"handles":[' + ref + ']}';
+      switch (obj.properties[i].name) {
         case 'name':
           var response_name;
           response_name = lookupRequest(dcp, arguments, true);
-          assertEquals('string', response_name.body.type);
-          assertEquals("f", response_name.body.value);
+          assertEquals('string', response_name.body[ref].type);
+          assertEquals("f", response_name.body[ref].value);
           count++;
           break;
         case 'length':
           var response_length;
           response_length = lookupRequest(dcp, arguments, true);
-          assertEquals('number', response_length.body.type);
-          assertEquals(1, response_length.body.value);
+          assertEquals('number', response_length.body[ref].type);
+          assertEquals(1, response_length.body[ref].value);
           count++;
           break;
         case 'caller':
-          assertEquals(handle_g, response.body.properties[i].ref);
+          assertEquals(handle_g, obj.properties[i].ref);
           count++;
           break;
       }
     }
     assertEquals(3, count, 'Either "name", "length" or "caller" not found');
 
 
+    // Resolve all at once.
+    var refs = [];
+    for (i in obj.properties) {
+      refs.push(obj.properties[i].ref);
+    }
+
+    var arguments = '{"handles":[' + refs.join(',') + ']}';
+    response = lookupRequest(dcp, arguments, true);
+    count = 0;
+    for (i in obj.properties) {
+      var ref = obj.properties[i].ref;
+      var val = response.body[ref];
+      assertTrue(!!val, 'Failed to lookup "' + obj.properties[i].name + '"');
+      switch (obj.properties[i].name) {
+        case 'name':
+          assertEquals('string', val.type);
+          assertEquals("f", val.value);
+          count++;
+          break;
+        case 'length':
+          assertEquals('number', val.type);
+          assertEquals(1, val.value);
+          count++;
+          break;
+        case 'caller':
+          assertEquals('function', val.type);
+          assertEquals(handle_g, ref);
+          count++;
+          break;
+      }
+    }
+    assertEquals(3, count, 'Either "name", "length" or "caller" not found');
+
+    count = 0;
+    for (var handle in response.body) {
+      assertTrue(refs.indexOf(parseInt(handle)) != -1,
+                 'Handle not in the request: ' + handle);
+      count++;
+    }
+    assertEquals(count, obj.properties.length, 
+                 'Unexpected number of resolved objects');
+
+
     // Indicate that all was processed.
     listenerComplete = true;
   }
   } catch (e) {
     exception = e
   };
 };
 
 // Add the debug event listener.
 Debug.setListener(listener);
@@ skipping 10 matching lines @@
 Debug.setBreakPoint(f, 2, 0);
 o = {};
 p = {}
 o.o = o;
 o.p = p;
 p.o = o;
 p.p = p;
 g(o);
 
 // Make sure that the debug event listener vas invoked.
-assertTrue(listenerComplete, "listener did not run to completion");
+assertTrue(listenerComplete, "listener did not run to completion: " + exception);
 assertFalse(exception, "exception in listener")