DevTools: handle 'scripts' response only when context id is known

webkit/glue/devtools/js/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');
 
@@ skipping 50 matching lines @@
    */
   this.requestSeqToCallback_ = null;
 
   /**
    * Whether the scripts list has been requested.
    * @type {boolean}
    */
   this.scriptsCacheInitialized_ = false;
 
   /**
+   * Whether the scripts list should be requested next time when context id is
+   * set.
+   * @type {boolean}
+   */
+  this.requestScriptsWhenContextIdSet_ = false;
+
+  /**
    * Active profiler modules flags.
    * @type {number}
    */
   this.activeProfilerModules_ =
       devtools.DebuggerAgent.ProfilerModules.PROFILER_MODULE_NONE;
 
   /**
    * Profiler processor instance.
    * @type {devtools.profiler.Processor}
    */
@@ skipping 24 matching lines @@
   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.
+ * @type {string}
  */
 devtools.DebuggerAgent.VOID_SCRIPT = 'javascript:void(0)';
 
+/**
+ * AfterCompile event source for devtools.DebuggerAgent.VOID_SCRIPT.
+ * @type {string}
+ */
+devtools.DebuggerAgent.VOID_SCRIPT_EVAL_SOURCE =
+   'with (window._inspectorCommandLineAPI) { with (window) { ' +
+   devtools.DebuggerAgent.VOID_SCRIPT +
+   ' } }';
 
 /**
  * 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.contextId_ = null;
+  // No need to request scripts since they all will be pushed in AfterCompile
+  // events.
+  this.requestScriptsWhenContextIdSet_ = false;
   this.parsedScripts_ = {};
   this.requestNumberToBreakpointInfo_ = {};
   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.
 };
 
 
 /**
- * Initializes scripts UI. Asynchronously requests for all parsed scripts
- * if necessary. Response will be processed in handleScriptsResponse_.
+ * Initializes scripts UI. This method is called every time Scripts panel
+ * is shown. It will send request for context id if it's not set yet.
  */
 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());
   }
 
+  // Initialize scripts cache when Scripts panel is shown first time.
+  if (this.scriptsCacheInitialized_) {
+    return;
+  }
+  this.scriptsCacheInitialized_ = true;
   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;
   }
-
+  // Script list should be requested only when current context id is known.
   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(devtools.DebuggerAgent.VOID_SCRIPT);
+  this.requestScriptsWhenContextIdSet_ = true;
 };
 
 
 /**
  * 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.
  */
@@ skipping 512 matching lines @@
   this.requestSeqToCallback_[cmd.getSequenceNumber()] = callback;
 };
 
 
 /**
  * Sets debugger context id for scripts filtering.
  * @param {number} contextId Id of the inspected page global context.
  */
 devtools.DebuggerAgent.prototype.setContextId_ = function(contextId) {
   this.contextId_ = contextId;
+
+  // If it's the first time context id is set request scripts list.
+  if (this.requestScriptsWhenContextIdSet_) {
+    this.requestScriptsWhenContextIdSet_ = false;
+    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(devtools.DebuggerAgent.VOID_SCRIPT);
+
+    var debuggerAgent = this;
+    this.requestSeqToCallback_[cmd.getSequenceNumber()] = function(msg) {
+      // Handle the response iff the context id hasn't changed since the request
+      // was issued. Otherwise if the context id did change all up-to-date
+      // scripts will be pushed in after compile events and there is no need to
+      // handle the response.
+      if (contextId == debuggerAgent.contextId_) {
+        debuggerAgent.handleScriptsResponse_(msg);
+      }
+    };
+  }
 };
 
 
 /**
  * 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);
+      this.invokeCallbackForResponse_(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);
@@ skipping 34 matching lines @@
   } 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
@@ skipping 77 matching lines @@
   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) {
+  var voidScript = devtools.DebuggerAgent.VOID_SCRIPT_EVAL_SOURCE;
   return !script.name &&
-         (script.sourceStart == devtools.DebuggerAgent.VOID_SCRIPT ||
-          script.source == devtools.DebuggerAgent.VOID_SCRIPT);
+         (script.sourceStart == voidScript ||
+          script.source == voidScript);
 };
 
 
 /**
  * Handles current profiler status.
  * @param {number} modules List of active (started) modules.
  */
 devtools.DebuggerAgent.prototype.didGetActiveProfilerModules_ = function(
     modules) {
   var profModules = devtools.DebuggerAgent.ProfilerModules;
@@ skipping 573 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];
 };