DevTools: rename WebInspector into modules.

third_party/WebKit/Source/devtools/front_end/services/ServiceManager.js

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 /**
  * @unrestricted
  */
-WebInspector.ServiceManager = class {
+Services.ServiceManager = class {
   /**
    * @param {string} serviceName
-   * @return {!Promise<?WebInspector.ServiceManager.Service>}
+   * @return {!Promise<?Services.ServiceManager.Service>}
    */
   createRemoteService(serviceName) {
     if (!this._remoteConnection) {
       var url = Runtime.queryParam('service-backend');
       if (!url) {
         console.error('No endpoint address specified');
-        return /** @type {!Promise<?WebInspector.ServiceManager.Service>} */ (Promise.resolve(null));
+        return /** @type {!Promise<?Services.ServiceManager.Service>} */ (Promise.resolve(null));
       }
       this._remoteConnection =
-          new WebInspector.ServiceManager.Connection(new WebInspector.ServiceManager.RemoteServicePort(url));
+          new Services.ServiceManager.Connection(new Services.ServiceManager.RemoteServicePort(url));
     }
     return this._remoteConnection._createService(serviceName);
   }
 
   /**
    * @param {string} appName
    * @param {string} serviceName
    * @param {boolean} isSharedWorker
-   * @return {!Promise<?WebInspector.ServiceManager.Service>}
+   * @return {!Promise<?Services.ServiceManager.Service>}
    */
   createAppService(appName, serviceName, isSharedWorker) {
     var url = appName + '.js';
     var remoteBase = Runtime.queryParam('remoteBase');
     if (remoteBase)
       url += '?remoteBase=' + remoteBase;
 
     var worker = isSharedWorker ? new SharedWorker(url, appName) : new Worker(url);
     var connection =
-        new WebInspector.ServiceManager.Connection(new WebInspector.ServiceManager.WorkerServicePort(worker));
+        new Services.ServiceManager.Connection(new Services.ServiceManager.WorkerServicePort(worker));
     return connection._createService(serviceName);
   }
 };
 
 /**
  * @unrestricted
  */
-WebInspector.ServiceManager.Connection = class {
+Services.ServiceManager.Connection = class {
   /**
    * @param {!ServicePort} port
    */
   constructor(port) {
     this._port = port;
     this._port.setHandlers(this._onMessage.bind(this), this._connectionClosed.bind(this));
 
     this._lastId = 1;
     /** @type {!Map<number, function(?Object)>}*/
     this._callbacks = new Map();
-    /** @type {!Map<string, !WebInspector.ServiceManager.Service>}*/
+    /** @type {!Map<string, !Services.ServiceManager.Service>}*/
     this._services = new Map();
   }
 
   /**
    * @param {string} serviceName
-   * @return {!Promise<?WebInspector.ServiceManager.Service>}
+   * @return {!Promise<?Services.ServiceManager.Service>}
    */
   _createService(serviceName) {
     return this._sendCommand(serviceName + '.create').then(result => {
       if (!result) {
         console.error('Could not initialize service: ' + serviceName);
         return null;
       }
-      var service = new WebInspector.ServiceManager.Service(this, serviceName, result.id);
+      var service = new Services.ServiceManager.Service(this, serviceName, result.id);
       this._services.set(serviceName + ':' + result.id, service);
       return service;
     });
   }
 
   /**
-   * @param {!WebInspector.ServiceManager.Service} service
+   * @param {!Services.ServiceManager.Service} service
    */
   _serviceDisposed(service) {
     this._services.delete(service._serviceName + ':' + service._objectId);
     if (!this._services.size) {
       // Terminate the connection since it is no longer used.
       this._port.close();
     }
   }
 
   /**
@@ skipping 47 matching lines @@
     this._callbacks.clear();
     for (var service of this._services.values())
       service._dispatchNotification('disposed');
     this._services.clear();
   }
 };
 
 /**
  * @unrestricted
  */
-WebInspector.ServiceManager.Service = class {
+Services.ServiceManager.Service = class {
   /**
-   * @param {!WebInspector.ServiceManager.Connection} connection
+   * @param {!Services.ServiceManager.Connection} connection
    * @param {string} serviceName
    * @param {string} objectId
    */
   constructor(connection, serviceName, objectId) {
     this._connection = connection;
     this._serviceName = serviceName;
     this._objectId = objectId;
     /** @type {!Map<string, function(!Object=)>}*/
     this._notificationHandlers = new Map();
   }
@@ skipping 38 matching lines @@
       return;
     }
     handler(params);
   }
 };
 
 /**
  * @implements {ServicePort}
  * @unrestricted
  */
-WebInspector.ServiceManager.RemoteServicePort = class {
+Services.ServiceManager.RemoteServicePort = class {
   /**
    * @param {string} url
    */
   constructor(url) {
     this._url = url;
   }
 
   /**
    * @override
    * @param {function(string)} messageHandler
    * @param {function(string)} closeHandler
    */
   setHandlers(messageHandler, closeHandler) {
     this._messageHandler = messageHandler;
     this._closeHandler = closeHandler;
   }
 
   /**
    * @return {!Promise<boolean>}
    */
   _open() {
     if (!this._connectionPromise)
       this._connectionPromise = new Promise(promiseBody.bind(this));
     return this._connectionPromise;
 
     /**
      * @param {function(boolean)} fulfill
-     * @this {WebInspector.ServiceManager.RemoteServicePort}
+     * @this {Services.ServiceManager.RemoteServicePort}
      */
     function promiseBody(fulfill) {
       var socket;
       try {
         socket = new WebSocket(/** @type {string} */ (this._url));
         socket.onmessage = onMessage.bind(this);
         socket.onclose = this._closeHandler;
         socket.onopen = onConnect.bind(this);
       } catch (e) {
         fulfill(false);
       }
 
       /**
-       * @this {WebInspector.ServiceManager.RemoteServicePort}
+       * @this {Services.ServiceManager.RemoteServicePort}
        */
       function onConnect() {
         this._socket = socket;
         fulfill(true);
       }
 
       /**
        * @param {!Event} event
-       * @this {WebInspector.ServiceManager.RemoteServicePort}
+       * @this {Services.ServiceManager.RemoteServicePort}
        */
       function onMessage(event) {
         this._messageHandler(event.data);
       }
     }
   }
 
   /**
    * @override
    * @param {string} message
@@ skipping 22 matching lines @@
       }
       return true;
     });
   }
 };
 
 /**
  * @implements {ServicePort}
  * @unrestricted
  */
-WebInspector.ServiceManager.WorkerServicePort = class {
+Services.ServiceManager.WorkerServicePort = class {
   /**
    * @param {!Worker|!SharedWorker} worker
    */
   constructor(worker) {
     this._worker = worker;
 
     var fulfill;
     this._workerPromise = new Promise(resolve => fulfill = resolve);
     this._isSharedWorker = worker instanceof SharedWorker;
 
     if (this._isSharedWorker) {
       this._worker.port.onmessage = onMessage.bind(this);
       this._worker.port.onclose = this._closeHandler;
     } else {
       this._worker.onmessage = onMessage.bind(this);
       this._worker.onclose = this._closeHandler;
     }
 
     /**
      * @param {!Event} event
-     * @this {WebInspector.ServiceManager.WorkerServicePort}
+     * @this {Services.ServiceManager.WorkerServicePort}
      */
     function onMessage(event) {
       if (event.data === 'workerReady') {
         fulfill(true);
         return;
       }
       this._messageHandler(event.data);
     }
   }
 
@@ skipping 32 matching lines @@
    */
   close() {
     return this._workerPromise.then(() => {
       if (this._worker)
         this._worker.terminate();
       return false;
     });
   }
 };
 
-WebInspector.serviceManager = new WebInspector.ServiceManager();
+Services.serviceManager = new Services.ServiceManager();