DevTools: use semicolons after each statement.

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

 /*
  * Copyright (C) 2009, 2010 Google Inc. All rights reserved.
  * Copyright (C) 2009 Joseph Pecoraro
  *
  * 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.
@@ skipping 105 matching lines @@
         if (this.ownerDocument && !this.ownerDocument.body && this._nodeName === "BODY")
             this.ownerDocument.body = this;
     } else if (this._nodeType === Node.DOCUMENT_TYPE_NODE) {
         this.publicId = payload.publicId;
         this.systemId = payload.systemId;
         this.internalSubset = payload.internalSubset;
     } else if (this._nodeType === Node.ATTRIBUTE_NODE) {
         this.name = payload.name;
         this.value = payload.value;
     }
-}
+};
 
 /**
  * @enum {string}
  */
 WebInspector.DOMNode.PseudoElementNames = {
     Before: "before",
     After: "after"
-}
+};
 
 /**
  * @enum {string}
  */
 WebInspector.DOMNode.ShadowRootTypes = {
     UserAgent: "user-agent",
     Open: "open",
     Closed: "closed"
-}
+};
 
 /** @typedef {{name: string, value: string, _node: WebInspector.DOMNode}} */
 WebInspector.DOMNode.Attribute;
 
 WebInspector.DOMNode.prototype = {
     /**
      * @return {!WebInspector.DOMModel}
      */
     domModel: function()
     {
@@ skipping 772 matching lines @@
          * @param {function(?)} fulfill
          * @param {function(*)} reject
          * @this {WebInspector.DOMNode}
          */
         function resolveToObject(fulfill, reject)
         {
             this.resolveToObject(objectGroup, mycallback);
             function mycallback(object)
             {
                 if (object)
-                    fulfill(object)
+                    fulfill(object);
                 else
                     reject(null);
             }
         }
     },
 
     /**
      * @param {function(?DOMAgent.BoxModel)} callback
      */
     boxModel: function(callback)
     {
         this._agent.getBoxModel(this.id, this._domModel._wrapClientCallback(callback));
     },
 
     setAsInspectedNode: function()
     {
         var node = this;
         while (true) {
             var ancestor = node.ancestorUserAgentShadowRoot();
             if (!ancestor)
                 break;
             ancestor = node.ancestorShadowHost();
             if (!ancestor)
-                break
+                break;
             // User agent shadow root, keep climbing up.
             node = ancestor;
         }
         this._agent.setInspectedNode(node.id);
     },
 
     /**
      *  @return {?WebInspector.DOMNode}
      */
     enclosingElementOrSelf: function()
     {
         var node = this;
         if (node && node.nodeType() === Node.TEXT_NODE && node.parentNode)
             node = node.parentNode;
 
         if (node && node.nodeType() !== Node.ELEMENT_NODE)
             node = null;
         return node;
     },
 
     __proto__: WebInspector.SDKObject.prototype
-}
+};
 
 /**
  * @param {!WebInspector.Target} target
  * @param {number} backendNodeId
  * @constructor
  */
 WebInspector.DeferredDOMNode = function(target, backendNodeId)
 {
     this._domModel = WebInspector.DOMModel.fromTarget(target);
     this._backendNodeId = backendNodeId;
-}
+};
 
 WebInspector.DeferredDOMNode.prototype = {
     /**
      * @param {function(?WebInspector.DOMNode)} callback
      */
     resolve: function(callback)
     {
         if (!this._domModel) {
             callback(null);
             return;
@@ skipping 21 matching lines @@
          * @param {function(*)} reject
          * @this {WebInspector.DeferredDOMNode}
          */
         function resolveNode(fulfill, reject)
         {
             /**
              * @param {?WebInspector.DOMNode} node
              */
             function mycallback(node)
             {
-                fulfill(node)
+                fulfill(node);
             }
             this.resolve(mycallback);
         }
         return new Promise(resolveNode.bind(this));
     },
 
     /**
      * @return {number}
      */
     backendNodeId: function()
     {
         return this._backendNodeId;
     },
 
     highlight: function()
     {
         if (this._domModel)
             this._domModel.highlightDOMNode(undefined, undefined, this._backendNodeId);
     }
-}
+};
 
 /**
  * @constructor
  * @param {!WebInspector.Target} target
  * @param {number} backendNodeId
  * @param {number} nodeType
  * @param {string} nodeName
  */
 WebInspector.DOMNodeShortcut = function(target, backendNodeId, nodeType, nodeName)
 {
     this.nodeType = nodeType;
     this.nodeName = nodeName;
     this.deferredNode = new WebInspector.DeferredDOMNode(target, backendNodeId);
-}
+};
 
 /**
  * @extends {WebInspector.DOMNode}
  * @constructor
  * @param {!WebInspector.DOMModel} domModel
  * @param {!DOMAgent.Node} payload
  */
 WebInspector.DOMDocument = function(domModel, payload)
 {
     WebInspector.DOMNode.call(this, domModel, this, false, payload);
     this.documentURL = payload.documentURL || "";
     this.baseURL = payload.baseURL || "";
     this._listeners = {};
-}
+};
 
 WebInspector.DOMDocument.prototype = {
     __proto__: WebInspector.DOMNode.prototype
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.SDKModel}
  * @param {!WebInspector.Target} target
  */
 WebInspector.DOMModel = function(target) {
     WebInspector.SDKModel.call(this, WebInspector.DOMModel, target);
 
     this._agent = target.domAgent();
 
     /** @type {!Object.<number, !WebInspector.DOMNode>} */
     this._idToDOMNode = {};
     /** @type {?WebInspector.DOMDocument} */
     this._document = null;
     /** @type {!Object.<number, boolean>} */
     this._attributeLoadNodeIds = {};
     target.registerDOMDispatcher(new WebInspector.DOMDispatcher(this));
 
     this._inspectModeEnabled = false;
 
     this._defaultHighlighter = new WebInspector.DefaultDOMNodeHighlighter(this._agent);
     this._highlighter = this._defaultHighlighter;
 
     this._agent.enable();
-}
+};
 
 /** @enum {symbol} */
 WebInspector.DOMModel.Events = {
     AttrModified: Symbol("AttrModified"),
     AttrRemoved: Symbol("AttrRemoved"),
     CharacterDataModified: Symbol("CharacterDataModified"),
     DOMMutated: Symbol("DOMMutated"),
     NodeInserted: Symbol("NodeInserted"),
     NodeInspected: Symbol("NodeInspected"),
     NodeHighlightedInOverlay: Symbol("NodeHighlightedInOverlay"),
     NodeRemoved: Symbol("NodeRemoved"),
     DocumentUpdated: Symbol("DocumentUpdated"),
     ChildNodeCountUpdated: Symbol("ChildNodeCountUpdated"),
     UndoRedoRequested: Symbol("UndoRedoRequested"),
     UndoRedoCompleted: Symbol("UndoRedoCompleted"),
     DistributedNodesChanged: Symbol("DistributedNodesChanged"),
     ModelSuspended: Symbol("ModelSuspended"),
     InspectModeWillBeToggled: Symbol("InspectModeWillBeToggled"),
     MarkersChanged: Symbol("MarkersChanged")
-}
+};
 
 /**
  * @param {!WebInspector.RemoteObject} object
  */
 WebInspector.DOMModel.highlightObjectAsDOMNode = function(object)
 {
     var domModel = WebInspector.DOMModel.fromTarget(object.target());
     if (domModel)
         domModel.highlightDOMNode(undefined, undefined, undefined, object.objectId);
-}
+};
 
 /**
  * @return {!Array<!WebInspector.DOMModel>}
  */
 WebInspector.DOMModel.instances = function()
 {
     var result = [];
     for (var target of WebInspector.targetManager.targets()) {
         var domModel = WebInspector.DOMModel.fromTarget(target);
         if (domModel)
             result.push(domModel);
     }
     return result;
-}
+};
 
 WebInspector.DOMModel.hideDOMNodeHighlight = function()
 {
     for (var domModel of WebInspector.DOMModel.instances())
         domModel.highlightDOMNode(0);
-}
+};
 
 WebInspector.DOMModel.muteHighlight = function()
 {
     WebInspector.DOMModel.hideDOMNodeHighlight();
     WebInspector.DOMModel._highlightDisabled = true;
-}
+};
 
 WebInspector.DOMModel.unmuteHighlight = function()
 {
     WebInspector.DOMModel._highlightDisabled = false;
-}
+};
 
 WebInspector.DOMModel.cancelSearch = function()
 {
     for (var domModel of WebInspector.DOMModel.instances())
         domModel._cancelSearch();
-}
+};
 
 WebInspector.DOMModel.prototype = {
     /**
      * @param {!WebInspector.DOMNode} node
      */
     _scheduleMutationEvent: function(node)
     {
         if (!this.hasEventListeners(WebInspector.DOMModel.Events.DOMMutated))
             return;
 
@@ skipping 865 matching lines @@
     nodeHighlightRequested: function(nodeId)
     {
         var node = this.nodeForId(nodeId);
         if (!node)
             return;
 
         this.dispatchEventToListeners(WebInspector.DOMModel.Events.NodeHighlightedInOverlay, node);
     },
 
     __proto__: WebInspector.SDKModel.prototype
-}
+};
 
 /**
  * @constructor
  * @implements {DOMAgent.Dispatcher}
  * @param {!WebInspector.DOMModel} domModel
  */
 WebInspector.DOMDispatcher = function(domModel)
 {
     this._domModel = domModel;
-}
+};
 
 WebInspector.DOMDispatcher.prototype = {
     /**
      * @override
      */
     documentUpdated: function()
     {
         this._domModel._documentUpdated();
     },
 
@@ skipping 138 matching lines @@
     },
 
     /**
      * @override
      * @param {!DOMAgent.NodeId} nodeId
      */
     nodeHighlightRequested: function(nodeId)
     {
         this._domModel.nodeHighlightRequested(nodeId);
     }
