Clean up JavaScript files to better follow coding standard.

src/debug-debugger.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 268 matching lines @@
   var copy = new ScriptBreakPoint(Debug.ScriptBreakPointType.ScriptId,
       other_script.id, this.line_, this.column_, this.groupId_);
   copy.number_ = next_break_point_number++;
   script_break_points.push(copy);
 
   copy.hit_count_ = this.hit_count_;
   copy.active_ = this.active_;
   copy.condition_ = this.condition_;
   copy.ignoreCount_ = this.ignoreCount_;
   return copy;
-}
+};
 
 
 ScriptBreakPoint.prototype.number = function() {
   return this.number_;
 };
 
 
 ScriptBreakPoint.prototype.groupId = function() {
   return this.groupId_;
 };
@@ skipping 28 matching lines @@
   return this.column_;
 };
 
 
 ScriptBreakPoint.prototype.actual_locations = function() {
   var locations = [];
   for (var i = 0; i < this.break_points_.length; i++) {
     locations.push(this.break_points_[i].actual_location);
   }
   return locations;
-}
+};
 
 
 ScriptBreakPoint.prototype.update_positions = function(line, column) {
   this.line_ = line;
   this.column_ = column;
-}
+};
 
 
 ScriptBreakPoint.prototype.hit_count = function() {
   return this.hit_count_;
 };
 
 
 ScriptBreakPoint.prototype.active = function() {
   return this.active_;
 };
@@ skipping 115 matching lines @@
   }
   break_points = remaining_break_points;
   this.break_points_ = [];
 };
 
 
 // Function called from runtime when a new script is compiled to set any script
 // break points set in this script.
 function UpdateScriptBreakPoints(script) {
   for (var i = 0; i < script_break_points.length; i++) {
-    if (script_break_points[i].type() == Debug.ScriptBreakPointType.ScriptName &&
-        script_break_points[i].matchesScript(script)) {
-      script_break_points[i].set(script);
+    var break_point = script_break_points[i];
+    if ((break_point.type() == Debug.ScriptBreakPointType.ScriptName) &&
+        break_point.matchesScript(script)) {
+      break_point.set(script);
     }
   }
 }
 
 
 function GetScriptBreakPoints(script) {
   var result = [];
   for (var i = 0; i < script_break_points.length; i++) {
     if (script_break_points[i].matchesScript(script)) {
       result.push(script_break_points[i]);
@@ skipping 85 matching lines @@
 Debug.sourcePosition = function(f) {
   if (!IS_FUNCTION(f)) throw new Error('Parameters have wrong types.');
   return %FunctionGetScriptSourcePosition(f);
 };
 
 
 Debug.findFunctionSourceLocation = function(func, opt_line, opt_column) {
   var script = %FunctionGetScript(func);
   var script_offset = %FunctionGetScriptSourcePosition(func);
   return script.locationFromLine(opt_line, opt_column, script_offset);
-}
+};
 
 
 // Returns the character position in a script based on a line number and an
 // optional position within that line.
 Debug.findScriptSourcePosition = function(script, opt_line, opt_column) {
   var location = script.locationFromLine(opt_line, opt_column);
   return location ? location.position : null;
-}
+};
 
 
 Debug.findBreakPoint = function(break_point_number, remove) {
   var break_point;
   for (var i = 0; i < break_points.length; i++) {
     if (break_points[i].number() == break_point_number) {
       break_point = break_points[i];
       // Remove the break point from the list if requested.
       if (remove) {
         break_points.splice(i, 1);
@@ skipping 13 matching lines @@
     if (script_break_points[i].number() == break_point_number) {
       return script_break_points[i].actual_locations();
     }
   }
   for (var i = 0; i < break_points.length; i++) {
     if (break_points[i].number() == break_point_number) {
       return [break_points[i].actual_location];
     }
   }
   return [];
-}
+};
 
 Debug.setBreakPoint = function(func, opt_line, opt_column, opt_condition) {
   if (!IS_FUNCTION(func)) throw new Error('Parameters have wrong types.');
   // Break points in API functions are not supported.
   if (%FunctionIsAPIFunction(func)) {
     throw new Error('Cannot set break point in native code.');
   }
   // Find source position relative to start of the function
   var break_position =
       this.findFunctionSourceLocation(func, opt_line, opt_column).position;
@@ skipping 29 matching lines @@
     return break_point.number();
   }
 };
 
 
 Debug.setBreakPointByScriptIdAndPosition = function(script_id, position,
                                                     condition, enabled)
 {
   break_point = MakeBreakPoint(position);
   break_point.setCondition(condition);
-  if (!enabled)
+  if (!enabled) {
     break_point.disable();
+  }
   var scripts = this.scripts();
   for (var i = 0; i < scripts.length; i++) {
     if (script_id == scripts[i].id) {
       break_point.actual_position = %SetScriptBreakPoint(scripts[i], position,
                                                          break_point);
       break;
     }
   }
   return break_point;
 };
@@ skipping 72 matching lines @@
       script_break_point = script_break_points[i];
       // Remove the break point from the list if requested.
       if (remove) {
         script_break_point.clear();
         script_break_points.splice(i,1);
       }
       break;
     }
   }
   return script_break_point;
