Revert 34040 - DevTools: make possible profiling of scripts doing heavy calcu...

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');
 
 
 /**
  * @constructor
  */
 devtools.DebuggerAgent = function() {
   RemoteDebuggerAgent.DebuggerOutput =
       goog.bind(this.handleDebuggerOutput_, 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}
@@ skipping 49 matching lines @@
   /**
    * If backtrace response is received when initial scripts response
    * is not yet processed the backtrace handling will be postponed until
    * after the scripts response processing. The handler bound to its arguments
    * and this agent will be stored in this field then.
    * @type {?function()}
    */
   this.pendingBacktraceResponseHandler_ = null;
 
   /**
+   * Active profiler modules flags.
+   * @type {number}
+   */
+  this.activeProfilerModules_ =
+      devtools.DebuggerAgent.ProfilerModules.PROFILER_MODULE_NONE;
+
+  /**
+   * Interval for polling profiler state.
+   * @type {number}
+   */
+  this.getActiveProfilerModulesInterval_ = null;
+
+  /**
+   * Whether log contents retrieval must be forced next time.
+   * @type {boolean}
+   */
+  this.forceGetLogLines_ = false;
+
+  /**
+   * 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.
@@ skipping 10 matching lines @@
 devtools.DebuggerAgent.ScopeType = {
   Global: 0,
   Local: 1,
   With: 2,
   Closure: 3,
   Catch: 4
 };
 
 
 /**
+ * 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.waitingForInitialScriptsResponse_ = 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. 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() {
   // Initialize scripts cache when Scripts panel is shown first time.
   if (this.scriptsPanelInitialized_) {
@@ skipping 473 matching lines @@
     } else {
       this.resolveFrameVariables_(callFrameId,
           function(result) {
             reportCompletions(result, false /* isException */);
           });
     }
 };
 
 
 /**
+ * Sets up callbacks that deal with profiles processing.
+ */
+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.getProfileType(
+      WebInspector.CPUProfileType.TypeId).treeElement;
+
+  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);
+        profile.typeId = WebInspector.CPUProfileType.TypeId;
+        InspectorBackend.addFullProfile(profile);
+        WebInspector.addProfileHeader(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();
+  this.forceGetLogLines_ = true;
+  this.getActiveProfilerModulesInterval_ = setInterval(
+        function() { RemoteDebuggerAgent.GetActiveProfilerModules(); }, 1000);
+};
+
+
+/**
+ * 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();
+  }
+};
+
+
+/**
+ * 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.
@@ skipping 282 matching lines @@
 
   // Ignore scripts from other tabs.
   if (!this.isScriptFromInspectedContext_(script, msg)) {
     return;
   }
   this.addScriptInfo_(script, msg);
 };
 
 
 /**
+ * Handles current profiler status.
+ * @param {number} modules List of active (started) modules.
+ */
+devtools.DebuggerAgent.prototype.didGetActiveProfilerModules_ = function(
+    modules) {
+  var profModules = devtools.DebuggerAgent.ProfilerModules;
+  var profModuleNone = profModules.PROFILER_MODULE_NONE;
+  if (this.forceGetLogLines_ ||
+      (modules != profModuleNone &&
+      this.activeProfilerModules_ == profModuleNone)) {
+    this.forceGetLogLines_ = false;
+    // Start to query log data.
+    RemoteDebuggerAgent.GetNextLogLines();
+  }
+  this.activeProfilerModules_ = modules;
+  // Update buttons.
+  WebInspector.setRecordingProfile(modules & profModules.PROFILER_MODULE_CPU);
+};
+
+
+/**
+ * Handles a portion of a profiler log retrieved by GetNextLogLines call.
+ * @param {string} log A portion of profiler log.
+ */
+devtools.DebuggerAgent.prototype.didGetNextLogLines_ = function(log) {
+  if (log.length > 0) {
+    this.profilerProcessor_.processLogChunk(log);
+  } else if (this.activeProfilerModules_ ==
+      devtools.DebuggerAgent.ProfilerModules.PROFILER_MODULE_NONE) {
+    // No new data and profiling is stopped---suspend log reading.
+    return;
+  }
+  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, msg) {
   var context = msg.lookup(script.context.ref);
   var contextType;
   if (goog.isString(context.data)) {
@@ skipping 558 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];
 };