The Tor Browser: browser/devtools/app-manager/webapps-store.js@6474c204b198 (annotated)

browser/devtools/app-manager/webapps-store.js@6474c204b198 (annotated)

browser/devtools/app-manager/webapps-store.js

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 const ObservableObject = require("devtools/shared/observable-object");
 const promise = require("devtools/toolkit/deprecated-sync-thenables");
 const {Connection} = require("devtools/client/connection-manager");
 const {Cu} = require("chrome");
 const dbgClient = Cu.import("resource://gre/modules/devtools/dbg-client.jsm");
 const _knownWebappsStores = new WeakMap();
 let WebappsStore;
 module.exports = WebappsStore = function(connection) {
   // If we already know about this connection,
   // let's re-use the existing store.
   if (_knownWebappsStores.has(connection)) {
     return _knownWebappsStores.get(connection);
   }
   _knownWebappsStores.set(connection, this);
   ObservableObject.call(this, {});
   this._resetStore();
   this.destroy = this.destroy.bind(this);
   this._onStatusChanged = this._onStatusChanged.bind(this);
   this._connection = connection;
   this._connection.once(Connection.Events.DESTROYED, this.destroy);
   this._connection.on(Connection.Events.STATUS_CHANGED, this._onStatusChanged);
   this._onStatusChanged();
   return this;
 }
 WebappsStore.prototype = {
   destroy: function() {
     if (this._connection) {
       // While this.destroy is bound using .once() above, that event may not
       // have occurred when the WebappsStore client calls destroy, so we
       // manually remove it here.
       this._connection.off(Connection.Events.DESTROYED, this.destroy);
       this._connection.off(Connection.Events.STATUS_CHANGED, this._onStatusChanged);
       _knownWebappsStores.delete(this._connection);
       this._connection = null;
     }
   },
   _resetStore: function() {
     this.object.all = []; // list of app objects
     this.object.running = []; // list of manifests
   },
   _getAppFromManifest: function(manifest) {
     for (let app of this.object.all) {
       if (app.manifestURL == manifest) {
         return app;
       }
     }
     return null;
   },
   _onStatusChanged: function() {
     if (this._connection.status == Connection.Status.CONNECTED) {
       this._listTabs();
     } else {
       this._resetStore();
     }
   },
   _listTabs: function() {
     this._connection.client.listTabs((resp) => {
       this._webAppsActor = resp.webappsActor;
       this._feedStore();
     });
   },
   _feedStore: function(deviceFront, webAppsActor) {
     this._listenToApps();
     this._getAllApps()
     .then(this._getRunningApps.bind(this))
     .then(this._getAppsIcons.bind(this))
   },
   _listenToApps: function() {
     let deferred = promise.defer();
     let client = this._connection.client;
     let request = {
       to: this._webAppsActor,
       type: "watchApps"
     };
     client.request(request, (res) => {
       if (res.error) {
         return deferred.reject(res.error);
       }
       client.addListener("appOpen", (type, { manifestURL }) => {
         this._onAppOpen(manifestURL);
       });
       client.addListener("appClose", (type, { manifestURL }) => {
         this._onAppClose(manifestURL);
       });
       client.addListener("appInstall", (type, { manifestURL }) => {
         this._onAppInstall(manifestURL);
       });
       client.addListener("appUninstall", (type, { manifestURL }) => {
         this._onAppUninstall(manifestURL);
       });
       return deferred.resolve();
     })
     return deferred.promise;
   },
   _getAllApps: function() {
     let deferred = promise.defer();
     let request = {
       to: this._webAppsActor,
       type: "getAll"
     };
     this._connection.client.request(request, (res) => {
       if (res.error) {
         return deferred.reject(res.error);
       }
       let apps = res.apps;
       for (let a of apps) {
         a.running = false;
       }
       this.object.all = apps;
       return deferred.resolve();
     });
     return deferred.promise;
   },
   _getRunningApps: function() {
     let deferred = promise.defer();
     let request = {
       to: this._webAppsActor,
       type: "listRunningApps"
     };
     this._connection.client.request(request, (res) => {
       if (res.error) {
         return deferred.reject(res.error);
       }
       let manifests = res.apps;
       this.object.running = manifests;
       for (let m of manifests) {
         let a = this._getAppFromManifest(m);
         if (a) {
           a.running = true;
         } else {
           return deferred.reject("Unexpected manifest: " + m);
         }
       }
       return deferred.resolve();
     });
     return deferred.promise;
   },
   _getAppsIcons: function() {
     let deferred = promise.defer();
     let allApps = this.object.all;
     let request = {
       to: this._webAppsActor,
       type: "getIconAsDataURL"
     };
     let client = this._connection.client;
     let idx = 0;
     (function getIcon() {
       if (idx == allApps.length) {
         return deferred.resolve();
       }
       let a = allApps[idx++];
       request.manifestURL = a.manifestURL;
       return client.request(request, (res) => {
         if (res.error) {
           Cu.reportError(res.message || res.error);
         }
         if (res.url) {
           a.iconURL = res.url;
         }
         getIcon();
       });
     })();
     return deferred.promise;
   },
   _onAppOpen: function(manifest) {
     let a = this._getAppFromManifest(manifest);
     a.running = true;
     let running = this.object.running;
     if (running.indexOf(manifest) < 0) {
       this.object.running.push(manifest);
     }
   },
   _onAppClose: function(manifest) {
     let a = this._getAppFromManifest(manifest);
     a.running = false;
     let running = this.object.running;
     this.object.running = running.filter((m) => {
       return m != manifest;
     });
   },
   _onAppInstall: function(manifest) {
     let client = this._connection.client;
     let request = {
       to: this._webAppsActor,
       type: "getApp",
       manifestURL: manifest
     };
     client.request(request, (res) => {
       if (res.error) {
         if (res.error == "forbidden") {
           // We got a notification for an app we don't have access to.
           // Ignore.
           return;
         }
         Cu.reportError(res.message || res.error);
         return;
       }
       let app = res.app;
       app.running = false;
       let notFound = true;
       let proxifiedApp;
       for (let i = 0; i < this.object.all.length; i++) {
         let storedApp = this.object.all[i];
         if (storedApp.manifestURL == app.manifestURL) {
           this.object.all[i] = app;
           proxifiedApp = this.object.all[i];
           notFound = false;
           break;
         }
       }
       if (notFound) {
         this.object.all.push(app);
         proxifiedApp = this.object.all[this.object.all.length - 1];
       }
       request.type = "getIconAsDataURL";
       client.request(request, (res) => {
         if (res.url) {
           proxifiedApp.iconURL = res.url;
         }
       });
       // This app may have been running while being installed, so check the list
       // of running apps again to get the right answer.
       this._getRunningApps();
     });
   },
   _onAppUninstall: function(manifest) {
     this.object.all = this.object.all.filter((app) => {
       return (app.manifestURL != manifest);
     });
   },
 }