-}
+};
 
 /**
  * @interface
  */
 WebInspector.DOMNodeHighlighter = function() {
-}
+};
 
 WebInspector.DOMNodeHighlighter.prototype = {
     /**
      * @param {?WebInspector.DOMNode} node
      * @param {!DOMAgent.HighlightConfig} config
      * @param {!DOMAgent.BackendNodeId=} backendNodeId
      * @param {!RuntimeAgent.RemoteObjectId=} objectId
      */
     highlightDOMNode: function(node, config, backendNodeId, objectId) {},
 
     /**
      * @param {!DOMAgent.InspectMode} mode
      * @param {!DOMAgent.HighlightConfig} config
      * @param {function(?Protocol.Error)=} callback
      */
     setInspectMode: function(mode, config, callback) {},
 
     /**
      * @param {!PageAgent.FrameId} frameId
      */
     highlightFrame: function(frameId) {}
-}
+};
 
 /**
  * @constructor
  * @implements {WebInspector.DOMNodeHighlighter}
  * @param {!Protocol.DOMAgent} agent
  */
 WebInspector.DefaultDOMNodeHighlighter = function(agent)
 {
     this._agent = agent;
-}
+};
 
 WebInspector.DefaultDOMNodeHighlighter.prototype = {
     /**
      * @override
      * @param {?WebInspector.DOMNode} node
      * @param {!DOMAgent.HighlightConfig} config
      * @param {!DOMAgent.BackendNodeId=} backendNodeId
      * @param {!RuntimeAgent.RemoteObjectId=} objectId
      */
     highlightDOMNode: function(node, config, backendNodeId, objectId)
@@ skipping 16 matching lines @@
     },
 
     /**
      * @override
      * @param {!PageAgent.FrameId} frameId
      */
     highlightFrame: function(frameId)
     {
         this._agent.highlightFrame(frameId, WebInspector.Color.PageHighlight.Content.toProtocolRGBA(), WebInspector.Color.PageHighlight.ContentOutline.toProtocolRGBA());
     }
-}
+};
 
 /**
  * @param {!WebInspector.Target} target
  * @return {?WebInspector.DOMModel}
  */
 WebInspector.DOMModel.fromTarget = function(target)
 {
     return /** @type {?WebInspector.DOMModel} */ (target.model(WebInspector.DOMModel));
-}
+};