Redo "running" field in debug-delay.js and support "suspend" command

src/debug-delay.js

 // Copyright 2006-2008 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 777 matching lines @@
 ExecutionState.prototype.setSelectedFrame = function(index) {
   var i = %ToNumber(index);
   if (i < 0 || i >= this.frameCount()) throw new Error('Illegal frame index.');
   this.selected_frame = i;
 };
 
 ExecutionState.prototype.selectedFrame = function() {
   return this.selected_frame;
 };
 
-ExecutionState.prototype.debugCommandProcessor = function(protocol) {
-  return new DebugCommandProcessor(this, protocol);
+ExecutionState.prototype.debugCommandProcessor = function(opt_is_running) {
+  return new DebugCommandProcessor(this, opt_is_running);
 };
 
 
 function MakeBreakEvent(exec_state, break_points_hit) {
   return new BreakEvent(exec_state, break_points_hit);
 }
 
 
 function BreakEvent(exec_state, break_points_hit) {
   this.exec_state_ = exec_state;
@@ skipping 264 matching lines @@
   if (!IS_UNDEFINED(script.data())) {
     o.data = script.data();
   }
   if (include_source) {
     o.source = script.source();
   }
   return o;
 };
 
 
-function DebugCommandProcessor(exec_state) {
+function DebugCommandProcessor(exec_state, opt_is_running) {
   this.exec_state_ = exec_state;
-  this.running_ = false;
+  this.running_ = opt_is_running || false;
 };
 
 
 DebugCommandProcessor.prototype.processDebugRequest = function (request) {
   return this.processDebugJSONRequest(request);
 }
 
 
 function ProtocolMessage(request) {
   // Update sequence number.
   this.seq = next_response_seq++;
 
   if (request) {
     // If message is based on a request this is a response. Fill the initial
     // response from the request.
     this.type = 'response';
     this.request_seq = request.seq;
     this.command = request.command;
   } else {
     // If message is not based on a request it is a dabugger generated event.
     this.type = 'event';
   }
   this.success = true;
-  this.running = false;
+  // Handler may set this field to control debugger state.
+  this.running = undefined;
 }
 
 
 ProtocolMessage.prototype.setOption = function(name, value) {
   if (!this.options_) {
     this.options_ = {};
   }
   this.options_[name] = value;
 }
 
@@ skipping 40 matching lines @@
       }
     } else {
       bodyJson = ObjectToProtocolObject_(this.body, serializer);
     }
     json.body = bodyJson;
     json.refs = serializer.serializeReferencedObjects();
   }
   if (this.message) {
     json.message = this.message;
   }
-  if (this.running) {
-    json.running = true;
-  } else {
-    json.running = false;
-  }
+  json.running = this.running;
   return JSON.stringify(json);
 }
 
 
 DebugCommandProcessor.prototype.createResponse = function(request) {
   return new ProtocolMessage(request);
 };
 
 
 DebugCommandProcessor.prototype.processDebugJSONRequest = function(json_request) {
@@ skipping 51 matching lines @@
       } else if (request.command == 'lookup') {
         this.lookupRequest_(request, response);
       } else if (request.command == 'references') {
         this.referencesRequest_(request, response);
       } else if (request.command == 'source') {
         this.sourceRequest_(request, response);
       } else if (request.command == 'scripts') {
         this.scriptsRequest_(request, response);
       } else if (request.command == 'threads') {
         this.threadsRequest_(request, response);
+      } else if (request.command == 'suspend') {
+        this.suspendRequest_(request, response);
       } else {
         throw new Error('Unknown command "' + request.command + '" in request');
       }
     } catch (e) {
       // If there is no response object created one (without command).
       if (!response) {
         response = this.createResponse();
       }
       response.success = false;
       response.message = %ToString(e);
     }
 
     // Return the response as a JSON encoded string.
     try {
-      this.running_ = response.running;  // Store the running state.
+      if (!IS_UNDEFINED(response.running)) {
+        // Response controls running state.
+        this.running_ = response.running;
+      }
+      response.running = this.running_; 
       return response.toJSONProtocol();
     } catch (e) {
       // Failed to generate response - return generic error.
       return '{"seq":' + response.seq + ',' +
               '"request_seq":' + request.seq + ',' +
               '"type":"response",' +
               '"success":false,' +
               '"message":"Internal error: ' + %ToString(e) + '"}';
     }
   } catch (e) {
@@ skipping 628 matching lines @@
   }
 
   // Create the response body.
   response.body = {
     totalThreads: total_threads,
     threads: threads
   }
 };
 
 
+DebugCommandProcessor.prototype.suspendRequest_ = function(request, response) {
+  // TODO(peter.rybin): probably we need some body field here.
+  response.running = false;
+};
+
+
 // Check whether the previously processed command caused the VM to become
 // running.
 DebugCommandProcessor.prototype.isRunning = function() {
   return this.running_;
 }
 
 
 DebugCommandProcessor.prototype.systemBreak = function(cmd, args) {
   return %SystemBreak();
 };
@@ skipping 106 matching lines @@
     case 'string':
     case 'number':
       json = value;
       break
 
     default:
       json = null;
   }
   return json;
 }