Publish Vulpes Preview 15 sources for desktop, Android and Tundra

Share Gaia assets and adapters, keep private profiles and development documents local, and update both public READMEs.

gaia/tools/extensions/browser-helper@gaiamobile.org/bootstrap.js

@@ -0,0 +1,292 @@
+/* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- /
+/* vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: */
+
+'use strict';
+
+const Cc = Components.classes;
+const Ci = Components.interfaces;
+const Cu = Components.utils;
+
+Cu.import('resource://gre/modules/Services.jsm');
+
+function debug(data) {
+  dump('browser-helper: ' + data + '\n');
+}
+
+function initResponsiveDesign(browserWindow) {
+  // Inject custom controls in responsive view
+  Cu.import('resource:///modules/devtools/responsivedesign.jsm');
+  ResponsiveUIManager.once('on', function(event, {tab:tab}) {
+    let responsive = tab.__responsiveUI;
+    let document = tab.ownerDocument;
+
+    browserWindow.shell = {
+      sendChromeEvent: sendChromeEvent
+    };
+
+    // Ensure tweaking only the first responsive mode opened
+    responsive.stack.classList.add('os-mode');
+
+    let sleepButton = document.createElement('button');
+    sleepButton.id = 'os-sleep-button';
+    sleepButton.setAttribute('top', 0);
+    sleepButton.setAttribute('right', 0);
+    sleepButton.addEventListener('mousedown', function() {
+      sendChromeEvent({type: 'sleep-button-press'});
+    });
+    sleepButton.addEventListener('mouseup', function() {
+      sendChromeEvent({type: 'sleep-button-release'});
+    });
+    responsive.stack.appendChild(sleepButton);
+
+    let volumeButtons = document.createElement('vbox');
+    volumeButtons.id = 'os-volume-buttons';
+    volumeButtons.setAttribute('top', 0);
+    volumeButtons.setAttribute('left', 0);
+
+    let volumeUp = document.createElement('button');
+    volumeUp.id = 'os-volume-up-button';
+    volumeUp.addEventListener('mousedown', function() {
+      sendChromeEvent({type: 'volume-up-button-press'});
+    });
+    volumeUp.addEventListener('mouseup', function() {
+      sendChromeEvent({type: 'volume-up-button-release'});
+    });
+
+    let volumeDown = document.createElement('button');
+    volumeDown.id = 'os-volume-down-button';
+    volumeDown.addEventListener('mousedown', function() {
+      sendChromeEvent({type: 'volume-down-button-press'});
+    });
+    volumeDown.addEventListener('mouseup', function() {
+      sendChromeEvent({type: 'volume-down-button-release'});
+    });
+
+    volumeButtons.appendChild(volumeUp);
+    volumeButtons.appendChild(volumeDown);
+    responsive.stack.appendChild(volumeButtons);
+
+    // <toolbar id="os-hardware-button">
+    //  <toolbarbutton id="os-home-button" />
+    // </toolbar>
+    let bottomToolbar = document.createElement('toolbar');
+    bottomToolbar.id = 'os-hardware-buttons';
+    bottomToolbar.setAttribute('align', 'center');
+    bottomToolbar.setAttribute('pack', 'center');
+
+    let homeButton = document.createElement('toolbarbutton');
+    homeButton.id = 'os-home-button';
+    homeButton.setAttribute('class', 'devtools-toolbarbutton');
+
+    homeButton.addEventListener('mousedown', function() {
+      sendChromeEvent({type: 'home-button-press'});
+    });
+    homeButton.addEventListener('mouseup', function() {
+      sendChromeEvent({type: 'home-button-release'});
+    });
+    bottomToolbar.appendChild(homeButton);
+    responsive.container.appendChild(bottomToolbar);
+
+    // Simulate chrome event.
+    function sendChromeEvent(detail) {
+      let contentWindow = responsive.browser.contentWindow;
+      var contentDetail = Components.utils.createObjectIn(contentWindow);
+      for (var i in detail) {
+        contentDetail[i] = detail[i];
+      }
+      Components.utils.makeObjectPropsNormal(contentDetail);
+
+      var customEvt = contentWindow.document.createEvent('CustomEvent');
+      customEvt.initCustomEvent('mozChromeEvent', true, true, contentDetail);
+      contentWindow.dispatchEvent(customEvt);
+    }
+  });
+
+  // Cleanup responsive mode if it's disabled
+  ResponsiveUIManager.on('off', function(event, tab, responsive) {
+    if (responsive.stack.classList.contains('os-mode')) {
+      responsive.stack.classList.remove('os-mode');
+      let document = tab.ownerDocument;
+      let sleepButton = document.getElementById('os-sleep-button');
+      responsive.stack.removeChild(sleepButton);
+      let volumeButtons = document.getElementById('os-volume-buttons');
+      responsive.stack.removeChild(volumeButtons);
+      let bottomToolbar = document.getElementById('os-hardware-buttons');
+      responsive.container.removeChild(bottomToolbar);
+    }
+  });
+
+  // Automatically toggle responsive design mode
+  let mgr = browserWindow.ResponsiveUI.ResponsiveUIManager;
+  mgr.handleGcliCommand(browserWindow,
+                        browserWindow.gBrowser.selectedTab,
+                        'resize on');
+
+  // Enable touch events
+  browserWindow.gBrowser.selectedTab.__responsiveUI.enableTouch();
+}
+
+function startup(data, reason) {
+  try {
+    // Initialize various JSM instanciated by shell.js
+    // All of them are usefull even if we don't use them in this file.
+    Cu.import('resource://gre/modules/ContactService.jsm');
+    Cu.import('resource://gre/modules/SettingsRequestManager.jsm');
+    Cu.import('resource://gre/modules/ActivitiesService.jsm');
+
+    var mm = Cc['@mozilla.org/globalmessagemanager;1']
+               .getService(Ci.nsIMessageBroadcaster);
+    // Allow panning to work in the system app.
+    mm.loadFrameScript('chrome://global/content/BrowserElementPanning.js', true);
+
+    // Enable mozApps.getAll and app.launch to work.
+    // By default on firefox, apps are consider as not launchable
+    // and only launchable apps appear in getAll().
+    Cu.import('resource://gre/modules/Webapps.jsm');
+    DOMApplicationRegistry.allAppsLaunchable = true;
+
+    // Track loading of the system app in order to load our striped down copy
+    // of shell.xul
+    Services.obs.addObserver(function(document) {
+      // Some documents like XBL don't have location and should be ignored
+      if (!document.location)
+        return;
+      let domain = document.location.toString();
+      if (domain.indexOf('system.gaiamobile.org') != -1) {
+        let scope = {
+          content: document.defaultView
+        };
+        Services.scriptloader.loadSubScript(
+          'chrome://browser-helper.js/content/shell.js', scope);
+      }
+    }, 'document-element-inserted', false);
+
+    // Watch for app load start in firefox tabs.
+    // We have to set the app id on each docshell where we are trying to load
+    // an app. That's because we can't set mozapp attribute on firefox iframes
+    // as Firefox is still using xul:browser.
+    let nsIWebProgressListener = Ci.nsIWebProgressListener;
+    let appsService = Cc['@mozilla.org/AppsService;1'].getService(Ci.nsIAppsService);
+    let docShellListener = {
+      onStateChange: function onStateChange(webProgress, request, flags, status) {
+        if (!webProgress.chromeEventHandler ||
+             webProgress.chromeEventHandler.tagName != "xul:browser") {
+          // Only set app id for firefox tab <xul:browser> frames
+          return;
+        }
+
+        // Catch any load start request
+        if (flags & nsIWebProgressListener.STATE_START &&
+            flags & nsIWebProgressListener.STATE_IS_DOCUMENT &&
+            (request instanceof Ci.nsIChannel || 'URI' in request)) {
+          // Try to compute the manifest URL out of document URL
+          // We should end up with urls like:
+          //   http://system.gaiamobile.org:8080/manifest.webapp
+          //   app://system.gaiamobile.org/manifest.webapp
+          let manifestURL = 'app://'+ request.URI.host +'/manifest.webapp';
+          let manifest = appsService.getAppByManifestURL(manifestURL);
+          if (manifest) {
+            let app = manifest.QueryInterface(Ci.mozIApplication);
+            // test-agent expects its iframes to load apps without any permissions
+            // so prevent setting the correct app id to its iframes
+            if (!webProgress.DOMWindow || !webProgress.DOMWindow.top ||
+                !webProgress.DOMWindow.top.location.host.startsWith("test-agent.gaiamobile.org")) {
+              webProgress.QueryInterface(Ci.nsIDocShell).setIsApp(app.localId);
+            }
+          }
+        }
+      }
+    };
+
+    // Watch for new Firefox top level windows
+    Services.obs.addObserver(function(win) {
+      win.addEventListener('DOMContentLoaded', function loaded() {
+        win.removeEventListener('DOMContentLoaded', loaded);
+        if (win.gBrowser) {
+          // Listen for loads happening in all browser windows.
+          win.gBrowser.addProgressListener(docShellListener);
+        }
+      });
+    }, 'domwindowopened', false);
+
+    Services.obs.addObserver(function() {
+      let browserWindow = Services.wm.getMostRecentWindow('navigator:browser');
+
+      // Inject CSS in browser to customize responsive view
+      let doc = browserWindow.document;
+      let pi = doc.createProcessingInstruction('xml-stylesheet', 'href="chrome://browser-helper.js/content/browser.css" type="text/css"');
+      doc.insertBefore(pi, doc.firstChild);
+
+      // Start responsive design mode
+      initResponsiveDesign(browserWindow);
+
+      // And devtool panel while maximizing its size according to screen size
+      Services.prefs.setIntPref('devtools.toolbox.sidebar.width',
+                                browserWindow.outerWidth - 550);
+      gDevToolsBrowser.selectToolCommand(browserWindow.gBrowser);
+
+      let KeyboardGlobal = Cu.import('resource://gre/modules/Keyboard.jsm');
+
+      // SystemAppProxy.jsm doesn't ship into Firefox.
+      // Keyboard.jsm is the only one user of it outside of b2g/ folder.
+      // So hack it, in order to allow keyboard to send events to the system app
+      Object.defineProperty(KeyboardGlobal, "SystemAppProxy", {
+        value: {
+          dispatchEvent: function (detail) {
+            let contentWindow = browserWindow.content;
+            var contentDetail = Components.utils.createObjectIn(contentWindow);
+            for (var i in detail) {
+              contentDetail[i] = detail[i];
+            }
+            Components.utils.makeObjectPropsNormal(contentDetail);
+
+            var customEvt = contentWindow.document.createEvent('CustomEvent');
+            customEvt.initCustomEvent('mozChromeEvent', true, true, contentDetail);
+            contentWindow.dispatchEvent(customEvt);
+          }
+        }
+      });
+
+      Keyboard.initFormsFrameScript(mm);
+      mm.loadFrameScript('chrome://global/content/forms.js', true);
+    }, 'sessionstore-windows-restored', false);
+
+    try {
+      // Register a new devtool panel with various OS controls
+      Cu.import('resource:///modules/devtools/gDevTools.jsm');
+      gDevTools.registerTool({
+        id: 'firefox-os-controls',
+        key: 'F',
+        modifiers: 'accel,shift',
+        icon: 'chrome://browser-helper.js/content/panel/icon.gif',
+        url: 'chrome://browser-helper.js/content/panel/index.html',
+        label: 'FFOS Control',
+        tooltip: 'Set of controls to tune FirefoxOS apps in Desktop browser',
+        isTargetSupported: function(target) {
+          return target.isLocalTab;
+        },
+        build: function(iframeWindow, toolbox) {
+          iframeWindow.wrappedJSObject.tab = toolbox.target.window;
+          return {
+            destroy: function () {}
+          };
+        }
+      });
+    } catch(e) {
+      debug('Can\'t load the devtools panel. Likely because this version of Gecko is too old');
+    }
+
+  } catch (e) {
+    debug('Something went wrong while trying to start browser-helper: ' + e);
+  }
+}
+
+function shutdown(data, reason) {
+  // prevent stdout warnings
+}
+
+function install(data, reason) {
+}
+
+function uninstall(data, reason) {
+}

