DevTools: use semicolons after each statement.

third_party/WebKit/Source/devtools/front_end/ui/Toolbar.js

 /*
  * Copyright (C) 2009 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 26 matching lines @@
 {
     /** @type {!Array.<!WebInspector.ToolbarItem>} */
     this._items = [];
     this._reverse = false;
     this.element = parentElement ? parentElement.createChild("div") : createElement("div");
     this.element.className = className;
     this.element.classList.add("toolbar");
     this._shadowRoot = WebInspector.createShadowRootWithCoreStyles(this.element, "ui/toolbar.css");
     this._contentElement = this._shadowRoot.createChild("div", "toolbar-shadow");
     this._insertionPoint = this._contentElement.createChild("content");
-}
+};
 
 WebInspector.Toolbar.prototype = {
     /**
      * @param {boolean=} reverse
      */
     makeWrappable: function(reverse)
     {
         this._contentElement.classList.add("wrappable");
         this._reverse = !!reverse;
         if (reverse)
@@ skipping 158 matching lines @@
          */
         function appendItemsInOrder(items)
         {
             for (var i = 0; i < items.length; ++i) {
                 var item = items[i];
                 if (item)
                     this.appendToolbarItem(item);
             }
         }
     }
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.Object}
  * @param {!Element} element
  */
 WebInspector.ToolbarItem = function(element)
 {
     this.element = element;
     this.element.classList.add("toolbar-item");
     this._visible = true;
     this._enabled = true;
     this.element.addEventListener("mouseenter", this._mouseEnter.bind(this), false);
     this.element.addEventListener("mouseleave", this._mouseLeave.bind(this), false);
-}
+};
 
 WebInspector.ToolbarItem.prototype = {
     /**
      * @param {string} title
      */
     setTitle: function(title)
     {
         if (this._title === title)
             return;
         this._title = title;
@@ skipping 41 matching lines @@
     {
         if (this._visible === x)
             return;
         this.element.classList.toggle("hidden", !x);
         this._visible = x;
         if (this._toolbar && !(this instanceof WebInspector.ToolbarSeparator))
             this._toolbar._hideSeparatorDupes();
     },
 
     __proto__: WebInspector.Object.prototype
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.ToolbarItem}
  * @param {string=} text
  */
 WebInspector.ToolbarText = function(text)
 {
     WebInspector.ToolbarItem.call(this, createElementWithClass("div", "toolbar-text"));
     this.element.classList.add("toolbar-text");
     this.setText(text || "");
-}
+};
 
 WebInspector.ToolbarText.prototype = {
      /**
      * @param {string} text
      */
     setText: function(text)
     {
         this.element.textContent = text;
     },
 
     __proto__: WebInspector.ToolbarItem.prototype
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.ToolbarItem}
  * @param {string} title
  * @param {string=} glyph
  * @param {string=} text
  */
 WebInspector.ToolbarButton = function(title, glyph, text)
 {
     WebInspector.ToolbarItem.call(this, createElementWithClass("button", "toolbar-button"));
     this.element.addEventListener("click", this._clicked.bind(this), false);
     this.element.addEventListener("mousedown", this._mouseDown.bind(this), false);
     this.element.addEventListener("mouseup", this._mouseUp.bind(this), false);
 
     this._glyphElement = this.element.createChild("div", "toolbar-glyph hidden");
     this._textElement = this.element.createChild("div", "toolbar-text hidden");
 
     this.setTitle(title);
     if (glyph)
         this.setGlyph(glyph);
     this.setText(text || "");
     this._state = "";
     this._title = "";
-}
+};
 
 WebInspector.ToolbarButton.prototype = {
     /**
      * @param {string} text
      */
     setText: function(text)
     {
         if (this._text === text)
             return;
         this._textElement.textContent = text;
@@ skipping 75 matching lines @@
 
     /**
      * @param {!Event} event
      */
     _mouseUp: function(event)
     {
         this.dispatchEventToListeners("mouseup", event);
     },
 
     __proto__: WebInspector.ToolbarItem.prototype
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.ToolbarItem}
  * @param {string=} placeholder
  * @param {number=} growFactor
  */
 WebInspector.ToolbarInput = function(placeholder, growFactor)
 {
     WebInspector.ToolbarItem.call(this, createElementWithClass("input", "toolbar-item"));
     this.element.addEventListener("input", this._onChangeCallback.bind(this), false);
     if (growFactor)
         this.element.style.flexGrow = growFactor;
     if (placeholder)
         this.element.setAttribute("placeholder", placeholder);
     this._value = "";
-}
+};
 
 WebInspector.ToolbarInput.Event = {
     TextChanged: "TextChanged"
 };
 
 WebInspector.ToolbarInput.prototype = {
     /**
      * @param {string} value
      */
     setValue: function(value)
     {
         this._value = value;
         this.element.value = value;
     },
 
     /**
      * @return {string}
      */
     value: function()
     {
         return this.element.value;
     },
 
     _onChangeCallback: function()
     {
         this.dispatchEventToListeners(WebInspector.ToolbarInput.Event.TextChanged, this.element.value);
     },
 
     __proto__: WebInspector.ToolbarItem.prototype
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.ToolbarButton}
  * @param {string} title
  * @param {string=} glyph
  * @param {string=} text
  */
 WebInspector.ToolbarToggle = function(title, glyph, text)
 {
     WebInspector.ToolbarButton.call(this, title, glyph, text);
     this._toggled = false;
     this.setState("off");
-}
+};
 
 WebInspector.ToolbarToggle.prototype = {
     /**
      * @return {boolean}
      */
     toggled: function()
     {
         return this._toggled;
     },
 
     /**
      * @param {boolean} toggled
      */
     setToggled: function(toggled)
     {
         if (this._toggled === toggled)
             return;
         this._toggled = toggled;
         this.setState(toggled ? "on" : "off");
     },
 
     __proto__: WebInspector.ToolbarButton.prototype
-}
+};
 
 /**
  * @param {!WebInspector.Action} action
  * @param {!Array<!WebInspector.ToolbarButton>=} toggledOptions
  * @param {!Array<!WebInspector.ToolbarButton>=} untoggledOptions
  * @return {!WebInspector.ToolbarItem}
  */
 WebInspector.Toolbar.createActionButton = function(action, toggledOptions, untoggledOptions)
 {
     var button = new WebInspector.ToolbarToggle(action.title(), action.icon());
@@ skipping 118 matching lines @@
 
             for (var i = 0; i < buttons.length; ++i) {
                 if (buttons[i].element.classList.contains("emulate-active")) {
                     buttons[i].element.classList.remove("emulate-active");
                     buttons[i]._clicked(e);
                     break;
                 }
             }
         }
     }