-}
+};
 
 
 // Sets a breakpoint in a script identified through id or name at the
 // specified source line and column within that line.
 Debug.setScriptBreakPoint = function(type, script_id_or_name,
                                      opt_line, opt_column, opt_condition,
                                      opt_groupId) {
   // Create script break point object.
   var script_break_point =
       new ScriptBreakPoint(type, script_id_or_name, opt_line, opt_column,
                            opt_groupId);
 
   // Assign number to the new script break point and add it.
   script_break_point.number_ = next_break_point_number++;
   script_break_point.setCondition(opt_condition);
   script_break_points.push(script_break_point);
 
   // Run through all scripts to see if this script break point matches any
   // loaded scripts.
   var scripts = this.scripts();
   for (var i = 0; i < scripts.length; i++) {
     if (script_break_point.matchesScript(scripts[i])) {
       script_break_point.set(scripts[i]);
     }
   }
 
   return script_break_point.number();
-}
+};
 
 
 Debug.setScriptBreakPointById = function(script_id,
                                          opt_line, opt_column,
                                          opt_condition, opt_groupId) {
   return this.setScriptBreakPoint(Debug.ScriptBreakPointType.ScriptId,
                                   script_id, opt_line, opt_column,
                                   opt_condition, opt_groupId);
-}
+};
 
 
 Debug.setScriptBreakPointByName = function(script_name,
                                            opt_line, opt_column,
                                            opt_condition, opt_groupId) {
   return this.setScriptBreakPoint(Debug.ScriptBreakPointType.ScriptName,
                                   script_name, opt_line, opt_column,
                                   opt_condition, opt_groupId);
-}
+};
 
 
 Debug.setScriptBreakPointByRegExp = function(script_regexp,
                                              opt_line, opt_column,
                                              opt_condition, opt_groupId) {
   return this.setScriptBreakPoint(Debug.ScriptBreakPointType.ScriptRegExp,
                                   script_regexp, opt_line, opt_column,
                                   opt_condition, opt_groupId);
-}
+};
 
 
 Debug.enableScriptBreakPoint = function(break_point_number) {
   var script_break_point = this.findScriptBreakPoint(break_point_number, false);
   script_break_point.enable();
 };
 
 
 Debug.disableScriptBreakPoint = function(break_point_number) {
   var script_break_point = this.findScriptBreakPoint(break_point_number, false);
   script_break_point.disable();
 };
 
 