gaia/tools/extensions/browser-helper@gaiamobile.org/chrome.manifest

@@ -0,0 +1 @@
+content browser-helper.js content/

gaia/tools/extensions/browser-helper@gaiamobile.org/content/browser.css

@@ -0,0 +1,102 @@
+
+
+/* Ignore devtools usual resizer */
+stack.browserStack.os-mode box.devtools-responsiveui-resizehandle,
+stack.browserStack.os-mode box.devtools-responsiveui-resizebar {
+  display: none;
+}
+
+/* Gives responsive mode a phone look'n feel */
+stack.browserStack.os-mode {
+  padding: 60px 15px 0;
+
+  border-radius: 25px / 20px;
+  border-bottom-left-radius: 0;
+  border-bottom-right-radius: 0;
+  border: 1px solid #FFFFFF;
+  border-bottom-width: 0;
+  
+  background-color: #353535;
+  
+  box-shadow: 0 3px 0.7px 1px #777777, 0 5px rgba(0, 0, 0, 0.4) inset !important;
+
+  background-image: -moz-linear-gradient(right, #111 11%, #333 56%);
+  min-width: 320px;
+}
+
+#os-hardware-buttons {
+  -moz-appearance: none;
+  padding: 20px;
+  
+  border: 1px solid #FFFFFF;
+  border-bottom-left-radius: 25px;
+  border-bottom-right-radius: 25px;
+  border-top-width: 0;
+
+  box-shadow: 0 3px 0.7px 1px #777777, 0 -7px rgba(0, 0, 0, 0.4) inset;
+
+  background-image: -moz-linear-gradient(right, #111 11%, #333 56%);
+}
+
+#os-home-button {
+  width: 40px;
+  height: 30px;
+  list-style-image: url("chrome://browser-helper.js/content/icons/home.png");
+  -moz-image-region: rect(0, 12px, 12px, 0);
+}
+
+#os-home-button:hover:active {
+  -moz-image-region: rect(0, 24px, 12px, 12px);
+}
+
+#os-sleep-button {
+  -moz-appearance: none;
+  /* compensate browserStack top padding */
+  margin-top: -67px;
+  margin-right: 10px;
+
+  min-width: 10px;
+  width: 50px;
+  height: 5px;
+
+  border: 1px solid #444;
+  border-top-right-radius: 12px;
+  border-top-left-radius: 12px;
+  border-bottom-color: transparent;
+
+  background-image: -moz-linear-gradient(top, #111 11%, #333 56%);
+}
+
+#os-sleep-button:hover:active {
+  background-image: -moz-linear-gradient(top, #aaa 11%, #ddd 56%);
+}
+
+#os-volume-buttons {
+  margin-left: -29px;
+}
+
+#os-volume-up-button,
+#os-volume-down-button {
+  -moz-appearance: none;
+  border: 1px solid red;
+  min-width: 8px;
+  height: 40px;
+
+  border: 1px solid #444;
+  border-right-color: transparent;
+
+  background-image: -moz-linear-gradient(right, #111 11%, #333 56%);
+}
+
+#os-volume-up-button:hover:active,
+#os-volume-down-button:hover:active {
+  background-image: -moz-linear-gradient(right, #aaa 11%, #ddd 56%);
+}
+
+#os-volume-up-button {
+  border-top-left-radius: 12px;
+}
+
+#os-volume-down-button {
+  border-bottom-left-radius: 12px;
+}

