DevTools: use semicolons after each statement.

third_party/WebKit/Source/devtools/front_end/sdk/CSSModel.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 41 matching lines @@
     this._originalStyleSheetText = new Map();
 
     /** @type {!Multimap<string, !CSSAgent.StyleSheetId>} */
     this._sourceMapLoadingStyleSheetsIds = new Multimap();
 
     /** @type {!Map<string, !WebInspector.SourceMap>} */
     this._sourceMapByURL = new Map();
     /** @type {!Multimap<string, !WebInspector.CSSStyleSheetHeader>} */
     this._sourceMapURLToHeaders = new Multimap();
     WebInspector.moduleSetting("cssSourceMapsEnabled").addChangeListener(this._toggleSourceMapSupport, this);
-}
+};
 
 /** @enum {symbol} */
 WebInspector.CSSModel.Events = {
     LayoutEditorChange: Symbol("LayoutEditorChange"),
     FontsUpdated: Symbol("FontsUpdated"),
     MediaQueryResultChanged: Symbol("MediaQueryResultChanged"),
     ModelWasEnabled: Symbol("ModelWasEnabled"),
     PseudoStateForced: Symbol("PseudoStateForced"),
     StyleSheetAdded: Symbol("StyleSheetAdded"),
     StyleSheetChanged: Symbol("StyleSheetChanged"),
     StyleSheetRemoved: Symbol("StyleSheetRemoved"),
     SourceMapAttached: Symbol("SourceMapAttached"),
     SourceMapDetached: Symbol("SourceMapDetached"),
     SourceMapChanged: Symbol("SourceMapChanged")
-}
+};
 
 WebInspector.CSSModel.MediaTypes = ["all", "braille", "embossed", "handheld", "print", "projection", "screen", "speech", "tty", "tv"];
 
 WebInspector.CSSModel.PseudoStateMarker = "pseudo-state-marker";
 
 /**
  * @constructor
  * @param {!CSSAgent.StyleSheetId} styleSheetId
  * @param {!WebInspector.TextRange} oldRange
  * @param {string} newText
  * @param {?Object} payload
  */
 WebInspector.CSSModel.Edit = function(styleSheetId, oldRange, newText, payload)
 {
     this.styleSheetId = styleSheetId;
     this.oldRange = oldRange;
     this.newRange = WebInspector.TextRange.fromEdit(oldRange, newText);
     this.payload = payload;
-}
+};
 
 WebInspector.CSSModel.prototype = {
     /**
      * @param {!WebInspector.Event} event
      */
     _toggleSourceMapSupport: function(event)
     {
         var enabled = /** @type {boolean} */ (event.data);
         var headers = this.styleSheetHeaders();
         for (var header of headers) {
@@ skipping 611 matching lines @@
     /**
      * @param {!CSSAgent.StyleSheetId} styleSheetId
      * @param {string} ruleText
      * @param {!WebInspector.TextRange} ruleLocation
      * @return {!Promise<?WebInspector.CSSStyleRule>}
      */
     addRule: function(styleSheetId, ruleText, ruleLocation)
     {
         return this._ensureOriginalStyleSheetText(styleSheetId)
             .then(() => this._agent.addRule(styleSheetId, ruleText, ruleLocation, parsePayload.bind(this)))
-            .catchException(/** @type {?WebInspector.CSSStyleRule} */(null))
+            .catchException(/** @type {?WebInspector.CSSStyleRule} */(null));
 
         /**
          * @param {?Protocol.Error} error
          * @param {?CSSAgent.CSSRule} rulePayload
          * @return {?WebInspector.CSSStyleRule}
          * @this {WebInspector.CSSModel}
          */
         function parsePayload(error, rulePayload)
         {
             if (error || !rulePayload)
@@ skipping 27 matching lines @@
          * @return {?WebInspector.CSSStyleSheetHeader}
          * @this {WebInspector.CSSModel}
          */
         function innerCallback(error, styleSheetId)
         {
             return !error && styleSheetId ? this._styleSheetIdToHeader.get(styleSheetId) || null : null;
         }
 
         this._agent.createStyleSheet(frameId, innerCallback.bind(this))
             .catchException(null)
-            .then(userCallback)
+            .then(userCallback);
     },
 
     mediaQueryResultChanged: function()
     {
         this.dispatchEventToListeners(WebInspector.CSSModel.Events.MediaQueryResultChanged);
     },
 
     fontsUpdated: function()
     {
         this.dispatchEventToListeners(WebInspector.CSSModel.Events.FontsUpdated);
@@ skipping 162 matching lines @@
     getStyleSheetText: function(styleSheetId)
     {
         /**
          * @param {?Protocol.Error} error
          * @param {?string} text
          * @return {string}
          */
         function textCallback(error, text)
         {
             if (error || text === null) {
-                console.error("Failed to get text for stylesheet " + styleSheetId + ": " + error)
+                console.error("Failed to get text for stylesheet " + styleSheetId + ": " + error);
                 text = "";
                 // Fall through.
             }
             return WebInspector.CSSModel.trimSourceURL(text);
         }
 
         return this._agent.getStyleSheetText(styleSheetId, textCallback)
             .catchException(/** @type {string} */(""));
     },
 
@@ skipping 73 matching lines @@
         return this._cachedMatchedCascadePromise;
     },
 
     discardCachedMatchedCascade: function()
     {
         delete this._cachedMatchedCascadeNode;
         delete this._cachedMatchedCascadePromise;
     },
 
     __proto__: WebInspector.SDKModel.prototype
-}
+};
 
 /**
  * @param {string} text
  * @return {string}
  */
 WebInspector.CSSModel.trimSourceURL = function(text)
 {
     var sourceURLIndex = text.lastIndexOf("/*# sourceURL=");
     if (sourceURLIndex === -1) {
         sourceURLIndex = text.lastIndexOf("/*@ sourceURL=");
         if (sourceURLIndex === -1)
             return text;
     }
     var sourceURLLineIndex = text.lastIndexOf("\n", sourceURLIndex);
     if (sourceURLLineIndex === -1)
         return text;
     var sourceURLLine = text.substr(sourceURLLineIndex + 1).split("\n", 1)[0];
     var sourceURLRegex = /[\040\t]*\/\*[#@] sourceURL=[\040\t]*([^\s]*)[\040\t]*\*\/[\040\t]*$/;
     if (sourceURLLine.search(sourceURLRegex) === -1)
         return text;
     return text.substr(0, sourceURLLineIndex) + text.substr(sourceURLLineIndex + sourceURLLine.length + 1);
-}
+};
 
 
 /**
  * @constructor
  * @extends {WebInspector.SDKObject}
  * @param {!WebInspector.CSSStyleSheetHeader} header
  * @param {number} lineNumber
  * @param {number=} columnNumber
  */
 WebInspector.CSSLocation = function(header, lineNumber, columnNumber)
 {
     WebInspector.SDKObject.call(this, header.target());
     this._header = header;
     this.styleSheetId = header.id;
     this.url = header.resourceURL();
     this.lineNumber = lineNumber;
     this.columnNumber = columnNumber || 0;
-}
+};
 
 WebInspector.CSSLocation.prototype = {
     /**
      * @return {!WebInspector.CSSModel}
      */
     cssModel: function()
     {
         return this._header.cssModel();
     },
 
     /**
      * @return {!WebInspector.CSSStyleSheetHeader}
      */
     header: function()
     {
         return this._header;
     },
 
     __proto__: WebInspector.SDKObject.prototype
-}
+};
 
 /**
  * @constructor
  * @implements {CSSAgent.Dispatcher}
  * @param {!WebInspector.CSSModel} cssModel
  */
 WebInspector.CSSDispatcher = function(cssModel)
 {
     this._cssModel = cssModel;
-}
+};
 
 WebInspector.CSSDispatcher.prototype = {
     /**
      * @override
      */
     mediaQueryResultChanged: function()
     {
         this._cssModel.mediaQueryResultChanged();
     },
 
@@ skipping 34 matching lines @@
 
     /**
      * @override
      * @param {!CSSAgent.StyleSheetId} id
      * @param {!CSSAgent.SourceRange} range
      */
     layoutEditorChange: function(id, range)
     {
         this._cssModel._layoutEditorChange(id, range);
     },
-}
+};
 
 /**
  * @constructor
  * @param {!WebInspector.CSSModel} cssModel
  */
 WebInspector.CSSModel.ComputedStyleLoader = function(cssModel)
 {
     this._cssModel = cssModel;
     /** @type {!Map<!DOMAgent.NodeId, !Promise<?Map<string, string>>>} */
     this._nodeIdToPromise = new Map();
-}
+};
 
 WebInspector.CSSModel.ComputedStyleLoader.prototype = {
     /**
      * @param {!DOMAgent.NodeId} nodeId
      * @return {!Promise<?Map<string, string>>}
      */
     computedStylePromise: function(nodeId)
     {
         if (!this._nodeIdToPromise.has(nodeId))
             this._nodeIdToPromise.set(nodeId, this._cssModel._agent.getComputedStyleForNode(nodeId, parsePayload).then(cleanUp.bind(this)));
@@ skipping 19 matching lines @@
          * @param {?Map.<string, string>} computedStyle
          * @return {?Map.<string, string>}
          * @this {WebInspector.CSSModel.ComputedStyleLoader}
          */
         function cleanUp(computedStyle)
         {
             this._nodeIdToPromise.delete(nodeId);
             return computedStyle;
         }
     }
-}
+};
 
 /**
  * @param {!WebInspector.Target} target
  * @return {?WebInspector.CSSModel}
  */
 WebInspector.CSSModel.fromTarget = function(target)
 {
     return /** @type {?WebInspector.CSSModel} */ (target.model(WebInspector.CSSModel));
-}
+};
 
 /**
  * @param {!WebInspector.DOMNode} node
  * @return {!WebInspector.CSSModel}
  */
 WebInspector.CSSModel.fromNode = function(node)
 {
     return /** @type {!WebInspector.CSSModel} */ (WebInspector.CSSModel.fromTarget(node.target()));
-}
+};
 
 /**
  * @constructor
  * @param {?WebInspector.CSSStyleDeclaration} inlineStyle
  * @param {?WebInspector.CSSStyleDeclaration} attributesStyle
  */
 WebInspector.CSSModel.InlineStyleResult = function(inlineStyle, attributesStyle)
 {
     this.inlineStyle = inlineStyle;
     this.attributesStyle = attributesStyle;
-}
+};