-Debug.changeScriptBreakPointCondition = function(break_point_number, condition) {
+Debug.changeScriptBreakPointCondition = function(
+    break_point_number, condition) {
   var script_break_point = this.findScriptBreakPoint(break_point_number, false);
   script_break_point.setCondition(condition);
 };
 
 
-Debug.changeScriptBreakPointIgnoreCount = function(break_point_number, ignoreCount) {
+Debug.changeScriptBreakPointIgnoreCount = function(
+    break_point_number, ignoreCount) {
   if (ignoreCount < 0) {
     throw new Error('Invalid argument');
   }
   var script_break_point = this.findScriptBreakPoint(break_point_number, false);
   script_break_point.setIgnoreCount(ignoreCount);
 };
 
 
 Debug.scriptBreakPoints = function() {
   return script_break_points;
-}
+};
 
 
 Debug.clearStepping = function() {
   %ClearStepping();
-}
+};
 
 Debug.setBreakOnException = function() {
   return %ChangeBreakOnException(Debug.ExceptionBreak.Caught, true);
 };
 
 Debug.clearBreakOnException = function() {
   return %ChangeBreakOnException(Debug.ExceptionBreak.Caught, false);
 };
 
 Debug.isBreakOnException = function() {
@@ skipping 56 matching lines @@
   this.break_id = break_id;
   this.selected_frame = 0;
 }
 
 ExecutionState.prototype.prepareStep = function(opt_action, opt_count) {
   var action = Debug.StepAction.StepIn;
   if (!IS_UNDEFINED(opt_action)) action = %ToNumber(opt_action);
   var count = opt_count ? %ToNumber(opt_count) : 1;
 
   return %PrepareStep(this.break_id, action, count);
-}
+};
 
 ExecutionState.prototype.evaluateGlobal = function(source, disable_break,
     opt_additional_context) {
   return MakeMirror(%DebugEvaluateGlobal(this.break_id, source,
                                          Boolean(disable_break),
                                          opt_additional_context));
 };
 
 ExecutionState.prototype.frameCount = function() {
   return %GetFrameCount(this.break_id);
 };
 
 ExecutionState.prototype.threadCount = function() {
   return %GetThreadCount(this.break_id);
 };
 
 ExecutionState.prototype.frame = function(opt_index) {
   // If no index supplied return the selected frame.
   if (opt_index == null) opt_index = this.selected_frame;
-  if (opt_index < 0 || opt_index >= this.frameCount())
+  if (opt_index < 0 || opt_index >= this.frameCount()) {
     throw new Error('Illegal frame index.');
+  }
   return new FrameMirror(this.break_id, opt_index);
 };
 
 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() {
@@ skipping 106 matching lines @@
 };
 
 
 ExceptionEvent.prototype.eventType = function() {
   return Debug.DebugEvent.Exception;
 };
 
 
 ExceptionEvent.prototype.exception = function() {
   return this.exception_;
-}
+};
 
 
 ExceptionEvent.prototype.uncaught = function() {
   return this.uncaught_;
-}
+};
 
 
 ExceptionEvent.prototype.func = function() {
   return this.exec_state_.frame(0).func();
 };
 
 
 ExceptionEvent.prototype.sourceLine = function() {
   return this.exec_state_.frame(0).sourceLine();
 };
@@ skipping 71 matching lines @@
   o.running = true;
   if (this.before_) {
     o.event = "beforeCompile";
   } else {
     o.event = "afterCompile";
   }
   o.body = {};
   o.body.script = this.script_;
 
   return o.toJSONProtocol();
-}
+};
 
 
 function MakeNewFunctionEvent(func) {
   return new NewFunctionEvent(func);
 }
 
 
 function NewFunctionEvent(func) {
   this.func = func;
 }
@@ skipping 35 matching lines @@
 };
 
 
 ScriptCollectedEvent.prototype.toJSONProtocol = function() {
   var o = new ProtocolMessage();
   o.running = true;
   o.event = "scriptCollected";
   o.body = {};
   o.body.script = { id: this.id() };
   return o.toJSONProtocol();
-}
+};
 
 
 function MakeScriptObject_(script, include_source) {
   var o = { id: script.id(),
             name: script.name(),
             lineOffset: script.lineOffset(),
             columnOffset: script.columnOffset(),
             lineCount: script.lineCount(),
           };
   if (!IS_UNDEFINED(script.data())) {
     o.data = script.data();
   }
   if (include_source) {
     o.source = script.source();
   }
   return o;
-};
+}
 
 
 function DebugCommandProcessor(exec_state, opt_is_running) {
   this.exec_state_ = exec_state;
   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;
   // 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;
-}
+};
 
 
 ProtocolMessage.prototype.failed = function(message) {
   this.success = false;
   this.message = message;
-}
+};
 
 
 ProtocolMessage.prototype.toJSONProtocol = function() {
   // Encode the protocol header.
   var json = {};
   json.seq= this.seq;
   if (this.request_seq) {
     json.request_seq = this.request_seq;
   }
   json.type = this.type;
@@ skipping 27 matching lines @@
       bodyJson = ObjectToProtocolObject_(this.body, serializer);
     }
     json.body = bodyJson;
     json.refs = serializer.serializeReferencedObjects();
   }
   if (this.message) {
     json.message = this.message;
   }
   json.running = this.running;
   return JSON.stringify(json);