gaia/tools/extensions/browser-helper@gaiamobile.org/content/panel/controls.js

@@ -0,0 +1,78 @@
+!function() {
+
+function sendChromeEvent(detail) {
+  var contentDetail = Components.utils.createObjectIn(tab);
+  for (var i in detail) {
+    contentDetail[i] = detail[i];
+  }
+  Components.utils.makeObjectPropsNormal(contentDetail);
+
+  var customEvt = tab.document.createEvent('CustomEvent');
+  customEvt.initCustomEvent('mozChromeEvent', true, true, contentDetail);
+  tab.dispatchEvent(customEvt);
+}
+
+function sendEvent(type, details) {
+  var event = new tab.CustomEvent(type, details);
+  tab.dispatchEvent(event);
+}
+
+function takeScreenshot() {
+  var canvas = document.createElementNS('http://www.w3.org/1999/xhtml',
+                                            'canvas');
+  var width = tab.innerWidth;
+  var height = tab.innerHeight;
+  canvas.setAttribute('width', width);
+  canvas.setAttribute('height', height);
+
+  var context = canvas.getContext('2d');
+  var flags =
+    context.DRAWWINDOW_DRAW_CARET |
+    context.DRAWWINDOW_DRAW_VIEW |
+    context.DRAWWINDOW_USE_WIDGET_LAYERS;
+  context.drawWindow(tab, 0, 0, width, height,
+                     'rgb(255,255,255)', flags);
+
+  sendChromeEvent({
+    type: 'take-screenshot-success',
+    file: canvas.mozGetAsFile('screenshot', 'image/png')
+  });
+}
+
+
+function Emulation() {
+
+}
+
+Emulation.prototype = {
+  notification: function() {
+    sendChromeEvent({
+      type: 'desktop-notification',
+      id: 123,
+      title: 'Some Notification',
+      text: 'I love notifications.',
+      manifestURL: 'http://sytem.gaiamobile.org:8080/manifest.webapp'
+    });
+  }
+};
+window.emulation = new Emulation();
+
+function Workflow() {
+
+}
+
+Workflow.prototype = {
+  reload: function() {
+    var global = tab.wrappedJSObject;
+    var app = global.System.curentApp;
+
+    app.reload();
+  },
+
+  screenshot: function() {
+    takeScreenshot();
+  }
+}
+window.workflow = new Workflow();
+
+}();

