On Linux, move the passing of filedescriptors to a dedicated socketpair().

chrome/tools/test/reference_build/chrome_linux/resources/inspector/debugger_agent.js

 // Copyright (c) 2009 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 /**
  * @fileoverview Provides communication interface to remote v8 debugger. See
  * protocol decription at http://code.google.com/p/v8/wiki/DebuggerProtocol
  */
 goog.provide('devtools.DebuggerAgent');
 
 
 /**
  * @constructor
  */
 devtools.DebuggerAgent = function() {
   RemoteDebuggerAgent.DebuggerOutput =
       goog.bind(this.handleDebuggerOutput_, this);
-  RemoteDebuggerAgent.DidGetContextId =
-      goog.bind(this.didGetContextId_, this);
-  RemoteDebuggerAgent.DidIsProfilingStarted =
-      goog.bind(this.didIsProfilingStarted_, this);
-  RemoteDebuggerAgent.DidGetLogLines =
-      goog.bind(this.didGetLogLines_, this);
+  RemoteDebuggerAgent.SetContextId =
+      goog.bind(this.setContextId_, this);
+  RemoteDebuggerAgent.DidGetActiveProfilerModules =
+      goog.bind(this.didGetActiveProfilerModules_, this);
+  RemoteDebuggerAgent.DidGetNextLogLines =
+      goog.bind(this.didGetNextLogLines_, this);
 
   /**
    * Id of the inspected page global context. It is used for filtering scripts.
    * @type {number}
    */
   this.contextId_ = null;
 
   /**
    * Mapping from script id to script info.
    * @type {Object}
    */
   this.parsedScripts_ = null;
 
   /**
    * Mapping from the request id to the devtools.BreakpointInfo for the
    * breakpoints whose v8 ids are not set yet. These breakpoints are waiting for
    * 'setbreakpoint' responses to learn their ids in the v8 debugger.
    * @see #handleSetBreakpointResponse_
    * @type {Object}
    */
   this.requestNumberToBreakpointInfo_ = null;
 
   /**
-   * Information on current stack top frame.
-   * See JavaScriptCallFrame.idl.
-   * @type {?devtools.CallFrame}
+   * Information on current stack frames.
+   * @type {Array.<devtools.CallFrame>}
    */
-  this.currentCallFrame_ = null;
+  this.callFrames_ = [];
 
   /**
    * Whether to stop in the debugger on the exceptions.
    * @type {boolean}
    */
   this.pauseOnExceptions_ = true;
 
   /**
    * Mapping: request sequence number->callback.
    * @type {Object}
    */
   this.requestSeqToCallback_ = null;
 
   /**
    * Whether the scripts list has been requested.
    * @type {boolean}
    */
   this.scriptsCacheInitialized_ = false;
 
   /**
-   * Whether user has stopped profiling and we are retrieving the rest of
-   * profiler's log.
-   * @type {boolean}
-   */
-  this.isProcessingProfile_ = false;
-
-  /**
-   * The position in log file to read from.
+   * Active profiler modules flags.
    * @type {number}
    */
-  this.lastProfileLogPosition_ = 0;
+  this.activeProfilerModules_ =
+      devtools.DebuggerAgent.ProfilerModules.PROFILER_MODULE_NONE;
 
   /**
    * Profiler processor instance.
    * @type {devtools.profiler.Processor}
    */
   this.profilerProcessor_ = new devtools.profiler.Processor();
+
+  /**
+   * Container of all breakpoints set using resource URL. These breakpoints
+   * survive page reload. Breakpoints set by script id(for scripts that don't
+   * have URLs) are stored in ScriptInfo objects.
+   * @type {Object}
+   */
+  this.urlToBreakpoints_ = {};
+
+
+  /**
+   * Exception message that is shown to user while on exception break.
+   * @type {WebInspector.ConsoleMessage}
+   */
+  this.currentExceptionMessage_ = null;
 };
 
 
+/**
+ * A copy of the scope types from v8/src/mirror-delay.js
+ * @enum {number}
+ */
+devtools.DebuggerAgent.ScopeType = {
+  Global: 0,
+  Local: 1,
+  With: 2,
+  Closure: 3
+};
+
+
+/**
+ * A no-op JS expression that is sent to the inspected page in order to force v8
+ * execution.
+ */
+devtools.DebuggerAgent.VOID_SCRIPT = 'javascript:void(0)';
+
+
+/**
+ * A copy of enum from include/v8.h
+ * @enum {number}
+ */
+devtools.DebuggerAgent.ProfilerModules = {
+  PROFILER_MODULE_NONE: 0,
+  PROFILER_MODULE_CPU: 1,
+  PROFILER_MODULE_HEAP_STATS: 1 << 1,
+  PROFILER_MODULE_JS_CONSTRUCTORS: 1 << 2,
+  PROFILER_MODULE_HEAP_SNAPSHOT: 1 << 16
+};
+
+
 /**
  * Resets debugger agent to its initial state.
  */
 devtools.DebuggerAgent.prototype.reset = function() {
-  this.scriptsCacheInitialized_ = false;
   this.contextId_ = null;
   this.parsedScripts_ = {};
   this.requestNumberToBreakpointInfo_ = {};
-  this.currentCallFrame_ = null;
+  this.callFrames_ = [];
   this.requestSeqToCallback_ = {};
+
+  // Profiler isn't reset because it contains no data that is
+  // specific for a particular V8 instance. All such data is
+  // managed by an agent on the Render's side.
 };
 
 
 /**
- * Requests scripts list if it has not been requested yet.
+ * Initializes scripts UI. Asynchronously requests for all parsed scripts
+ * if necessary. Response will be processed in handleScriptsResponse_.
  */