-}
+};
 
 
 DebugCommandProcessor.prototype.createResponse = function(request) {
   return new ProtocolMessage(request);
 };
 
 
-DebugCommandProcessor.prototype.processDebugJSONRequest = function(json_request) {
+DebugCommandProcessor.prototype.processDebugJSONRequest = function(
+    json_request) {
   var request;  // Current request.
   var response;  // Generated response.
   try {
     try {
       // Convert the JSON string to an object.
       request = JSON.parse(json_request);
 
       // Create an initial response.
       response = this.createResponse(request);
 
@@ skipping 266 matching lines @@
   var break_point = Debug.findBreakPoint(break_point_number);
   if (ignoreCount) {
     Debug.changeBreakPointIgnoreCount(break_point_number, ignoreCount);
   }
   if (!enabled) {
     Debug.disableBreakPoint(break_point_number);
   }
 
   // Add the break point number to the response.
   response.body = { type: type,
-                    breakpoint: break_point_number }
+                    breakpoint: break_point_number };
 
   // Add break point information to the response.
   if (break_point instanceof ScriptBreakPoint) {
     if (break_point.type() == Debug.ScriptBreakPointType.ScriptId) {
       response.body.type = 'scriptId';
       response.body.script_id = break_point.script_id();
     } else if (break_point.type() == Debug.ScriptBreakPointType.ScriptName) {
       response.body.type = 'scriptName';
       response.body.script_name = break_point.script_name();
     } else if (break_point.type() == Debug.ScriptBreakPointType.ScriptRegExp) {
       response.body.type = 'scriptRegExp';
       response.body.script_regexp = break_point.script_regexp_object().source;
     } else {
-      throw new Error("Internal error: Unexpected breakpoint type: " + break_point.type());
+      throw new Error("Internal error: Unexpected breakpoint type: " +
+                      break_point.type());
     }
     response.body.line = break_point.line();
     response.body.column = break_point.column();
     response.body.actual_locations = break_point.actual_locations();
   } else {
     response.body.type = 'function';
     response.body.actual_locations = [break_point.actual_location];
   }
 };
 
 
-DebugCommandProcessor.prototype.changeBreakPointRequest_ = function(request, response) {
+DebugCommandProcessor.prototype.changeBreakPointRequest_ = function(
+    request, response) {
   // Check for legal request.
   if (!request.arguments) {
     response.failed('Missing arguments');
     return;
   }
 
   // Pull out arguments.
   var break_point = %ToNumber(request.arguments.breakpoint);
   var enabled = request.arguments.enabled;
   var condition = request.arguments.condition;
@@ skipping 16 matching lines @@
 
   // Change condition if supplied
   if (!IS_UNDEFINED(condition)) {
     Debug.changeBreakPointCondition(break_point, condition);
   }
 
   // Change ignore count if supplied
   if (!IS_UNDEFINED(ignoreCount)) {
     Debug.changeBreakPointIgnoreCount(break_point, ignoreCount);
   }
-}
+};
 
 
-DebugCommandProcessor.prototype.clearBreakPointGroupRequest_ = function(request, response) {
+DebugCommandProcessor.prototype.clearBreakPointGroupRequest_ = function(
+    request, response) {
   // Check for legal request.
   if (!request.arguments) {
     response.failed('Missing arguments');
     return;
   }
 
   // Pull out arguments.
   var group_id = request.arguments.groupId;
 
   // Check for legal arguments.
@@ skipping 10 matching lines @@
       cleared_break_points.push(next_break_point.number());
       next_break_point.clear();
     } else {
       new_script_break_points.push(next_break_point);
     }
   }
   script_break_points = new_script_break_points;
 
   // Add the cleared break point numbers to the response.
   response.body = { breakpoints: cleared_break_points };
-}
+};
 
 
-DebugCommandProcessor.prototype.clearBreakPointRequest_ = function(request, response) {
+DebugCommandProcessor.prototype.clearBreakPointRequest_ = function(
+    request, response) {
   // Check for legal request.
   if (!request.arguments) {
     response.failed('Missing arguments');
     return;
   }
 
   // Pull out arguments.
   var break_point = %ToNumber(request.arguments.breakpoint);
 
   // Check for legal arguments.
   if (!break_point) {
     response.failed('Missing argument "breakpoint"');
     return;
   }
 
   // Clear break point.
   Debug.clearBreakPoint(break_point);
 
   // Add the cleared break point number to the response.
-  response.body = { breakpoint: break_point }
-}
+  response.body = { breakpoint: break_point };
+};
 
 
-DebugCommandProcessor.prototype.listBreakpointsRequest_ = function(request, response) {
+DebugCommandProcessor.prototype.listBreakpointsRequest_ = function(
+    request, response) {
   var array = [];
   for (var i = 0; i < script_break_points.length; i++) {
     var break_point = script_break_points[i];
 
     var description = {
       number: break_point.number(),
       line: break_point.line(),
       column: break_point.column(),
       groupId: break_point.groupId(),
       hit_count: break_point.hit_count(),
       active: break_point.active(),
       condition: break_point.condition(),
       ignoreCount: break_point.ignoreCount(),
       actual_locations: break_point.actual_locations()
-    }
+    };
 
     if (break_point.type() == Debug.ScriptBreakPointType.ScriptId) {
       description.type = 'scriptId';
       description.script_id = break_point.script_id();
     } else if (break_point.type() == Debug.ScriptBreakPointType.ScriptName) {
       description.type = 'scriptName';
       description.script_name = break_point.script_name();
     } else if (break_point.type() == Debug.ScriptBreakPointType.ScriptRegExp) {
       description.type = 'scriptRegExp';
       description.script_regexp = break_point.script_regexp_object().source;
     } else {
-      throw new Error("Internal error: Unexpected breakpoint type: " + break_point.type());
+      throw new Error("Internal error: Unexpected breakpoint type: " +
+                      break_point.type());
     }
     array.push(description);
   }
 
   response.body = {
     breakpoints: array,
     breakOnExceptions: Debug.isBreakOnException(),
     breakOnUncaughtExceptions: Debug.isBreakOnUncaughtException()
-  }
-}
+  };
+};
 
 
 DebugCommandProcessor.prototype.disconnectRequest_ =
     function(request, response) {
   Debug.disableAllBreakPoints();
   this.continueRequest_(request, response);
-}
+};
 
 
 DebugCommandProcessor.prototype.setExceptionBreakRequest_ =
     function(request, response) {
   // Check for legal request.
   if (!request.arguments) {
     response.failed('Missing arguments');
     return;
   }
 
@@ skipping 24 matching lines @@
   if (type == 'all') {
     %ChangeBreakOnException(Debug.ExceptionBreak.Caught, enabled);
   } else if (type == 'uncaught') {
     %ChangeBreakOnException(Debug.ExceptionBreak.Uncaught, enabled);
   } else {
     response.failed('Unknown "type":"' + type + '"');
   }
 
   // Add the cleared break point number to the response.
   response.body = { 'type': type, 'enabled': enabled };
-}
+};
 
 
-DebugCommandProcessor.prototype.backtraceRequest_ = function(request, response) {
+DebugCommandProcessor.prototype.backtraceRequest_ = function(
+    request, response) {
   // Get the number of frames.
   var total_frames = this.exec_state_.frameCount();
 
   // Create simple response if there are no frames.
   if (total_frames == 0) {
     response.body = {
       totalFrames: total_frames
-    }
+    };
     return;
   }
 
   // Default frame range to include in backtrace.
-  var from_index = 0
+  var from_index = 0;
   var to_index = kDefaultBacktraceLength;
 
   // Get the range from the arguments.
   if (request.arguments) {
     if (request.arguments.fromFrame) {
       from_index = request.arguments.fromFrame;
     }
     if (request.arguments.toFrame) {
       to_index = request.arguments.toFrame;
     }
     if (request.arguments.bottom) {
       var tmp_index = total_frames - from_index;
-      from_index = total_frames - to_index
+      from_index = total_frames - to_index;
       to_index = tmp_index;
     }
     if (from_index < 0 || to_index < 0) {
       return response.failed('Invalid frame number');
     }
   }
 
   // Adjust the index.
   to_index = Math.min(total_frames, to_index);
 
   if (to_index <= from_index) {
     var error = 'Invalid frame range';
     return response.failed(error);
   }
 
   // Create the response body.
   var frames = [];
   for (var i = from_index; i < to_index; i++) {
     frames.push(this.exec_state_.frame(i));
   }
   response.body = {
     fromFrame: from_index,
     toFrame: to_index,
     totalFrames: total_frames,
     frames: frames
-  }
+  };
 };
 
 
 DebugCommandProcessor.prototype.frameRequest_ = function(request, response) {
   // No frames no source.
   if (this.exec_state_.frameCount() == 0) {
     return response.failed('No frames');
   }
 
   // With no arguments just keep the selected frame.
   if (request.arguments) {
     var index = request.arguments.number;
     if (index < 0 || this.exec_state_.frameCount() <= index) {
       return response.failed('Invalid frame number');
     }
 
     this.exec_state_.setSelectedFrame(request.arguments.number);
   }
   response.body = this.exec_state_.frame();
 };
 
 
 DebugCommandProcessor.prototype.frameForScopeRequest_ = function(request) {
-  // Get the frame for which the scope or scopes are requested. With no frameNumber
-  // argument use the currently selected frame.
+  // Get the frame for which the scope or scopes are requested.
+  // With no frameNumber argument use the currently selected frame.
   if (request.arguments && !IS_UNDEFINED(request.arguments.frameNumber)) {
     frame_index = request.arguments.frameNumber;
     if (frame_index < 0 || this.exec_state_.frameCount() <= frame_index) {
       return response.failed('Invalid frame number');
     }
     return this.exec_state_.frame(frame_index);
   } else {
     return this.exec_state_.frame();
   }
-}
+};
 
 
 DebugCommandProcessor.prototype.scopesRequest_ = function(request, response) {
   // No frames no scopes.
   if (this.exec_state_.frameCount() == 0) {
     return response.failed('No scopes');
   }
 
   // Get the frame for which the scopes are requested.
   var frame = this.frameForScopeRequest_(request);
 
   // Fill all scopes for this frame.
   var total_scopes = frame.scopeCount();
   var scopes = [];
   for (var i = 0; i < total_scopes; i++) {
     scopes.push(frame.scope(i));
   }
   response.body = {
     fromScope: 0,
     toScope: total_scopes,
     totalScopes: total_scopes,
     scopes: scopes
-  }
+  };
 };
 
 
 DebugCommandProcessor.prototype.scopeRequest_ = function(request, response) {
   // No frames no scopes.
   if (this.exec_state_.frameCount() == 0) {
     return response.failed('No scopes');
   }
 
   // Get the frame for which the scope is requested.
@@ skipping 224 matching lines @@
 
 DebugCommandProcessor.prototype.scriptsRequest_ = function(request, response) {
   var types = ScriptTypeFlag(Debug.ScriptType.Normal);
   var includeSource = false;
   var idsToInclude = null;
   if (request.arguments) {
     // Pull out arguments.
     if (!IS_UNDEFINED(request.arguments.types)) {
       types = %ToNumber(request.arguments.types);
       if (isNaN(types) || types < 0) {
-        return response.failed('Invalid types "' + request.arguments.types + '"');
+        return response.failed('Invalid types "' +
+                               request.arguments.types + '"');
       }
     }
 
     if (!IS_UNDEFINED(request.arguments.includeSource)) {
       includeSource = %ToBoolean(request.arguments.includeSource);
       response.setOption('includeSource', includeSource);
     }
 
     if (IS_ARRAY(request.arguments.ids)) {
       idsToInclude = {};
@@ skipping 48 matching lines @@
 DebugCommandProcessor.prototype.threadsRequest_ = function(request, response) {
   // Get the number of threads.
   var total_threads = this.exec_state_.threadCount();
 
   // Get information for all threads.
   var threads = [];
   for (var i = 0; i < total_threads; i++) {
     var details = %GetThreadDetails(this.exec_state_.break_id, i);
     var thread_info = { current: details[0],
                         id: details[1]
-                      }
+                      };
     threads.push(thread_info);
   }
 
   // Create the response body.
   response.body = {
     totalThreads: total_threads,
     threads: threads
-  }
+  };
 };
 
 
 DebugCommandProcessor.prototype.suspendRequest_ = function(request, response) {
   response.running = false;
 };
 
 
 DebugCommandProcessor.prototype.versionRequest_ = function(request, response) {
   response.body = {
     V8Version: %GetV8Version()
-  }
+  };
 };
 
 
 DebugCommandProcessor.prototype.profileRequest_ = function(request, response) {
   if (request.arguments.command == 'resume') {
     %ProfilerResume();
   } else if (request.arguments.command == 'pause') {
     %ProfilerPause();
   } else {
     return response.failed('Unknown command');
   }
   response.body = {};
 };
 
 
-DebugCommandProcessor.prototype.changeLiveRequest_ = function(request, response) {
+DebugCommandProcessor.prototype.changeLiveRequest_ = function(
+    request, response) {
   if (!Debug.LiveEdit) {
     return response.failed('LiveEdit feature is not supported');
   }
   if (!request.arguments) {
     return response.failed('Missing arguments');
   }
   var script_id = request.arguments.script_id;
   var preview_only = !!request.arguments.preview_only;
 
   var scripts = %DebugGetLoadedScripts();
@@ skipping 50 matching lines @@
         debugger_flag.setValue(flags[i].value);
       }
       response.body.flags.push({ name: name, value: debugger_flag.getValue() });
     }
   } else {
     for (var name in debugger_flags) {
       var value = debugger_flags[name].getValue();
       response.body.flags.push({ name: name, value: value });
     }
   }