gaia/tools/extensions/browser-helper@gaiamobile.org/content/panel/index.html

@@ -0,0 +1,17 @@
+<link rel="stylesheet" href="stylesheet.css">
+<script defer src="controls.js"></script>
+<script defer src="workloads.js"></script>
+
+<h3>Emulation</h3>
+<section>
+  <button onclick="emulation.notification()">Notification</button>
+</section>
+
+<h3>Developer</h3>
+<section>
+  <button onclick="workflow.reload()">Reload Application</button>
+  <button onclick="workflow.screenshot()">Take a screenshot</button>
+  <select id="reference-workloads">
+    <option value="-1">Import workload:</option>
+  </select>
+</section>

gaia/tools/extensions/browser-helper@gaiamobile.org/content/panel/stylesheet.css

@@ -0,0 +1,12 @@
+* {
+	font-family: sans-serif;
+}
+
+section {
+	border-bottom: 1px solid #ccc;
+	padding-bottom: 1rem;
+}
+
+h3 {
+	margin-bottom: 1rem;
+}

gaia/tools/extensions/browser-helper@gaiamobile.org/content/panel/workloads.js

@@ -0,0 +1,78 @@
+!function() {
+
+  var select = document.getElementById('reference-workloads');
+
+  var options = [
+    {
+      name: 'contacts',
+      db: 'contacts',
+      counts: [0, 200, 500, 1000, 2000]
+    },
+    {
+      name: 'messages',
+      db: 'sms',
+      counts: [0, 200, 500, 1000, 2000]
+    },
+    {
+      name: 'dialer recents',
+      db: 'dialer',
+      counts: [0, 50, 100, 200, 500]
+    }
+  ];
+
+  var targetFiles = {
+    sms: '226660312ssm.sqlite',
+    contacts: '3406066227csotncta.sqlite',
+    dialer: '2584670174dsitanleecreR.sqlite'
+  };
+
+  for (var i = 0, option; option = options[i]; i++) {
+    for (var j = 0, cLen = option.counts.length; j < cLen; j++) {
+      var count = option.counts[j];
+      var optionEl = document.createElement('option');
+      optionEl.innerHTML = count + ' ' + option.name;
+      optionEl.value = option.db + '-' + count;
+      select.appendChild(optionEl);
+    }
+  }
+
+  select.addEventListener('change', function(e) {
+    var parts = this.value.split('-');
+    var database = parts[0];
+    var count = parts[1];
+
+    importRecords(database, count);
+
+    tab.alert('Imported: ' + count + ' ' + database + ' records.');
+    this.value = '-1';
+  });
+
+  function importRecords(database, count) {
+    var Ci = Components.interfaces;
+
+    Components.utils.import('resource://gre/modules/Services.jsm');
+    var currProfD = Services.dirsvc.get('ProfD', Ci.nsIFile);
+    var profileDir = currProfD.path;
+
+    var file = database + 'Db-' + count + '.sqlite';
+
+    var sourceFile = Services.dirsvc.get('ProfD', Ci.nsILocalFile);
+    sourceFile.append('..');
+    sourceFile.append('test_media');
+    sourceFile.append('reference-workload');
+    sourceFile.append(file);
+
+    var targetFolder = Services.dirsvc.get('ProfD', Ci.nsILocalFile);
+    targetFolder.append('storage');
+    targetFolder.append('persistent');
+    targetFolder.append('chrome');
+    targetFolder.append('idb');
+
+    try {
+      sourceFile.copyTo(targetFolder, targetFiles[database]);
+    } catch (e) {
+      tab.alert('Could not import file: ' + e);
+    }
+  }
+
+}();

