DevTools: use semicolons after each statement.

third_party/WebKit/Source/devtools/front_end/sdk/CookieParser.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 24 matching lines @@
 // which is in a format slightly different from Set-Cookie and is normally
 // only required on the server side.
 
 /**
  * @constructor
  * @param {!WebInspector.Target} target
  */
 WebInspector.CookieParser = function(target)
 {
     this._target = target;
-}
+};
 
 /**
  * @constructor
  * @param {string} key
  * @param {string|undefined} value
  * @param {number} position
  */
 WebInspector.CookieParser.KeyValue = function(key, value, position)
 {
     this.key = key;
     this.value = value;
     this.position = position;
-}
+};
 
 WebInspector.CookieParser.prototype = {
     /**
      * @return {!Array.<!WebInspector.Cookie>}
      */
     cookies: function()
     {
         return this._cookies;
     },
 
@@ skipping 112 matching lines @@
 };
 
 /**
  * @param {!WebInspector.Target} target
  * @param {string|undefined} header
  * @return {?Array.<!WebInspector.Cookie>}
  */
 WebInspector.CookieParser.parseCookie = function(target, header)
 {
     return (new WebInspector.CookieParser(target)).parseCookie(header);
-}
+};
 
 /**
  * @param {!WebInspector.Target} target
  * @param {string|undefined} header
  * @return {?Array.<!WebInspector.Cookie>}
  */
 WebInspector.CookieParser.parseSetCookie = function(target, header)
 {
     return (new WebInspector.CookieParser(target)).parseSetCookie(header);
-}
+};
 
 /**
  * @constructor
  * @param {!WebInspector.Target} target
  * @param {string} name
  * @param {string} value
  * @param {?WebInspector.Cookie.Type} type
  */
 WebInspector.Cookie = function(target, name, value, type)
 {
     this._target = target;
     this._name = name;
     this._value = value;
     this._type = type;
     this._attributes = {};
-}
+};
 
 WebInspector.Cookie.prototype = {
     /**
      * @return {string}
      */
     name: function()
     {
         return this._name;
     },
 
@@ skipping 137 matching lines @@
         this._attributes[key.toLowerCase()] = value;
     },
 
     /**
      * @param {function(?Protocol.Error)=} callback
      */
     remove: function(callback)
     {
         this._target.networkAgent().deleteCookie(this.name(), (this.secure() ? "https://" : "http://") + this.domain() + this.path(), callback);
     }
-}
+};
 
 /**
  * @enum {number}
  */
 WebInspector.Cookie.Type = {
     Request: 0,
     Response: 1
 };
 
-WebInspector.Cookies = {}
+WebInspector.Cookies = {};
 
 /**
  * @param {function(!Array.<!WebInspector.Cookie>)} callback
  */
 WebInspector.Cookies.getCookiesAsync = function(callback)
 {
     var allCookies = [];
     /**
      * @param {!WebInspector.Target} target
      * @param {?Protocol.Error} error
      * @param {!Array.<!NetworkAgent.Cookie>} cookies
      */
     function mycallback(target, error, cookies)
     {
         if (error) {
             console.error(error);
             return;
         }
         for (var i = 0; i < cookies.length; ++i)
             allCookies.push(WebInspector.Cookies._parseProtocolCookie(target, cookies[i]));
     }
 
     var barrier = new CallbackBarrier();
     for (var target of WebInspector.targetManager.targets(WebInspector.Target.Capability.Network))
         target.networkAgent().getCookies(barrier.createCallback(mycallback.bind(null, target)));
     barrier.callWhenDone(callback.bind(null, allCookies));
-}
+};
 
 /**
  * @param {!WebInspector.Target} target
  * @param {!NetworkAgent.Cookie} protocolCookie
  * @return {!WebInspector.Cookie}
  */
 WebInspector.Cookies._parseProtocolCookie = function(target, protocolCookie)
 {
     var cookie = new WebInspector.Cookie(target, protocolCookie.name, protocolCookie.value, null);
     cookie.addAttribute("domain", protocolCookie["domain"]);
     cookie.addAttribute("path", protocolCookie["path"]);
     cookie.addAttribute("port", protocolCookie["port"]);
     if (protocolCookie["expires"])
         cookie.addAttribute("expires", protocolCookie["expires"]);
     if (protocolCookie["httpOnly"])
         cookie.addAttribute("httpOnly");
     if (protocolCookie["secure"])
         cookie.addAttribute("secure");
     if (protocolCookie["sameSite"])
         cookie.addAttribute("sameSite", protocolCookie["sameSite"]);
     cookie.setSize(protocolCookie["size"]);
     return cookie;
-}
+};
 
 /**
  * @param {!WebInspector.Cookie} cookie
  * @param {string} resourceURL
  * @return {boolean}
  */
 WebInspector.Cookies.cookieMatchesResourceURL = function(cookie, resourceURL)
 {
     var url = resourceURL.asParsedURL();
     if (!url || !WebInspector.Cookies.cookieDomainMatchesResourceDomain(cookie.domain(), url.host))
         return false;
     return (url.path.startsWith(cookie.path())
         && (!cookie.port() || url.port === cookie.port())
         && (!cookie.secure() || url.scheme === "https"));
-}
+};
 
 /**
  * @param {string} cookieDomain
  * @param {string} resourceDomain
  * @return {boolean}
  */
 WebInspector.Cookies.cookieDomainMatchesResourceDomain = function(cookieDomain, resourceDomain)
 {
     if (cookieDomain.charAt(0) !== ".")
         return resourceDomain === cookieDomain;
     return !!resourceDomain.match(new RegExp("^([^\\.]+\\.)*" + cookieDomain.substring(1).escapeForRegExp() + "$", "i"));
-}
+};