-}
+};
 
 
 DebugCommandProcessor.prototype.v8FlagsRequest_ = function(request, response) {
   var flags = request.arguments.flags;
   if (!flags) flags = '';
   %SetFlags(flags);
 };
 
 
 DebugCommandProcessor.prototype.gcRequest_ = function(request, response) {
@@ skipping 85 matching lines @@
   var id = request.arguments.id;
   response.body = {};
   response.body.dump = %PrintLOLObj(id);
 };
 
 
 // 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();
 };
 
 
 function NumberToHex8Str(n) {
   var r = "";
   for (var i = 0; i < 8; ++i) {
     var c = hexCharArray[n & 0x0F];  // hexCharArray is defined in uri.js
     r = c + r;
     n = n >>> 4;
   }
   return r;
-};
+}
 
 
 /**
  * Convert an Object to its debugger protocol representation. The representation
  * may be serilized to a JSON object using JSON.stringify().
  * This implementation simply runs through all string property names, converts
  * each property value to a protocol value and adds the property to the result
  * object. For type "object" the function will be called recursively. Note that
  * circular structures will cause infinite recursion.
  * @param {Object} object The object to format as protocol object.
@@ skipping 55 matching lines @@
         json = ArrayToProtocolArray_(value, mirror_serializer);
       } else {
         json = ObjectToProtocolObject_(value, mirror_serializer);
       }
       break;
 
     case 'boolean':
     case 'string':
     case 'number':
       json = value;
-      break
+      break;
 
     default:
       json = null;
   }
   return json;
 }