DevTools: use semicolons after each statement.

third_party/WebKit/Source/devtools/front_end/sources/ScriptFormatter.js

 /*
  * Copyright (C) 2011 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 15 matching lines @@
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 /**
  * @interface
  */
 WebInspector.Formatter = function()
 {
-}
+};
 
 /**
  * @param {!WebInspector.ResourceType} contentType
  * @param {string} mimeType
  * @param {string} content
  * @param {function(string, !WebInspector.FormatterSourceMapping)} callback
  */
 WebInspector.Formatter.format = function(contentType, mimeType, content, callback)
 {
     if (contentType.isDocumentOrScriptOrStyleSheet())
         new WebInspector.ScriptFormatter(mimeType, content, callback);
     else
         new WebInspector.IdentityFormatter(mimeType, content, callback);
-}
+};
 
 /**
  * @param {!Array.<number>} lineEndings
  * @param {number} lineNumber
  * @param {number} columnNumber
  * @return {number}
  */
 WebInspector.Formatter.locationToPosition = function(lineEndings, lineNumber, columnNumber)
 {
     var position = lineNumber ? lineEndings[lineNumber - 1] + 1 : 0;
     return position + columnNumber;
-}
+};
 
 /**
  * @param {!Array.<number>} lineEndings
  * @param {number} position
  * @return {!Array.<number>}
  */
 WebInspector.Formatter.positionToLocation = function(lineEndings, position)
 {
     var lineNumber = lineEndings.upperBound(position - 1);
     if (!lineNumber)
         var columnNumber = position;
     else
         var columnNumber = position - lineEndings[lineNumber - 1] - 1;
     return [lineNumber, columnNumber];
-}
+};
 
 /**
  * @constructor
  * @implements {WebInspector.Formatter}
  * @param {string} mimeType
  * @param {string} content
  * @param {function(string, !WebInspector.FormatterSourceMapping)} callback
  */
 WebInspector.ScriptFormatter = function(mimeType, content, callback)
 {
     content = content.replace(/\r\n?|[\n\u2028\u2029]/g, "\n").replace(/^\uFEFF/, "");
     this._callback = callback;
     this._originalContent = content;
 
     var parameters = {
         mimeType: mimeType,
         content: content,
         indentString: WebInspector.moduleSetting("textEditorIndent").get()
     };
     WebInspector.formatterWorkerPool.runTask("format", parameters)
         .then(this._didFormatContent.bind(this));
-}
+};
 
 WebInspector.ScriptFormatter.prototype = {
     /**
      * @param {?MessageEvent} event
      */
     _didFormatContent: function(event)
     {
         var formattedContent = "";
         var mapping = [];
         if (event) {
             formattedContent = event.data.content;
             mapping = event.data["mapping"];
         }
         var sourceMapping = new WebInspector.FormatterSourceMappingImpl(this._originalContent.computeLineEndings(), formattedContent.computeLineEndings(), mapping);
         this._callback(formattedContent, sourceMapping);
     }
-}
+};
 
 /**
  * @constructor
  * @implements {WebInspector.Formatter}
  * @param {string} mimeType
  * @param {string} content
  * @param {function(string, !WebInspector.FormatterSourceMapping)} callback
  */
 WebInspector.IdentityFormatter = function(mimeType, content, callback)
 {
     callback(content, new WebInspector.IdentityFormatterSourceMapping());
-}
+};
 
 /**
  * @typedef {{original: !Array.<number>, formatted: !Array.<number>}}
  */
 WebInspector.FormatterMappingPayload;
 
 /**
  * @interface
  */
 WebInspector.FormatterSourceMapping = function()
 {
-}
+};
 
 WebInspector.FormatterSourceMapping.prototype = {
     /**
      * @param {number} lineNumber
      * @param {number=} columnNumber
      * @return {!Array.<number>}
      */
     originalToFormatted: function(lineNumber, columnNumber) { },
 
     /**
      * @param {number} lineNumber
      * @param {number=} columnNumber
      * @return {!Array.<number>}
      */
     formattedToOriginal: function(lineNumber, columnNumber) { }
-}
+};
 
 /**
  * @constructor
  * @implements {WebInspector.FormatterSourceMapping}
  */
 WebInspector.IdentityFormatterSourceMapping = function()
 {
-}
+};
 
 WebInspector.IdentityFormatterSourceMapping.prototype = {
     /**
      * @override
      * @param {number} lineNumber
      * @param {number=} columnNumber
      * @return {!Array.<number>}
      */
     originalToFormatted: function(lineNumber, columnNumber)
     {
         return [lineNumber, columnNumber || 0];
     },
 
     /**
      * @override
      * @param {number} lineNumber
      * @param {number=} columnNumber
      * @return {!Array.<number>}
      */
     formattedToOriginal: function(lineNumber, columnNumber)
     {
         return [lineNumber, columnNumber || 0];
     }
-}
+};
 
 /**
  * @constructor
  * @implements {WebInspector.FormatterSourceMapping}
  * @param {!Array.<number>} originalLineEndings
  * @param {!Array.<number>} formattedLineEndings
  * @param {!WebInspector.FormatterMappingPayload} mapping
  */
 WebInspector.FormatterSourceMappingImpl = function(originalLineEndings, formattedLineEndings, mapping)
 {
     this._originalLineEndings = originalLineEndings;
     this._formattedLineEndings = formattedLineEndings;
     this._mapping = mapping;
-}
+};
 
 WebInspector.FormatterSourceMappingImpl.prototype = {
     /**
      * @override
      * @param {number} lineNumber
      * @param {number=} columnNumber
      * @return {!Array.<number>}
      */
     originalToFormatted: function(lineNumber, columnNumber)
     {
@@ skipping 22 matching lines @@
      * @return {number}
      */
     _convertPosition: function(positions1, positions2, position)
     {
         var index = positions1.upperBound(position) - 1;
         var convertedPosition = positions2[index] + position - positions1[index];
         if (index < positions2.length - 1 && convertedPosition > positions2[index + 1])
             convertedPosition = positions2[index + 1];
         return convertedPosition;
     }
-}
+};