DevTools: reformat front-end code to match chromium style.

third_party/WebKit/LayoutTests/inspector/sources/debugger-breakpoints/breakpoint-manager.js

 var initialize_BreakpointManagerTest = function() {
 
 InspectorTest.uiSourceCodes = {};
 
 InspectorTest.dumpTargetIds = false;
 
 InspectorTest.initializeDefaultMappingOnTarget = function(target)
 {
     var defaultMapping = {
         rawLocationToUILocation: function(rawLocation)
@@ skipping 14 matching lines @@
         }
     };
     target.defaultMapping = defaultMapping;
 }
 
 InspectorTest.dumpTarget = function(targetAware)
 {
     return InspectorTest.dumpTargetIds ?  "target " + targetAware.target().id() + " " : "";
 }
 
-InspectorTest.DebuggerModelMock = function(target)
-{
-    WebInspector.SDKModel.call(this, WebInspector.DebuggerModel, target);
-    this._breakpointResolvedEventTarget = new WebInspector.Object();
-    this._scripts = {};
-    this._breakpoints = {};
-    this._debuggerWorkspaceBinding = InspectorTest.testDebuggerWorkspaceBinding;
-}
+InspectorTest.DebuggerModelMock = class extends WebInspector.SDKModel {
+    constructor(target)
+    {
+        super(WebInspector.DebuggerModel, target);
+        this._breakpointResolvedEventTarget = new WebInspector.Object();
+        this._scripts = {};
+        this._breakpoints = {};
+        this._debuggerWorkspaceBinding = InspectorTest.testDebuggerWorkspaceBinding;
+    }
 
-InspectorTest.DebuggerModelMock.prototype = {
-    target: function()
+    target()
     {
         return this._target;
-    },
+    }
 
-    _targetDisposed: function() { },
+    _targetDisposed() { }
 
-    debuggerEnabled: function()
+    debuggerEnabled()
     {
         return true;
-    },
+    }
 
-    scriptsForSourceURL: function(url)
+    scriptsForSourceURL(url)
     {
         var script = this._scriptForURL(url);
         return script ? [script] : [];
-    },
+    }
 
-    _addScript: function(scriptId, url)
+    _addScript(scriptId, url)
     {
         var script = new WebInspector.Script(this, scriptId, url);
         this._scripts[scriptId] = script;
         this._debuggerWorkspaceBinding._targetToData.get(this._target)._parsedScriptSource({data: script});
-    },
+    }
 
-    _registerScript: function(script)
+    _registerScript(script)
     {
         this._scripts[script.scriptId] = script;
         this._debuggerWorkspaceBinding._targetToData.get(this._target)._parsedScriptSource({data: script});
-    },
+    }
 
-    _scriptForURL: function(url)
+    _scriptForURL(url)
     {
         for (var scriptId in this._scripts) {
             var script = this._scripts[scriptId];
             if (script.sourceURL === url)
                 return script;
         }
-    },
+    }
 
-    _scheduleSetBeakpointCallback: function(callback, breakpointId, locations)
+    _scheduleSetBeakpointCallback(callback, breakpointId, locations)
     {
         setTimeout(innerCallback.bind(this), 0);
 
         function innerCallback()
         {
             if (callback)
                 callback(breakpointId, locations);
             if (window.setBreakpointCallback) {
                 var savedCallback = window.setBreakpointCallback;
                 delete window.setBreakpointCallback;
                 savedCallback();
             }
         }
-    },
+    }
 
-    createRawLocation: function(script, line, column)
+    createRawLocation(script, line, column)
     {
         return new WebInspector.DebuggerModel.Location(this, script.scriptId, line, column);
-    },
+    }
 