gaia/tools/extensions/browser-helper@gaiamobile.org/content/shell.js

@@ -0,0 +1,187 @@
+
+dump('======== browser-helper: content.js loaded ========\n')
+
+function debug(str) {
+  //dump('browser-helper (frame-script): ' + str + '\n');
+}
+
+let CC = Components.Constructor;
+let Cc = Components.classes;
+let Ci = Components.interfaces;
+let Cu = Components.utils;
+let Cr = Components.results;
+
+Cu.import('resource://gre/modules/Services.jsm');
+Cu.import('resource://gre/modules/Keyboard.jsm');
+
+// Various helpers coming from /b2g/chrome/content/shell.js
+function getContentWindow() {
+  return content;
+}
+
+function sendChromeEvent(details, type) {
+  type = type || 'mozChromeEvent';
+  let content = getContentWindow();
+  details = details || {};
+
+  let event = content.document.createEvent('CustomEvent');
+  event.initCustomEvent(type, true, true,
+                        Cu.cloneInto(details, content));
+  content.dispatchEvent(event);
+}
+
+// Listen for app.launch calls and forward them to the the system app.
+// Copy of /b2g/chrome/content/shell.js
+Cu.import('resource://gre/modules/Webapps.jsm');
+Cu.import('resource://gre/modules/AppsUtils.jsm');
+
+Services.obs.addObserver(function onLaunch(subject, topic, data) {
+  let json = JSON.parse(data);
+
+  DOMApplicationRegistry.getManifestFor(json.manifestURL).then((aManifest) => {
+    if (!aManifest)
+      return;
+
+    let manifest = new ManifestHelper(aManifest, json.origin,
+      json.manifestURL);
+    let data = {
+      'timestamp': json.timestamp,
+      'url': manifest.fullLaunchPath(json.startPoint),
+      'manifestURL': json.manifestURL
+    };
+    sendChromeEvent(data, 'webapps-launch');
+  });
+}, 'webapps-launch', false);
+
+
+// Listen for system messages and relay them to Gaia.
+// Copy of /b2g/chrome/content/shell.js
+// XXX This code should be loaded in the activities/ extension
+Services.obs.addObserver(function onSystemMessage(subject, topic, data) {
+  let msg = JSON.parse(data);
+
+  let origin = Services.io.newURI(msg.manifest, null, null).prePath;
+  sendChromeEvent({
+    url: msg.uri,
+    manifestURL: msg.manifest,
+    isActivity: (msg.type == 'activity'),
+    target: msg.target,
+    expectingSystemMessage: true
+  }, 'open-app');
+}, 'system-messages-open-app', false);
+
+Services.obs.addObserver(function(aSubject, aTopic, aData) {
+  let data = JSON.parse(aData);
+  sendChromeEvent({
+    type: 'activity-done',
+    success: data.success,
+    manifestURL: data.manifestURL,
+    pageURL: data.pageURL
+  });
+}, 'activity-done', false);
+
+
+
+// =================== Settings ====================
+// Copy of /b2g/chrome/content/settings.js
+var SettingsListener = {
+  _callbacks: {},
+
+  init: function sl_init() {
+    if ('mozSettings' in content.navigator && content.navigator.mozSettings) {
+      content.navigator.mozSettings.onsettingchange = this.onchange.bind(this);
+    }
+  },
+
+ onchange: function sl_onchange(evt) {
+    var callback = this._callbacks[evt.settingName];
+    if (callback) {
+      callback(evt.settingValue);
+    }
+  },
+
+  observe: function sl_observe(name, defaultValue, callback) {
+    var settings = content.navigator.mozSettings;
+    if (!settings) {
+      content.setTimeout(function() { callback(defaultValue); });
+      return;
+    }
+
+    if (!callback || typeof callback !== 'function') {
+      throw new Error('Callback is not a function');
+    }
+
+    var req = settings.createLock().get(name);
+    req.addEventListener('success', (function onsuccess() {
+      callback(typeof(req.result[name]) != 'undefined' ?
+        req.result[name] : defaultValue);
+    }));
+
+    this._callbacks[name] = callback;
+  }
+};
+
+SettingsListener.init();
+
+// =================== Languages ====================
+// Modified copy of /b2g/chrome/content/settings.js
+SettingsListener.observe('language.current', 'en-US', function(value) {
+  Services.prefs.setCharPref('general.useragent.locale', value);
+
+  let prefName = 'intl.accept_languages';
+  if (Services.prefs.prefHasUserValue(prefName)) {
+    Services.prefs.clearUserPref(prefName);
+  }
+
+  let intl = '';
+  try {
+    intl = Services.prefs.getComplexValue(prefName,
+                                        Ci.nsIPrefLocalizedString).data;
+  } catch(e) {}
+
+  // Bug 830782 - Homescreen is in English instead of selected locale after
+  // the first run experience.
+  // In order to ensure the current intl value is reflected on the child
+  // process let's always write a user value, even if this one match the
+  // current localized pref value.
+  if (!((new RegExp('^' + value + '[^a-z-_] *[,;]?', 'i')).test(intl))) {
+    value = value + ', ' + intl;
+  } else {
+    value = intl;
+  }
+  Services.prefs.setCharPref(prefName, value);
+
+  //XXX: modification of settings.js here:
+  var window = getContentWindow();
+  if (!('hasStarted' in window) && window.hasStarted != true) {
+    window.hasStarted = true;
+
+    window.addEventListener('load', function onload() {
+      window.removeEventListener('load', onload);
+      window.setTimeout(function() {
+        sendChromeEvent({'type': 'webapps-registry-ready'});
+      });
+    });
+  }
+});
+
+/**
+ * This code comes from b2g/chrome/content/shell.js
+ * For now just the keyboard stuff, should copy everything over at some point
+ */
+getContentWindow().addEventListener('mozContentEvent', function(evt) {
+  let detail = evt.detail;
+  debug('XXX FIXME : Got a mozContentEvent: ' + detail.type + "\n");
+
+  switch(detail.type) {
+    case 'inputmethod-update-layouts':
+      KeyboardHelper.handleEvent(detail);
+      break;
+  }
+});
+
+let KeyboardHelper = {
+  handleEvent: function keyboard_handleEvent(aMessage) {
+    Keyboard.setLayouts(aMessage.layouts);
+  }
+};

gaia/tools/extensions/browser-helper@gaiamobile.org/install.rdf

@@ -0,0 +1,23 @@
+<?xml version="1.0"?>
+
+<RDF xmlns="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+     xmlns:em="http://www.mozilla.org/2004/em-rdf#">
+
+  <Description about="urn:mozilla:install-manifest">
+    <em:id>browser-helper@gaiamobile.org</em:id>
+    <em:name>browser-helper.js</em:name>
+    <em:version>0.1</em:version>
+    <em:targetApplication>
+      <Description>
+       <em:id>{ec8030f7-c20a-464f-9b0e-13a3a9e97384}</em:id>
+       <em:minVersion>6.0</em:minVersion>
+       <em:maxVersion>*</em:maxVersion>
+     </Description>
+    </em:targetApplication>
+    <em:unpack>true</em:unpack>
+    <em:bootstrap>true</em:bootstrap>
+    <em:creator>Mozilla</em:creator>
+    <em:description>browser shims to make gaia work in desktop browser</em:description>
+    <em:homepageURL>https://github.com/mozilla-b2g/gaia/</em:homepageURL>
+  </Description>
+</RDF>