[DevTools] move green dots further

third_party/WebKit/Source/devtools/front_end/sdk/DebuggerModel.js

 /*
  * Copyright (C) 2010 Google Inc. 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
@@ skipping 150 matching lines @@
   }
 
   stepOver() {
     this._agent.stepOver();
   }
 
   stepOut() {
     this._agent.stepOut();
   }
 
+  scheduleStepIntoAsync() {
+    this._agent.scheduleStepIntoAsync();
+  }
+
   resume() {
     this._agent.resume();
     this._isPausing = false;
   }
 
   pause() {
     this._isPausing = true;
     this._skipAllPauses(false);
     this._agent.pause();
   }
@@ skipping 82 matching lines @@
         console.error('Failed to remove breakpoint: ' + error);
       if (callback)
         callback();
     }
   }
 
   /**
    * @param {!SDK.DebuggerModel.Location} startLocation
    * @param {!SDK.DebuggerModel.Location} endLocation
    * @param {boolean} restrictToFunction
-   * @return {!Promise<!Array<!SDK.DebuggerModel.Location>>}
+   * @return {!Promise<!Array<!SDK.DebuggerModel.BreakLocation>>}
    */
   getPossibleBreakpoints(startLocation, endLocation, restrictToFunction) {
     var fulfill;
     var promise = new Promise(resolve => fulfill = resolve);
     this._agent.invoke_getPossibleBreakpoints(
         {start: startLocation.payload(), end: endLocation.payload(), restrictToFunction: restrictToFunction},
         checkErrorAndReturn.bind(this));
     return promise;
 
     /**
      * @this {!SDK.DebuggerModel}
      * @param {?Protocol.Error} error
-     * @param {?Array<!Protocol.Debugger.Location>} locations
+     * @param {?Array<!Protocol.Debugger.BreakLocation>} locations
      */
     function checkErrorAndReturn(error, locations) {
       if (error || !locations) {
         fulfill([]);
         return;
       }
-      fulfill(locations.map(location => SDK.DebuggerModel.Location.fromPayload(this, location)));
+      fulfill(locations.map(location => SDK.DebuggerModel.BreakLocation.fromPayload(this, location)));
     }
   }
 
   /**
    * @param {!Protocol.Debugger.BreakpointId} breakpointId
    * @param {!Protocol.Debugger.Location} location
    */
   _breakpointResolved(breakpointId, location) {
     this._breakpointResolvedEventTarget.dispatchEventToListeners(
         breakpointId, SDK.DebuggerModel.Location.fromPayload(this, location));
@@ skipping 559 matching lines @@
   EventListener: 'EventListener',
   XHR: 'XHR',
   Exception: 'exception',
   PromiseRejection: 'promiseRejection',
   Assert: 'assert',
   DebugCommand: 'debugCommand',
   OOM: 'OOM',
   Other: 'other'
 };
 
+/** @enum {string} */
+SDK.DebuggerModel.BreakLocationType = {
+  Return: 'return',
+  Call: 'call',
+  DebuggerStatement: 'debuggerStatement'
+};
+
 SDK.DebuggerEventTypes = {
   JavaScriptPause: 0,
   JavaScriptBreakpoint: 1,
   NativeBreakpoint: 2
 };
 
 /**
  * @implements {Protocol.DebuggerDispatcher}
  * @unrestricted
  */
@@ skipping 143 matching lines @@
   }
 
   /**
    * @return {string}
    */
   id() {
     return this.debuggerModel.target().id() + ':' + this.scriptId + ':' + this.lineNumber + ':' + this.columnNumber;
   }
 };
 
+/**
+ * @unrestricted
+ */
+SDK.DebuggerModel.BreakLocation = class extends SDK.DebuggerModel.Location {
+  /**
+   * @param {!SDK.DebuggerModel} debuggerModel
+   * @param {string} scriptId
+   * @param {number} lineNumber
+   * @param {number=} columnNumber
+   * @param {!Protocol.Debugger.BreakLocationType=} type
+   */
+  constructor(debuggerModel, scriptId, lineNumber, columnNumber, type) {
+    super(debuggerModel, scriptId, lineNumber, columnNumber);
+    if (type)
+      this.type = type;
+  }
+
+  /**
+   * @param {!SDK.DebuggerModel} debuggerModel
+   * @param {!Protocol.Debugger.BreakLocation} payload
+   * @return {!SDK.DebuggerModel.BreakLocation}
+   */
+  static fromPayload(debuggerModel, payload) {
+    return new SDK.DebuggerModel.BreakLocation(
+        debuggerModel, payload.scriptId, payload.lineNumber, payload.columnNumber, payload.type);
+  }
+};
 
 /**
  * @unrestricted
  */
 SDK.DebuggerModel.CallFrame = class {
   /**
    * @param {!SDK.DebuggerModel} debuggerModel
    * @param {!SDK.Script} script
    * @param {!Protocol.Debugger.CallFrame} payload
    */
@@ skipping 302 matching lines @@
         stack.callFrames.shift();
       if (previous && (!stack.callFrames.length && !stack.promiseCreationFrame))
         previous.parent = stack.parent;
       else
         previous = stack;
       stack = stack.parent;
     }
     return asyncStackTrace;
   }
 };