-}
+};
 
 /**
  * @param {string} actionId
  * @return {?WebInspector.ToolbarItem}
  */
 WebInspector.Toolbar.createActionButtonForId = function(actionId)
 {
     var action = WebInspector.actionRegistry.action(actionId);
     return /** @type {?WebInspector.ToolbarItem} */(action ? WebInspector.Toolbar.createActionButton(action) : null);
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.ToolbarButton}
  * @param {function(!WebInspector.ContextMenu)} contextMenuHandler
  * @param {boolean=} useSoftMenu
  */
 WebInspector.ToolbarMenuButton = function(contextMenuHandler, useSoftMenu)
 {
     WebInspector.ToolbarButton.call(this, "", "menu-toolbar-item");
     this._contextMenuHandler = contextMenuHandler;
     this._useSoftMenu = !!useSoftMenu;
-}
+};
 
 WebInspector.ToolbarMenuButton.prototype = {
     /**
      * @override
      * @param {!Event} event
      */
     _mouseDown: function(event)
     {
         if (event.buttons !== 1) {
             WebInspector.ToolbarButton.prototype._mouseDown.call(this, event);
@@ skipping 24 matching lines @@
      */
     _clicked: function(event)
     {
         if (!this._triggerTimeout)
             return;
         clearTimeout(this._triggerTimeout);
         this._trigger(event);
     },
 
     __proto__: WebInspector.ToolbarButton.prototype
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.ToolbarToggle}
  * @param {!WebInspector.Setting} setting
  * @param {string} glyph
  * @param {string} title
  * @param {string=} toggledTitle
  */
 WebInspector.ToolbarSettingToggle = function(setting, glyph, title, toggledTitle)
 {
     WebInspector.ToolbarToggle.call(this, title, glyph);
     this._defaultTitle = title;
     this._toggledTitle = toggledTitle || title;
     this._setting = setting;
     this._settingChanged();
     this._setting.addChangeListener(this._settingChanged, this);
-}
+};
 
 WebInspector.ToolbarSettingToggle.prototype = {
     _settingChanged: function()
     {
         var toggled = this._setting.get();
         this.setToggled(toggled);
         this.setTitle(toggled ? this._toggledTitle : this._defaultTitle);
     },
 
     /**
      * @override
      * @param {!Event} event
      */
     _clicked: function(event)
     {
         this._setting.set(!this.toggled());
         WebInspector.ToolbarToggle.prototype._clicked.call(this, event);
     },
 
     __proto__: WebInspector.ToolbarToggle.prototype
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.ToolbarItem}
  * @param {boolean=} spacer
  */
 WebInspector.ToolbarSeparator = function(spacer)
 {
     WebInspector.ToolbarItem.call(this, createElementWithClass("div", spacer ? "toolbar-spacer" : "toolbar-divider"));
-}
+};
 
 WebInspector.ToolbarSeparator.prototype = {
     __proto__: WebInspector.ToolbarItem.prototype
-}
+};
 
 /**
  * @interface
  */
 WebInspector.ToolbarItem.Provider = function()
 {
-}
+};
 
 WebInspector.ToolbarItem.Provider.prototype = {
     /**
      * @return {?WebInspector.ToolbarItem}
      */
     item: function() {}
-}
+};
 
 /**
  * @interface
  */
 WebInspector.ToolbarItem.ItemsProvider = function()
 {
-}
+};
 
 WebInspector.ToolbarItem.ItemsProvider.prototype = {
     /**
      * @return {!Array<!WebInspector.ToolbarItem>}
      */
     toolbarItems: function() {}
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.ToolbarItem}
  * @param {?function(!Event)} changeHandler
  * @param {string=} className
  */
 WebInspector.ToolbarComboBox = function(changeHandler, className)
 {
     WebInspector.ToolbarItem.call(this, createElementWithClass("span", "toolbar-select-container"));
 
     this._selectElement = this.element.createChild("select", "toolbar-item");
     this.element.createChild("div", "toolbar-dropdown-arrow");
     if (changeHandler)
         this._selectElement.addEventListener("change", changeHandler, false);
     if (className)
         this._selectElement.classList.add(className);
-}
+};
 
 WebInspector.ToolbarComboBox.prototype = {
     /**
      * @return {!HTMLSelectElement}
      */
     selectElement: function()
     {
         return /** @type {!HTMLSelectElement} */ (this._selectElement);
     },
 
@@ skipping 95 matching lines @@
 
     /**
      * @param {number} width
      */
     setMaxWidth: function(width)
     {
         this._selectElement.style.maxWidth = width + "px";
     },
 
     __proto__: WebInspector.ToolbarItem.prototype
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.ToolbarItem}
  * @param {string} text
  * @param {string=} title
  * @param {!WebInspector.Setting=} setting
  * @param {function()=} listener
  */
 WebInspector.ToolbarCheckbox = function(text, title, setting, listener)
 {
     WebInspector.ToolbarItem.call(this, createCheckboxLabel(text));
     this.element.classList.add("checkbox");
     this.inputElement = this.element.checkboxElement;
     if (title)
         this.element.title = title;
     if (setting)
         WebInspector.SettingsUI.bindCheckbox(this.inputElement, setting);
     if (listener)
         this.inputElement.addEventListener("click", listener, false);
-}
+};
 
 WebInspector.ToolbarCheckbox.prototype = {
     /**
      * @return {boolean}
      */
     checked: function()
     {
         return this.inputElement.checked;
     },
 
     /**
      * @param {boolean} value
      */
     setChecked: function(value)
     {
         this.inputElement.checked = value;
     },
 
     __proto__: WebInspector.ToolbarItem.prototype
-}
+};