-devtools.DebuggerAgent.prototype.initializeScriptsCache = function() {
-  if (!this.scriptsCacheInitialized_) {
-    this.scriptsCacheInitialized_ = true;
-    this.requestScripts();
+devtools.DebuggerAgent.prototype.initUI = function() {
+  // There can be a number of scripts from after-compile events that are
+  // pending addition into the UI.
+  for (var scriptId in this.parsedScripts_) {
+    var script = this.parsedScripts_[scriptId];
+    WebInspector.parsedScriptSource(scriptId, script.getUrl(),
+        undefined /* script source */, script.getLineOffset());
   }
-};
 
-
-/**
- * Asynchronously requests for all parsed script sources. Response will be
- * processed in handleScriptsResponse_.
- */
-devtools.DebuggerAgent.prototype.requestScripts = function() {
-  if (this.contextId_ === null) {
-    // Update context id first to filter the scripts.
-    RemoteDebuggerAgent.GetContextId();
+  if (this.contextId_) {
+    // We already have context id. This means that we are here from the
+    // very beginning of the page load cycle and hence will get all scripts
+    // via after-compile events. No need to request scripts for this session.
     return;
   }
+
+  RemoteDebuggerAgent.GetContextId();
   var cmd = new devtools.DebugCommand('scripts', {
     'includeSource': false
   });
   devtools.DebuggerAgent.sendCommand_(cmd);
   // Force v8 execution so that it gets to processing the requested command.
-  devtools.tools.evaluateJavaScript('javascript:void(0)');
+  devtools.tools.evaluateJavaScript(devtools.DebuggerAgent.VOID_SCRIPT);
 };
 
 
 /**
  * Asynchronously requests the debugger for the script source.
  * @param {number} scriptId Id of the script whose source should be resolved.
  * @param {function(source:?string):void} callback Function that will be called
  *     when the source resolution is completed. 'source' parameter will be null
  *     if the resolution fails.
  */
 devtools.DebuggerAgent.prototype.resolveScriptSource = function(
     scriptId, callback) {
   var script = this.parsedScripts_[scriptId];
-  if (!script) {
+  if (!script || script.isUnresolved()) {
     callback(null);
     return;
   }
 
   var cmd = new devtools.DebugCommand('scripts', {
     'ids': [scriptId],
     'includeSource': true
   });
   devtools.DebuggerAgent.sendCommand_(cmd);
   // Force v8 execution so that it gets to processing the requested command.
-  devtools.tools.evaluateJavaScript('javascript:void(0)');
+  devtools.tools.evaluateJavaScript(devtools.DebuggerAgent.VOID_SCRIPT);
 
   this.requestSeqToCallback_[cmd.getSequenceNumber()] = function(msg) {
     if (msg.isSuccess()) {
       var scriptJson = msg.getBody()[0];
       callback(scriptJson.source);
     } else {
       callback(null);
     }
   };
 };
@@ skipping 12 matching lines @@
  * @param {number} line Number of the line for the breakpoint.
  */
 devtools.DebuggerAgent.prototype.addBreakpoint = function(sourceId, line) {
   var script = this.parsedScripts_[sourceId];
   if (!script) {
     return;
   }
 
   line = devtools.DebuggerAgent.webkitToV8LineNumber_(line);
 
-  var breakpointInfo = script.getBreakpointInfo(line);
-  if (breakpointInfo) {
-    return;
+  var commandArguments;
+  if (script.getUrl()) {
+    var breakpoints = this.urlToBreakpoints_[script.getUrl()];
+    if (breakpoints && breakpoints[line]) {
+      return;
+    }
+    if (!breakpoints) {
+      breakpoints = {};
+      this.urlToBreakpoints_[script.getUrl()] = breakpoints;
+    }
+
+    var breakpointInfo = new devtools.BreakpointInfo(line);
+    breakpoints[line] = breakpointInfo;
+
+    commandArguments = {
+      'groupId': this.contextId_,
+      'type': 'script',
+      'target': script.getUrl(),
+      'line': line
+    };
+  } else {
+    var breakpointInfo = script.getBreakpointInfo(line);
+    if (breakpointInfo) {
+      return;
+    }
+
+    breakpointInfo = new devtools.BreakpointInfo(line);
+    script.addBreakpointInfo(breakpointInfo);
+
+    commandArguments = {
+      'groupId': this.contextId_,
+      'type': 'scriptId',
+      'target': sourceId,
+      'line': line
+    };
   }
 
-  breakpointInfo = new devtools.BreakpointInfo(sourceId, line);
-  script.addBreakpointInfo(breakpointInfo);
-
-  var cmd = new devtools.DebugCommand('setbreakpoint', {
-    'type': 'scriptId',
-    'target': sourceId,
-    'line': line
-  });
+  var cmd = new devtools.DebugCommand('setbreakpoint', commandArguments);
 
   this.requestNumberToBreakpointInfo_[cmd.getSequenceNumber()] = breakpointInfo;
 
   devtools.DebuggerAgent.sendCommand_(cmd);
 };
 
 
 /**
  * @param {number} sourceId Id of the script fot the breakpoint.
  * @param {number} line Number of the line for the breakpoint.
  */
 devtools.DebuggerAgent.prototype.removeBreakpoint = function(sourceId, line) {
   var script = this.parsedScripts_[sourceId];
   if (!script) {
     return;
   }
 
   line = devtools.DebuggerAgent.webkitToV8LineNumber_(line);
 
-  var breakpointInfo = script.getBreakpointInfo(line);
-  script.removeBreakpointInfo(breakpointInfo);
+  var breakpointInfo;
+  if (script.getUrl()) {
+    var breakpoints = this.urlToBreakpoints_[script.getUrl()];
+    breakpointInfo = breakpoints[line];
+    delete breakpoints[line];
+  } else {
+    breakpointInfo = script.getBreakpointInfo(line);
+    if (breakpointInfo) {
+      script.removeBreakpointInfo(breakpointInfo);
+    }
+  }
+
+  if (!breakpointInfo) {
+    return;
+  }
+
   breakpointInfo.markAsRemoved();
 
   var id = breakpointInfo.getV8Id();
 
   // If we don't know id of this breakpoint in the v8 debugger we cannot send
   // 'clearbreakpoint' request. In that case it will be removed in
   // 'setbreakpoint' response handler when we learn the id.
   if (id != -1) {
     this.requestClearBreakpoint_(id);
   }
@@ skipping 22 matching lines @@
 devtools.DebuggerAgent.prototype.stepOverStatement = function() {
   this.stepCommand_('next');
 };
 
 
 /**
  * Tells the v8 debugger to continue execution after it has been stopped on a
  * breakpoint or an exception.
  */
 devtools.DebuggerAgent.prototype.resumeExecution = function() {
+  this.clearExceptionMessage_();
   var cmd = new devtools.DebugCommand('continue');
   devtools.DebuggerAgent.sendCommand_(cmd);
 };
 
 
 /**
+ * Creates exception message and schedules it for addition to the resource upon
+ * backtrace availability.
+ * @param {string} url Resource url.
+ * @param {number} line Resource line number.
+ * @param {string} message Exception text.
+ */
+devtools.DebuggerAgent.prototype.createExceptionMessage_ = function(
+    url, line, message) {
+  this.currentExceptionMessage_ = new WebInspector.ConsoleMessage(
+      WebInspector.ConsoleMessage.MessageSource.JS,
+      WebInspector.ConsoleMessage.MessageType.Log,
+      WebInspector.ConsoleMessage.MessageLevel.Error,
+      line,
+      url,
+      0 /* group level */,
+      1 /* repeat count */,
+      '[Exception] ' + message);
+};
+
+
+/**
+ * Shows pending exception message that is created with createExceptionMessage_
+ * earlier.
+ */
+devtools.DebuggerAgent.prototype.showPendingExceptionMessage_ = function() {
+  if (!this.currentExceptionMessage_) {
+    return;
+  }
+  var msg = this.currentExceptionMessage_;
+  var resource = WebInspector.resourceURLMap[msg.url];
+  if (resource) {
+    msg.resource = resource;
+    WebInspector.panels.resources.addMessageToResource(resource, msg);
+  } else {
+    this.currentExceptionMessage_ = null;
+  }
+};
+
+
+/**
+ * Clears exception message from the resource.
+ */
+devtools.DebuggerAgent.prototype.clearExceptionMessage_ = function() {
+  if (this.currentExceptionMessage_) {
+    var messageElement =
+        this.currentExceptionMessage_._resourceMessageLineElement;
+    var bubble = messageElement.parentElement;
+    bubble.removeChild(messageElement);
+    if (!bubble.firstChild) {
+      // Last message in bubble removed.
+      bubble.parentElement.removeChild(bubble);
+    }
+    this.currentExceptionMessage_ = null;
+  }
+};
+
+
+/**
  * @return {boolean} True iff the debugger will pause execution on the
  * exceptions.
  */
 devtools.DebuggerAgent.prototype.pauseOnExceptions = function() {
   return this.pauseOnExceptions_;
 };
 
 
 /**
  * Tells whether to pause in the debugger on the exceptions or not.
  * @param {boolean} value True iff execution should be stopped in the debugger
  * on the exceptions.
  */
 devtools.DebuggerAgent.prototype.setPauseOnExceptions = function(value) {
   this.pauseOnExceptions_ = value;
 };
 
 
 /**
- * Current stack top frame.
- * @return {devtools.CallFrame}
- */
-devtools.DebuggerAgent.prototype.getCurrentCallFrame = function() {
-  return this.currentCallFrame_;
-};
-
-
-/**
  * Sends 'evaluate' request to the debugger.
  * @param {Object} arguments Request arguments map.
  * @param {function(devtools.DebuggerMessage)} callback Callback to be called
  *     when response is received.
  */
 devtools.DebuggerAgent.prototype.requestEvaluate = function(
     arguments, callback) {
   var cmd = new devtools.DebugCommand('evaluate', arguments);
   devtools.DebuggerAgent.sendCommand_(cmd);
   this.requestSeqToCallback_[cmd.getSequenceNumber()] = callback;
 };
 
 
 /**
  * Sends 'lookup' request for each unresolved property of the object. When
  * response is received the properties will be changed with their resolved
  * values.
  * @param {Object} object Object whose properties should be resolved.
  * @param {function(devtools.DebuggerMessage)} Callback to be called when all
  *     children are resolved.
+ * @param {boolean} noIntrinsic Whether intrinsic properties should be included.
  */
-devtools.DebuggerAgent.prototype.resolveChildren = function(object, callback) {
-  if ('ref' in object) {
+devtools.DebuggerAgent.prototype.resolveChildren = function(object, callback,
+                                                            noIntrinsic) {
+  if ('handle' in object) {
+    var result = [];
+    devtools.DebuggerAgent.formatObjectProperties_(object, result,
+                                                   noIntrinsic);
+    callback(result);
+  } else {
     this.requestLookup_([object.ref], function(msg) {
-      var result = {};
+      var result = [];
       if (msg.isSuccess()) {
         var handleToObject = msg.getBody();
         var resolved = handleToObject[object.ref];
-        devtools.DebuggerAgent.formatObjectProperties_(resolved, result);
+        devtools.DebuggerAgent.formatObjectProperties_(resolved, result,
+                                                       noIntrinsic);
+        callback(result);
       } else {
-        result.error = 'Failed to resolve children: ' + msg.getMessage();
+        callback([]);
       }
-      object.resolvedValue = result;
-      callback(object);
     });
-
-    return;
-  } else {
-    if (!object.resolvedValue) {
-      var message = 'Corrupted object: ' + JSON.stringify(object);
-      object.resolvedValue = {};
-      object.resolvedValue.error = message;
-    }
-    callback(object);
   }
 };
 
 
 /**
- * Starts (resumes) profiling.
+ * Sends 'scope' request for the scope object to resolve its variables.
+ * @param {Object} scope Scope to be resolved.
+ * @param {function(Array.<WebInspector.ObjectPropertyProxy>)} callback
+ *     Callback to be called when all scope variables are resolved.
  */
-devtools.DebuggerAgent.prototype.startProfiling = function() {
-  if (this.isProcessingProfile_) {
-    return;
-  }
-  RemoteDebuggerAgent.StartProfiling();
-  // Query if profiling has been really started.
-  RemoteDebuggerAgent.IsProfilingStarted();
+devtools.DebuggerAgent.prototype.resolveScope = function(scope, callback) {
+  var cmd = new devtools.DebugCommand('scope', {
+    'frameNumber': scope.frameNumber,
+    'number': scope.index,
+    'compactFormat': true
+  });
+  devtools.DebuggerAgent.sendCommand_(cmd);
+  this.requestSeqToCallback_[cmd.getSequenceNumber()] = function(msg) {
+      var result = [];
+    if (msg.isSuccess()) {
+      var scopeObjectJson = msg.getBody().object;
+      devtools.DebuggerAgent.formatObjectProperties_(scopeObjectJson, result,
+                                                     true /* no intrinsic */);
+    }
+    callback(result);
+  };
 };
 
 
 /**
- * Stops (pauses) profiling.
+ * Sets up callbacks that deal with profiles processing.
  */
-devtools.DebuggerAgent.prototype.stopProfiling = function() {
-  this.isProcessingProfile_ = true;
-  RemoteDebuggerAgent.StopProfiling();
+devtools.DebuggerAgent.prototype.setupProfilerProcessorCallbacks = function() {
+  // A temporary icon indicating that the profile is being processed.
+  var processingIcon = new WebInspector.SidebarTreeElement(
+      'profile-sidebar-tree-item',
+      WebInspector.UIString('Processing...'),
+      '', null, false);
+  var profilesSidebar = WebInspector.panels.profiles.sidebarTree;
+
+  this.profilerProcessor_.setCallbacks(
+      function onProfileProcessingStarted() {
+        // Set visually empty string. Subtitle hiding is done via styles
+        // manipulation which doesn't play well with dynamic append / removal.
+        processingIcon.subtitle = ' ';
+        profilesSidebar.appendChild(processingIcon);
+      },
+      function onProfileProcessingStatus(ticksCount) {
+        processingIcon.subtitle =
+            WebInspector.UIString('%d ticks processed', ticksCount);
+      },
+      function onProfileProcessingFinished(profile) {
+        profilesSidebar.removeChild(processingIcon);
+        WebInspector.addProfile(profile);
+        // If no profile is currently shown, show the new one.
+        var profilesPanel = WebInspector.panels.profiles;
+        if (!profilesPanel.visibleView) {
+          profilesPanel.showProfile(profile);
+        }
+      }
+  );
 };
 
 
+/**
+ * Initializes profiling state.
+ */
+devtools.DebuggerAgent.prototype.initializeProfiling = function() {
+  this.setupProfilerProcessorCallbacks();
+  RemoteDebuggerAgent.GetActiveProfilerModules();
+};
+
+
+/**
+ * Starts profiling.
+ * @param {number} modules List of modules to enable.
+ */
+devtools.DebuggerAgent.prototype.startProfiling = function(modules) {
+  RemoteDebuggerAgent.StartProfiling(modules);
+  if (modules &
+      devtools.DebuggerAgent.ProfilerModules.PROFILER_MODULE_HEAP_SNAPSHOT) {
+    // Active modules will not change, instead, a snapshot will be logged.
+    RemoteDebuggerAgent.GetNextLogLines();
+  } else {
+    RemoteDebuggerAgent.GetActiveProfilerModules();
+  }
+};
+
+
+/**
+ * Stops profiling.
+ */
+devtools.DebuggerAgent.prototype.stopProfiling = function(modules) {
+  RemoteDebuggerAgent.StopProfiling(modules);
+};
+
+
+/**
+ * @param{number} scriptId
+ * @return {string} Type of the context of the script with specified id.
+ */
+devtools.DebuggerAgent.prototype.getScriptContextType = function(scriptId) {
+  return this.parsedScripts_[scriptId].getContextType();
+};
+
+
 /**
  * Removes specified breakpoint from the v8 debugger.
  * @param {number} breakpointId Id of the breakpoint in the v8 debugger.
  */
 devtools.DebuggerAgent.prototype.requestClearBreakpoint_ = function(
     breakpointId) {
   var cmd = new devtools.DebugCommand('clearbreakpoint', {
     'breakpoint': breakpointId
   });
   devtools.DebuggerAgent.sendCommand_(cmd);
@@ skipping 18 matching lines @@
 devtools.DebuggerAgent.sendCommand_ = function(cmd) {
   RemoteDebuggerCommandExecutor.DebuggerCommand(cmd.toJSONProtocol());
 };
 
 
 /**
  * Tells the v8 debugger to make the next execution step.
  * @param {string} action 'in', 'out' or 'next' action.
  */
 devtools.DebuggerAgent.prototype.stepCommand_ = function(action) {
+  this.clearExceptionMessage_();
   var cmd = new devtools.DebugCommand('continue', {
     'stepaction': action,
     'stepcount': 1
   });
   devtools.DebuggerAgent.sendCommand_(cmd);
 };
 
 
 /**
  * Sends 'lookup' request to v8.
  * @param {number} handle Handle to the object to lookup.
  */
 devtools.DebuggerAgent.prototype.requestLookup_ = function(handles, callback) {
   var cmd = new devtools.DebugCommand('lookup', {
     'compactFormat':true,
     'handles': handles
   });
   devtools.DebuggerAgent.sendCommand_(cmd);
   this.requestSeqToCallback_[cmd.getSequenceNumber()] = callback;
 };
 
 
 /**
- * Handles GetContextId response.
+ * Sets debugger context id for scripts filtering.
  * @param {number} contextId Id of the inspected page global context.
  */
-devtools.DebuggerAgent.prototype.didGetContextId_ = function(contextId) {
+devtools.DebuggerAgent.prototype.setContextId_ = function(contextId) {
   this.contextId_ = contextId;
-  // Update scripts.
-  this.requestScripts();
 };
 
 
 /**
  * Handles output sent by v8 debugger. The output is either asynchronous event
  * or response to a previously sent request.  See protocol definitioun for more
  * details on the output format.
  * @param {string} output
  */
 devtools.DebuggerAgent.prototype.handleDebuggerOutput_ = function(output) {
   var msg;
   try {
     msg = new devtools.DebuggerMessage(output);
   } catch(e) {
     debugPrint('Failed to handle debugger reponse:\n' + e);
     throw e;
   }
 
-
   if (msg.getType() == 'event') {
     if (msg.getEvent() == 'break') {
       this.handleBreakEvent_(msg);
     } else if (msg.getEvent() == 'exception') {
       this.handleExceptionEvent_(msg);
     } else if (msg.getEvent() == 'afterCompile') {
       this.handleAfterCompileEvent_(msg);
     }
   } else if (msg.getType() == 'response') {
     if (msg.getCommand() == 'scripts') {
       this.handleScriptsResponse_(msg);
     } else if (msg.getCommand() == 'setbreakpoint') {
       this.handleSetBreakpointResponse_(msg);
     } else if (msg.getCommand() == 'clearbreakpoint') {
       this.handleClearBreakpointResponse_(msg);
     } else if (msg.getCommand() == 'backtrace') {
       this.handleBacktraceResponse_(msg);
     } else if (msg.getCommand() == 'lookup') {
       this.invokeCallbackForResponse_(msg);
     } else if (msg.getCommand() == 'evaluate') {
       this.invokeCallbackForResponse_(msg);
+    } else if (msg.getCommand() == 'scope') {
+      this.invokeCallbackForResponse_(msg);
     }
   }
 };
 
 
 /**
  * @param {devtools.DebuggerMessage} msg
  */
 devtools.DebuggerAgent.prototype.handleBreakEvent_ = function(msg) {
+  // Force scrips panel to be shown first.
+  WebInspector.currentPanel = WebInspector.panels.scripts;
+
   var body = msg.getBody();
 
   var line = devtools.DebuggerAgent.v8ToWwebkitLineNumber_(body.sourceLine);
-  this.currentCallFrame_ = new devtools.CallFrame();
-  this.currentCallFrame_.sourceID = body.script.id;
-  this.currentCallFrame_.line = line;
-  this.currentCallFrame_.script = body.script;
   this.requestBacktrace_();
 };
 
 
 /**
  * @param {devtools.DebuggerMessage} msg
  */
 devtools.DebuggerAgent.prototype.handleExceptionEvent_ = function(msg) {
+  // Force scrips panel to be shown first.
+  WebInspector.currentPanel = WebInspector.panels.scripts;
+
   var body = msg.getBody();
-  debugPrint('Uncaught exception in ' + body.script.name + ':' +
-             body.sourceLine + '\n' + body.sourceLineText);
   if (this.pauseOnExceptions_) {
     var body = msg.getBody();
-
-    var sourceId = -1;
-    // The exception may happen in native code in which case there is no script.
-    if (body.script) {
-      sourceId = body.script.id;
-    }
-
     var line = devtools.DebuggerAgent.v8ToWwebkitLineNumber_(body.sourceLine);
-
-    this.currentCallFrame_ = new devtools.CallFrame();
-    this.currentCallFrame_.sourceID = sourceId;
-    this.currentCallFrame_.line = line;
-    this.currentCallFrame_.script = body.script;
+    this.createExceptionMessage_(body.script.name, line, body.exception.text);
     this.requestBacktrace_();
   } else {
     this.resumeExecution();
   }
 };
 
 
 /**
  * @param {devtools.DebuggerMessage} msg
  */
 devtools.DebuggerAgent.prototype.handleScriptsResponse_ = function(msg) {
   if (this.invokeCallbackForResponse_(msg)) {
     return;
   }
 
   var scripts = msg.getBody();
   for (var i = 0; i < scripts.length; i++) {
     var script = scripts[i];
 
     // Skip scripts from other tabs.
     if (!this.isScriptFromInspectedContext_(script, msg)) {
       continue;
     }
 
+    // There is no script source
+    if (this.isVoidScript_(script)) {
+      continue;
+    }
+
     // We may already have received the info in an afterCompile event.
     if (script.id in this.parsedScripts_) {
       continue;
     }
-    this.addScriptInfo_(script);
+    this.addScriptInfo_(script, msg);
   }
 };
 
 
 /**
  * @param {Object} script Json object representing script.
  * @param {devtools.DebuggerMessage} msg Debugger response.
  */
 devtools.DebuggerAgent.prototype.isScriptFromInspectedContext_ = function(
     script, msg) {
   if (!script.context) {
     // Always ignore scripts from the utility context.
     return false;
   }
   var context = msg.lookup(script.context.ref);
   var scriptContextId = context.data;
   if (!goog.isDef(scriptContextId)) {
     return false; // Always ignore scripts from the utility context.
   }
   if (this.contextId_ === null) {
     return true;
   }
-  return (scriptContextId == this.contextId_);
+  return (scriptContextId.value == this.contextId_);
 };
 
 
 /**
  * @param {devtools.DebuggerMessage} msg
  */
 devtools.DebuggerAgent.prototype.handleSetBreakpointResponse_ = function(msg) {
   var requestSeq = msg.getRequestSeq();
   var breakpointInfo = this.requestNumberToBreakpointInfo_[requestSeq];
   if (!breakpointInfo) {
@@ skipping 11 matching lines @@
   if (breakpointInfo.isRemoved()) {
     this.requestClearBreakpoint_(idInV8);
   }
 };
 
 
 /**
  * @param {devtools.DebuggerMessage} msg
  */
 devtools.DebuggerAgent.prototype.handleAfterCompileEvent_ = function(msg) {
+  if (!this.contextId_) {
+    // Ignore scripts delta if main request has not been issued yet.
+    return;
+  }
   var script = msg.getBody().script;
+
+  if (this.isVoidScript_(script)) {
+    return;
+  }
+
   // Ignore scripts from other tabs.
   if (!this.isScriptFromInspectedContext_(script, msg)) {
     return;
   }
-  this.addScriptInfo_(script);
+  this.addScriptInfo_(script, msg);
+};
+
+
+/**
+ * @param {Object} script Parsed JSON object representing script.
+ * @return {boolean} Whether the script is a result of the void script
+ *     evaluation and should not appear in the UI.
+ */
+devtools.DebuggerAgent.prototype.isVoidScript_ = function(script) {
+  return !script.name &&
+         (script.sourceStart == devtools.DebuggerAgent.VOID_SCRIPT ||
+          script.source == devtools.DebuggerAgent.VOID_SCRIPT);
 };
 
 
 /**
  * Handles current profiler status.
+ * @param {number} modules List of active (started) modules.
  */
-devtools.DebuggerAgent.prototype.didIsProfilingStarted_ = function(
-    is_started) {
-  if (is_started) {
+devtools.DebuggerAgent.prototype.didGetActiveProfilerModules_ = function(
+    modules) {
+  var profModules = devtools.DebuggerAgent.ProfilerModules;
+  var profModuleNone = profModules.PROFILER_MODULE_NONE;
+  if (modules != profModuleNone &&
+      this.activeProfilerModules_ == profModuleNone) {
     // Start to query log data.
-    RemoteDebuggerAgent.GetLogLines(this.lastProfileLogPosition_);
+    RemoteDebuggerAgent.GetNextLogLines();
   }
-  WebInspector.setRecordingProfile(is_started);
+  this.activeProfilerModules_ = modules;
+  // Update buttons.
+  WebInspector.setRecordingProfile(modules & profModules.PROFILER_MODULE_CPU);
+  if (modules != profModuleNone) {
+    // Monitor profiler state. It can stop itself on buffer fill-up.
+    setTimeout(
+        function() { RemoteDebuggerAgent.GetActiveProfilerModules(); }, 1000);
+  }
 };
 
 
 /**
- * Handles a portion of a profiler log retrieved by GetLogLines call.
+ * Handles a portion of a profiler log retrieved by GetNextLogLines call.
  * @param {string} log A portion of profiler log.
- * @param {number} newPosition The position in log file to read from
- *     next time.
  */
-devtools.DebuggerAgent.prototype.didGetLogLines_ = function(
-    log, newPosition) {
+devtools.DebuggerAgent.prototype.didGetNextLogLines_ = function(log) {
   if (log.length > 0) {
     this.profilerProcessor_.processLogChunk(log);
-    this.lastProfileLogPosition_ = newPosition;
-  } else if (this.isProcessingProfile_) {
-    this.isProcessingProfile_ = false;
-    WebInspector.setRecordingProfile(false);
-    WebInspector.addProfile(this.profilerProcessor_.createProfileForView());
+  } else if (this.activeProfilerModules_ ==
+      devtools.DebuggerAgent.ProfilerModules.PROFILER_MODULE_NONE) {
+    // No new data and profiling is stopped---suspend log reading.
     return;
   }
-  setTimeout(function() { RemoteDebuggerAgent.GetLogLines(newPosition); },
-    this.isProcessingProfile_ ? 100 : 1000);
+  setTimeout(function() { RemoteDebuggerAgent.GetNextLogLines(); }, 500);
 };
 
 
 /**
  * Adds the script info to the local cache. This method assumes that the script
  * is not in the cache yet.
  * @param {Object} script Script json object from the debugger message.
+ * @param {devtools.DebuggerMessage} msg Debugger message containing the script
+ *     data.
  */
-devtools.DebuggerAgent.prototype.addScriptInfo_ = function(script) {
+devtools.DebuggerAgent.prototype.addScriptInfo_ = function(script, msg) {
+  var context = msg.lookup(script.context.ref);
+  var contextType = context.data.type;
   this.parsedScripts_[script.id] = new devtools.ScriptInfo(
-      script.id, script.lineOffset);
-  WebInspector.parsedScriptSource(
-      script.id, script.name, script.source, script.lineOffset);
+      script.id, script.name, script.lineOffset, contextType);
+  if (WebInspector.panels.scripts.element.parentElement) {
+    // Only report script as parsed after scripts panel has been shown.
+    WebInspector.parsedScriptSource(
+        script.id, script.name, script.source, script.lineOffset);
+  }
 };
 
 
 /**
  * @param {devtools.DebuggerMessage} msg
  */
 devtools.DebuggerAgent.prototype.handleClearBreakpointResponse_ = function(
     msg) {
   // Do nothing.
 };
 
 
 /**
  * Handles response to 'backtrace' command.
  * @param {devtools.DebuggerMessage} msg
  */
 devtools.DebuggerAgent.prototype.handleBacktraceResponse_ = function(msg) {
-  if (!this.currentCallFrame_) {
-    return;
+  var frames = msg.getBody().frames;
+  this.callFrames_ = [];
+  for (var i = 0; i <  frames.length; ++i) {
+    this.callFrames_.push(this.formatCallFrame_(frames[i]));
   }
-
-  var script = this.currentCallFrame_.script;
-
-  var callerFrame = null;
-  var f = null;
-  var frames = msg.getBody().frames;
-  for (var i = frames.length - 1; i>=0; i--) {
-    var nextFrame = frames[i];
-    var f = devtools.DebuggerAgent.formatCallFrame_(nextFrame, script, msg);
-    f.frameNumber = i;
-    f.caller = callerFrame;
-    callerFrame = f;
-  }
-
-  this.currentCallFrame_ = f;
-
-  WebInspector.pausedScript();
+  WebInspector.pausedScript(this.callFrames_);
+  this.showPendingExceptionMessage_();
   DevToolsHost.activateWindow();
 };
 
 
+/**
+ * Returns current suspended stack.
+ */
+devtools.DebuggerAgent.prototype.getCallFrames = function(callback) {
+  return this.callFrames_;
+};
+
+
+/**
+ * Evaluates code on given callframe.
+ */
+devtools.DebuggerAgent.prototype.evaluateInCallFrame = function(
+    callFrameId, code, callback) {
+  var callFrame = this.callFrames_[callFrameId];
+  callFrame.evaluate_(code, callback);
+};
+
+
 /**
  * Handles response to a command by invoking its callback (if any).
  * @param {devtools.DebuggerMessage} msg
  * @return {boolean} Whether a callback for the given message was found and
  *     excuted.
  */
 devtools.DebuggerAgent.prototype.invokeCallbackForResponse_ = function(msg) {
   var callback = this.requestSeqToCallback_[msg.getRequestSeq()];
   if (!callback) {
     // It may happend if reset was called.
     return false;
   }
   delete this.requestSeqToCallback_[msg.getRequestSeq()];
   callback(msg);
   return true;
 };
 
 
-devtools.DebuggerAgent.prototype.evaluateInCallFrame_ = function(expression) {
-};
-
-
 /**
  * @param {Object} stackFrame Frame json object from 'backtrace' response.
- * @param {Object} script Script json object from 'break' event.
- * @param {devtools.DebuggerMessage} msg Parsed 'backtrace' response.
  * @return {!devtools.CallFrame} Object containing information related to the
  *     call frame in the format expected by ScriptsPanel and its panes.
  */
-devtools.DebuggerAgent.formatCallFrame_ = function(stackFrame, script, msg) {
-  var sourceId = script.id;
-
+devtools.DebuggerAgent.prototype.formatCallFrame_ = function(stackFrame) {
   var func = stackFrame.func;
   var sourceId = func.scriptId;
+
+  // Add service script if it does not exist.
+  var existingScript = this.parsedScripts_[sourceId];
+  if (!existingScript) {
+    this.parsedScripts_[sourceId] = new devtools.ScriptInfo(
+        sourceId, null /* name */, 0 /* line */, 'unknown' /* type */,
+        true /* unresolved */);
+    WebInspector.parsedScriptSource(sourceId, null, null, 0);
+  }
+
   var funcName = func.name || func.inferredName || '(anonymous function)';
+  var line = devtools.DebuggerAgent.v8ToWwebkitLineNumber_(stackFrame.line);
 
-  var scope = {};
-
-  // Add arguments.
-  devtools.DebuggerAgent.argumentsArrayToMap_(stackFrame.arguments, scope);
-
-  // Add local variables.
-  devtools.DebuggerAgent.propertiesToMap_(stackFrame.locals, scope);
-
-  var thisObject = devtools.DebuggerAgent.formatObjectReference_(
-      stackFrame.receiver);
-  // Add variable with name 'this' to the scope.
-  scope['this'] = thisObject;
-
-  var line = devtools.DebuggerAgent.v8ToWwebkitLineNumber_(stackFrame.line);
-  var result = new devtools.CallFrame();
-  result.sourceID = sourceId;
-  result.line = line;
-  result.type = 'function';
-  result.functionName = funcName;
-  result.localScope = scope;
-  result.scopeChain = [scope];
-  result.thisObject = thisObject;
-  return result;
+  // Add basic scope chain info with scope variables.
+  var scopeChain = [];
+  var ScopeType = devtools.DebuggerAgent.ScopeType;
+  for (var i = 0; i < stackFrame.scopes.length; i++) {
+    var scope = stackFrame.scopes[i];
+    scope.frameNumber = stackFrame.index;
+    var scopeObjectProxy = new WebInspector.ObjectProxy(scope, [], 0, '', true);
+    scopeObjectProxy.isScope = true;
+    scopeObjectProxy.properties = {};  // TODO(pfeldman): Fix autocomplete.
+    switch(scope.type) {
+      case ScopeType.Global:
+        scopeObjectProxy.isDocument = true;
+        break;
+      case ScopeType.Local:
+        scopeObjectProxy.isLocal = true;
+        scopeObjectProxy.thisObject =
+            devtools.DebuggerAgent.formatObjectProxy_(stackFrame.receiver);
+        break;
+      case ScopeType.With:
+        scopeObjectProxy.isWithBlock = true;
+        break;
+      case ScopeType.Closure:
+        scopeObjectProxy.isClosure = true;
+        break;
+    }
+    scopeChain.push(scopeObjectProxy);
+  }
+  return new devtools.CallFrame(stackFrame.index, 'function', funcName,
+      sourceId, line, scopeChain);
 };
 
 
 /**
  * Collects properties for an object from the debugger response.
  * @param {Object} object An object from the debugger protocol response.
- * @param {Object} result A map to put the properties in.
+ * @param {Array.<WebInspector.ObjectPropertyProxy>} result An array to put the
+ *     properties into.
+ * @param {boolean} noIntrinsic Whether intrinsic properties should be
+ *     included.
  */
-devtools.DebuggerAgent.formatObjectProperties_ = function(object, result) {
-  devtools.DebuggerAgent.propertiesToMap_(object.properties, result);
-  result.protoObject = devtools.DebuggerAgent.formatObjectReference_(
-      object.protoObject);
-  result.prototypeObject = devtools.DebuggerAgent.formatObjectReference_(
-      object.prototypeObject);
-  result.constructorFunction = devtools.DebuggerAgent.formatObjectReference_(
-      object.constructorFunction);
+devtools.DebuggerAgent.formatObjectProperties_ = function(object, result,
+                                                          noIntrinsic) {
+  devtools.DebuggerAgent.propertiesToProxies_(object.properties, result);
+  if (noIntrinsic) {
+    return;
+  }
+
+  result.push(new WebInspector.ObjectPropertyProxy('__proto__',
+      devtools.DebuggerAgent.formatObjectProxy_(object.protoObject)));
+  result.push(new WebInspector.ObjectPropertyProxy('prototype',
+      devtools.DebuggerAgent.formatObjectProxy_(object.prototypeObject)));
+  result.push(new WebInspector.ObjectPropertyProxy('constructor',
+      devtools.DebuggerAgent.formatObjectProxy_(object.constructorFunction)));
 };
 
 
 /**
- * For each property in 'properties' puts its name and user-friendly value into
- * 'map'.
+ * For each property in 'properties' creates its proxy representative.
  * @param {Array.<Object>} properties Receiver properties or locals array from
  *     'backtrace' response.
- * @param {Object} map Result holder.
+ * @param {Array.<WebInspector.ObjectPropertyProxy>} Results holder.
  */
-devtools.DebuggerAgent.propertiesToMap_ = function(properties, map) {
-  for (var j = 0; j < properties.length; j++) {
-    var nextValue = properties[j];
-    // Skip unnamed properties. They may appear e.g. when number of actual
-    // parameters is greater the that of formal. In that case the superfluous
-    // parameters will be present in the arguments list as elements without
-    // names.
-    if (nextValue.name) {
-      map[nextValue.name] =
-          devtools.DebuggerAgent.formatObjectReference_(nextValue.value);
+devtools.DebuggerAgent.propertiesToProxies_ = function(properties, result) {
+  var map = {};
+  for (var i = 0; i < properties.length; ++i) {
+    var property = properties[i];
+    var name = String(property.name);
+    if (name in map) {
+      continue;
     }
+    map[name] = true;
+    var value = devtools.DebuggerAgent.formatObjectProxy_(property.value);
+    var propertyProxy = new WebInspector.ObjectPropertyProxy(name, value);
+    result.push(propertyProxy);
   }
 };
 
-
-/**
- * Puts arguments from the protocol arguments array to the map assigning names
- * to the anonymous arguments.
- * @param {Array.<Object>} array Arguments array from 'backtrace' response.
- * @param {Object} map Result holder.
- */
-devtools.DebuggerAgent.argumentsArrayToMap_ = function(array, map) {
-  for (var j = 0; j < array.length; j++) {
-    var nextValue = array[j];
-    // Skip unnamed properties. They may appear e.g. when number of actual
-    // parameters is greater the that of formal. In that case the superfluous
-    // parameters will be present in the arguments list as elements without
-    // names.
-    var name = nextValue.name ? nextValue.name : '<arg #' + j + '>';
-    map[name] = devtools.DebuggerAgent.formatObjectReference_(nextValue.value);
-  }
-};
-
 
 /**
  * @param {Object} v An object reference from the debugger response.
  * @return {*} The value representation expected by ScriptsPanel.
  */
-devtools.DebuggerAgent.formatObjectReference_ = function(v) {
+devtools.DebuggerAgent.formatObjectProxy_ = function(v) {
+  var description;
+  var hasChildren = false;
   if (v.type == 'object') {
-    return v;
+    description = v.className;
+    hasChildren = true;
   } else if (v.type == 'function') {
-    var f = function() {};
-    f.ref = v.ref;
-    return f;
+    if (v.source) {
+      description = v.source;
+    } else {
+      description = 'function ' + v.name + '()';
+    }
+    hasChildren = true;
   } else if (goog.isDef(v.value)) {
-    return v.value;
+    description = v.value;
   } else if (v.type == 'undefined') {
-    return 'undefined';
+    description = 'undefined';
   } else if (v.type == 'null') {
-    return 'null';
-  } else if (v.name) {
-    return v.name;
-  } else if (v.className) {
-    return v.className;
+    description = 'null';
   } else {
-    return '<unresolved ref: ' + v.ref + ', type: ' + v.type + '>';
+    description = '<unresolved ref: ' + v.ref + ', type: ' + v.type + '>';
   }
+  var proxy = new WebInspector.ObjectProxy(v, [], 0, description, hasChildren);
+  proxy.type = v.type;
+  proxy.isV8Ref = true;
+  return proxy;
 };
 
 
 /**
  * Converts line number from Web Inspector UI(1-based) to v8(0-based).
  * @param {number} line Resource line number in Web Inspector UI.
  * @return {number} The line number in v8.
  */
 devtools.DebuggerAgent.webkitToV8LineNumber_ = function(line) {
   return line - 1;
 };
 
 
 /**
  * Converts line number from v8(0-based) to Web Inspector UI(1-based).
  * @param {number} line Resource line number in v8.
  * @return {number} The line number in Web Inspector.
  */
 devtools.DebuggerAgent.v8ToWwebkitLineNumber_ = function(line) {
   return line + 1;
 };
 
 
 /**
  * @param {number} scriptId Id of the script.
+ * @param {?string} url Script resource URL if any.
  * @param {number} lineOffset First line 0-based offset in the containing
  *     document.
+ * @param {string} contextType Type of the script's context:
+ *     "page" - regular script from html page
+ *     "injected" - extension content script
+ * @param {bool} opt_isUnresolved If true, script will not be resolved.
  * @constructor
  */
-devtools.ScriptInfo = function(scriptId, lineOffset) {
+devtools.ScriptInfo = function(
+    scriptId, url, lineOffset, contextType, opt_isUnresolved) {
   this.scriptId_ = scriptId;
   this.lineOffset_ = lineOffset;
+  this.contextType_ = contextType;
+  this.url_ = url;
+  this.isUnresolved_ = opt_isUnresolved;
 
   this.lineToBreakpointInfo_ = {};
 };
 
 
 /**
  * @return {number}
  */
 devtools.ScriptInfo.prototype.getLineOffset = function() {
   return this.lineOffset_;
 };
 
 
 /**
+ * @return {string}
+ */
+devtools.ScriptInfo.prototype.getContextType = function() {
+  return this.contextType_;
+};
+
+
+/**
+ * @return {?string}
+ */
+devtools.ScriptInfo.prototype.getUrl = function() {
+  return this.url_;
+};
+
+
+/**
+ * @return {?bool}
+ */
+devtools.ScriptInfo.prototype.isUnresolved = function() {
+  return this.isUnresolved_;
+};
+
+
+/**
  * @param {number} line 0-based line number in the script.
  * @return {?devtools.BreakpointInfo} Information on a breakpoint at the
  *     specified line in the script or undefined if there is no breakpoint at
  *     that line.
  */
 devtools.ScriptInfo.prototype.getBreakpointInfo = function(line) {
   return this.lineToBreakpointInfo_[line];
 };
 
 
@@ skipping 10 matching lines @@
  * @param {devtools.BreakpointInfo} breakpoint Breakpoint info to be removed.
  */
 devtools.ScriptInfo.prototype.removeBreakpointInfo = function(breakpoint) {
   var line = breakpoint.getLine();
   delete this.lineToBreakpointInfo_[line];
 };
 
 
 
 /**
- * @param {number} scriptId Id of the owning script.
  * @param {number} line Breakpoint 0-based line number in the containing script.
  * @constructor
  */
-devtools.BreakpointInfo = function(sourceId, line) {
-  this.sourceId_ = sourceId;
+devtools.BreakpointInfo = function(line) {
   this.line_ = line;
   this.v8id_ = -1;
   this.removed_ = false;
 };
 
 
 /**
  * @return {number}
  */
-devtools.BreakpointInfo.prototype.getSourceId = function(n) {
-  return this.sourceId_;
-};
-
-
-/**
- * @return {number}
- */
 devtools.BreakpointInfo.prototype.getLine = function(n) {
   return this.line_;
 };
 
 
 /**
  * @return {number} Unique identifier of this breakpoint in the v8 debugger.
  */
 devtools.BreakpointInfo.prototype.getV8Id = function(n) {
   return this.v8id_;
@@ skipping 21 matching lines @@
  * @return {boolean} Whether this breakpoint has been removed from the
  *     front-end.
  */
 devtools.BreakpointInfo.prototype.isRemoved = function() {
   return this.removed_;
 };
 
 
 /**
  * Call stack frame data.
+ * @param {string} id CallFrame id.
+ * @param {string} type CallFrame type.
+ * @param {string} functionName CallFrame type.
+ * @param {string} sourceID Source id.
+ * @param {number} line Source line.
+ * @param {Array.<Object>} scopeChain Array of scoped objects.
  * @construnctor
  */
-devtools.CallFrame = function() {
-  this.sourceID = null;
-  this.line = null;
-  this.type = 'function';
-  this.functionName = null;
-  this.caller = null;
-  this.localScope = null;
-  this.scopeChain = [];
-  this.thisObject = {};
-  this.frameNumber = null;
+devtools.CallFrame = function(id, type, functionName, sourceID, line,
+    scopeChain) {
+  this.id = id;
+  this.type = type;
+  this.functionName = functionName;
+  this.sourceID = sourceID;
+  this.line = line;
+  this.scopeChain = scopeChain;
 };
 
 
 /**
- * This method is called by
- * WebInspector.ScriptsPanel.evaluateInSelectedCallFrame. This method issues
- * asynchronous evaluate request.
+ * This method issues asynchronous evaluate request, reports result to the
+ * callback.
  * @param {string} expression An expression to be evaluated in the context of
  *     this call frame.
- * @return {string} User message that the expression is being evaluated.
+ * @param {function(Object):undefined} callback Callback to report result to.
  */
-devtools.CallFrame.prototype.evaluate = function(expression) {
+devtools.CallFrame.prototype.evaluate_ = function(expression, callback) {
   devtools.tools.getDebuggerAgent().requestEvaluate({
-        'expression': expression,
-        'frame': this.frameNumber,
-        'global': false,
-        'disable_break': false
-      },
-      devtools.CallFrame.handleEvaluateResponse_);
-  return 'evaluating...';
+      'expression': expression,
+      'frame': this.id,
+      'global': false,
+      'disable_break': false,
+      'compactFormat': true
+    },
+    function(response) {
+      var result = {};
+      if (response.isSuccess()) {
+        result.value = devtools.DebuggerAgent.formatObjectProxy_(
+            response.getBody());
+      } else {
+        result.value = response.getMessage();
+        result.isException = true;
+      }
+      callback(result);
+    });
 };
 
 
-/**
- * Handles 'evaluate' response for a call frame
- * @param {devtools.DebuggerMessage} response
- */
-devtools.CallFrame.handleEvaluateResponse_ = function(response) {
-  var body = response.getBody();
-  var value = devtools.DebuggerAgent.formatObjectReference_(body);
-  WebInspector.addMessageToConsole(new WebInspector.ConsoleCommandResult(
-      value, false /* exception */, null /* commandMessage */));
-};
-
-
 /**
  * JSON based commands sent to v8 debugger.
  * @param {string} command Name of the command to execute.
  * @param {Object} opt_arguments Command-specific arguments map.
  * @constructor
  */
 devtools.DebugCommand = function(command, opt_arguments) {
   this.command_ = command;
   this.type_ = 'request';
   this.seq_ = ++devtools.DebugCommand.nextSeq_;
@@ skipping 34 matching lines @@
 };
 
 
 /**
  * JSON messages sent from v8 debugger. See protocol definition for more
  * details: http://code.google.com/p/v8/wiki/DebuggerProtocol
  * @param {string} msg Raw protocol packet as JSON string.
  * @constructor
  */
 devtools.DebuggerMessage = function(msg) {
-  var jsExpression = '[' + msg + '][0]';
-  this.packet_ = eval(jsExpression);
+  this.packet_ = JSON.parse(msg);
   this.refs_ = [];
   if (this.packet_.refs) {
     for (var i = 0; i < this.packet_.refs.length; i++) {
       this.refs_[this.packet_.refs[i].handle] = this.packet_.refs[i];
     }
   }
 };
 
 
 /**
@@ skipping 62 matching lines @@
 
 
 /**
  * @param {number} handle Object handle.
  * @return {?Object} Returns the object with the handle if it was sent in this
  *    message(some objects referenced by handles may be missing in the message).
  */
 devtools.DebuggerMessage.prototype.lookup = function(handle) {
   return this.refs_[handle];
 };