-    setBreakpointByURL: function(url, lineNumber, columnNumber, condition, callback)
+    setBreakpointByURL(url, lineNumber, columnNumber, condition, callback)
     {
         InspectorTest.addResult("    " + InspectorTest.dumpTarget(this) + "debuggerModel.setBreakpoint(" + [url, lineNumber, condition].join(":") + ")");
 
         var breakpointId = url + ":" + lineNumber;
         if (this._breakpoints[breakpointId]) {
             this._scheduleSetBeakpointCallback(callback, null);
             return;
         }
         this._breakpoints[breakpointId] = true;
 
         if (lineNumber >= 2000) {
             this._scheduleSetBeakpointCallback(callback, breakpointId, []);
             return;
         }
         if (lineNumber >= 1000) {
             var shiftedLocation = new WebInspector.DebuggerModel.Location(this, url, lineNumber + 10, columnNumber);
             this._scheduleSetBeakpointCallback(callback, breakpointId, [shiftedLocation]);
             return;
         }
 
         var locations = [];
         var script = this._scriptForURL(url);
         if (script) {
             var location = new WebInspector.DebuggerModel.Location(this, script.scriptId, lineNumber, 0);
             locations.push(location);
         }
 
         this._scheduleSetBeakpointCallback(callback, breakpointId, locations);
-    },
+    }
 
-    removeBreakpoint: function(breakpointId, callback)
+    removeBreakpoint(breakpointId, callback)
     {
         InspectorTest.addResult("    " + InspectorTest.dumpTarget(this) + "debuggerModel.removeBreakpoint(" + breakpointId + ")");
         delete this._breakpoints[breakpointId];
         if (callback)
             setTimeout(callback, 0);
-    },
+    }
 
-    setBreakpointsActive: function() { },
+    setBreakpointsActive() { }
 
-    scriptForId: function(scriptId)
+    scriptForId(scriptId)
     {
         return this._scripts[scriptId];
-    },
+    }
 
-    reset: function()
+    reset()
     {
         InspectorTest.addResult("  Resetting debugger.");
         this._scripts = {};
         this._debuggerWorkspaceBinding._reset(this._target);
-    },
+    }
 
-    pushSourceMapping: function(sourceMapping)
+    pushSourceMapping(sourceMapping)
     {
         for (var scriptId in this._scripts)
             this._debuggerWorkspaceBinding.pushSourceMapping(this._scripts[scriptId], sourceMapping);
-    },
+    }
 
-    disableSourceMapping: function(sourceMapping)
+    disableSourceMapping(sourceMapping)
     {
         sourceMapping._disabled = true;
         for (var scriptId in this._scripts)
             this._debuggerWorkspaceBinding.updateLocations(this._scripts[scriptId]);
-    },
+    }
 
-    addBreakpointListener: function(breakpointId, listener, thisObject)
+    addBreakpointListener(breakpointId, listener, thisObject)
     {
         this._breakpointResolvedEventTarget.addEventListener(breakpointId, listener, thisObject)
-    },
+    }
 
-    removeBreakpointListener: function(breakpointId, listener, thisObject)
+    removeBreakpointListener(breakpointId, listener, thisObject)
     {
         this._breakpointResolvedEventTarget.removeEventListener(breakpointId, listener, thisObject);
-    },
+    }
 
-    _breakpointResolved: function(breakpointId, location)
+    _breakpointResolved(breakpointId, location)
     {
         this._breakpointResolvedEventTarget.dispatchEventToListeners(breakpointId, location);
-    },
-
-    __proto__: WebInspector.Object.prototype
-}
+    }
+};
 
 InspectorTest.setupLiveLocationSniffers = function()
 {
     InspectorTest.addSniffer(WebInspector.DebuggerWorkspaceBinding.prototype, "createLiveLocation", function(rawLocation)
     {
         InspectorTest.addResult("    Location created: " + InspectorTest.dumpTarget(rawLocation) + rawLocation.scriptId + ":" + rawLocation.lineNumber);
     }, true);
     InspectorTest.addSniffer(WebInspector.DebuggerWorkspaceBinding.Location.prototype, "dispose", function()
     {
         InspectorTest.addResult("    Location disposed: " + InspectorTest.dumpTarget(this._rawLocation) + this._rawLocation.scriptId + ":" + this._rawLocation.lineNumber);
@@ skipping 182 matching lines @@
     }
 
     function finish()
     {
         InspectorTest.dumpBreakpointLocations(breakpointManager);
         next();
     }
 }
 
 }