Convert all source files to JavaScript

atom/renderer/api/lib/desktop-capturer.coffee

@@ -1,20 +0,0 @@
-{ipcRenderer, nativeImage} = require 'electron'
-
-nextId = 0
-getNextId = -> ++nextId
-
-### |options.type| can not be empty and has to include 'window' or 'screen'. ###
-isValid = (options) ->
-  return options?.types? and Array.isArray options.types
-
-exports.getSources = (options, callback) ->
-  return callback new Error('Invalid options') unless isValid options
-
-  captureWindow = 'window' in options.types
-  captureScreen = 'screen' in options.types
-  options.thumbnailSize ?= width: 150, height: 150
-
-  id = getNextId()
-  ipcRenderer.send 'ATOM_BROWSER_DESKTOP_CAPTURER_GET_SOURCES', captureWindow, captureScreen, options.thumbnailSize, id
-  ipcRenderer.once "ATOM_RENDERER_DESKTOP_CAPTURER_RESULT_#{id}", (event, sources) ->
-    callback null, ({id: source.id, name: source.name, thumbnail: nativeImage.createFromDataURL source.thumbnail} for source in sources)

atom/renderer/api/lib/desktop-capturer.js

@@ -0,0 +1,50 @@
+var getNextId, ipcRenderer, isValid, nativeImage, nextId, ref,
+  indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; };
+
+ref = require('electron'), ipcRenderer = ref.ipcRenderer, nativeImage = ref.nativeImage;
+
+nextId = 0;
+
+getNextId = function() {
+  return ++nextId;
+};
+
+
+/* |options.type| can not be empty and has to include 'window' or 'screen'. */
+
+isValid = function(options) {
+  return ((options != null ? options.types : void 0) != null) && Array.isArray(options.types);
+};
+
+exports.getSources = function(options, callback) {
+  var captureScreen, captureWindow, id;
+  if (!isValid(options)) {
+    return callback(new Error('Invalid options'));
+  }
+  captureWindow = indexOf.call(options.types, 'window') >= 0;
+  captureScreen = indexOf.call(options.types, 'screen') >= 0;
+  if (options.thumbnailSize == null) {
+    options.thumbnailSize = {
+      width: 150,
+      height: 150
+    };
+  }
+  id = getNextId();
+  ipcRenderer.send('ATOM_BROWSER_DESKTOP_CAPTURER_GET_SOURCES', captureWindow, captureScreen, options.thumbnailSize, id);
+  return ipcRenderer.once("ATOM_RENDERER_DESKTOP_CAPTURER_RESULT_" + id, function(event, sources) {
+    var source;
+    return callback(null, (function() {
+      var i, len, results;
+      results = [];
+      for (i = 0, len = sources.length; i < len; i++) {
+        source = sources[i];
+        results.push({
+          id: source.id,
+          name: source.name,
+          thumbnail: nativeImage.createFromDataURL(source.thumbnail)
+        });
+      }
+      return results;
+    })());
+  });
+};

atom/renderer/api/lib/exports/electron.coffee

@@ -1,22 +0,0 @@
-common = require '../../../../common/api/lib/exports/electron'
-
-### Import common modules. ###
-common.defineProperties exports
-
-Object.defineProperties exports,
-  ### Renderer side modules, please sort with alphabet order. ###
-  desktopCapturer:
-    enumerable: true
-    get: -> require '../desktop-capturer'
-  ipcRenderer:
-    enumerable: true
-    get: -> require '../ipc-renderer'
-  remote:
-    enumerable: true
-    get: -> require '../remote'
-  screen:
-    enumerable: true
-    get: -> require '../screen'
-  webFrame:
-    enumerable: true
-    get: -> require '../web-frame'

atom/renderer/api/lib/exports/electron.js

@@ -0,0 +1,43 @@
+var common;
+
+common = require('../../../../common/api/lib/exports/electron');
+
+
+/* Import common modules. */
+
+common.defineProperties(exports);
+
+Object.defineProperties(exports, {
+
+  /* Renderer side modules, please sort with alphabet order. */
+  desktopCapturer: {
+    enumerable: true,
+    get: function() {
+      return require('../desktop-capturer');
+    }
+  },
+  ipcRenderer: {
+    enumerable: true,
+    get: function() {
+      return require('../ipc-renderer');
+    }
+  },
+  remote: {
+    enumerable: true,
+    get: function() {
+      return require('../remote');
+    }
+  },
+  screen: {
+    enumerable: true,
+    get: function() {
+      return require('../screen');
+    }
+  },
+  webFrame: {
+    enumerable: true,
+    get: function() {
+      return require('../web-frame');
+    }
+  }
+});

atom/renderer/api/lib/ipc-renderer.coffee

@@ -1,18 +0,0 @@
-{EventEmitter} = require 'events'
-
-binding = process.atomBinding 'ipc'
-v8Util  = process.atomBinding 'v8_util'
-
-### Created by init.coffee. ###
-ipcRenderer = v8Util.getHiddenValue global, 'ipc'
-
-ipcRenderer.send = (args...) ->
-  binding.send 'ipc-message', [args...]
-
-ipcRenderer.sendSync = (args...) ->
-  JSON.parse binding.sendSync('ipc-message-sync', [args...])
-
-ipcRenderer.sendToHost = (args...) ->
-  binding.send 'ipc-message-host', [args...]
-
-module.exports = ipcRenderer

atom/renderer/api/lib/ipc-renderer.js

@@ -0,0 +1,33 @@
+var EventEmitter, binding, ipcRenderer, v8Util,
+  slice = [].slice;
+
+EventEmitter = require('events').EventEmitter;
+
+binding = process.atomBinding('ipc');
+
+v8Util = process.atomBinding('v8_util');
+
+
+/* Created by init.coffee. */
+
+ipcRenderer = v8Util.getHiddenValue(global, 'ipc');
+
+ipcRenderer.send = function() {
+  var args;
+  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
+  return binding.send('ipc-message', slice.call(args));
+};
+
+ipcRenderer.sendSync = function() {
+  var args;
+  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
+  return JSON.parse(binding.sendSync('ipc-message-sync', slice.call(args)));
+};
+
+ipcRenderer.sendToHost = function() {
+  var args;
+  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
+  return binding.send('ipc-message-host', slice.call(args));
+};
+
+module.exports = ipcRenderer;

atom/renderer/api/lib/ipc.coffee

@@ -1,19 +0,0 @@
-{ipcRenderer, deprecate} = require 'electron'
-{EventEmitter} = require 'events'
-
-### This module is deprecated, we mirror everything from ipcRenderer. ###
-deprecate.warn 'ipc module', 'require("electron").ipcRenderer'
-
-### Routes events of ipcRenderer. ###
-ipc = new EventEmitter
-ipcRenderer.emit = (channel, event, args...) ->
-  ipc.emit channel, args...
-  EventEmitter::emit.apply ipcRenderer, arguments
-
-### Deprecated. ###
-for method of ipcRenderer when method.startsWith 'send'
-  ipc[method] = ipcRenderer[method]
-deprecate.rename ipc, 'sendChannel', 'send'
-deprecate.rename ipc, 'sendChannelSync', 'sendSync'
-
-module.exports = ipc

atom/renderer/api/lib/ipc.js

@@ -0,0 +1,38 @@
+var EventEmitter, deprecate, ipc, ipcRenderer, method, ref,
+  slice = [].slice;
+
+ref = require('electron'), ipcRenderer = ref.ipcRenderer, deprecate = ref.deprecate;
+
+EventEmitter = require('events').EventEmitter;
+
+
+/* This module is deprecated, we mirror everything from ipcRenderer. */
+
+deprecate.warn('ipc module', 'require("electron").ipcRenderer');
+
+
+/* Routes events of ipcRenderer. */
+
+ipc = new EventEmitter;
+
+ipcRenderer.emit = function() {
+  var args, channel, event;
+  channel = arguments[0], event = arguments[1], args = 3 <= arguments.length ? slice.call(arguments, 2) : [];
+  ipc.emit.apply(ipc, [channel].concat(slice.call(args)));
+  return EventEmitter.prototype.emit.apply(ipcRenderer, arguments);
+};
+
+
+/* Deprecated. */
+
+for (method in ipcRenderer) {
+  if (method.startsWith('send')) {
+    ipc[method] = ipcRenderer[method];
+  }
+}
+
+deprecate.rename(ipc, 'sendChannel', 'send');
+
+deprecate.rename(ipc, 'sendChannelSync', 'sendSync');
+
+module.exports = ipc;

atom/renderer/api/lib/remote.coffee

@@ -1,209 +0,0 @@
-{ipcRenderer, CallbacksRegistry} = require 'electron'
-v8Util = process.atomBinding 'v8_util'
-
-callbacksRegistry = new CallbacksRegistry
-
-### Check for circular reference. ###
-isCircular = (field, visited) ->
-  if typeof field is 'object'
-    if field in visited
-      return true
-    visited.push field
-  return false
-
-### Convert the arguments object into an array of meta data. ###
-wrapArgs = (args, visited=[]) ->
-  valueToMeta = (value) ->
-    if Array.isArray value
-      type: 'array', value: wrapArgs(value, visited)
-    else if Buffer.isBuffer value
-      type: 'buffer', value: Array::slice.call(value, 0)
-    else if value instanceof Date
-      type: 'date', value: value.getTime()
-    else if value?.constructor.name is 'Promise'
-      type: 'promise', then: valueToMeta(value.then.bind(value))
-    else if value? and typeof value is 'object' and v8Util.getHiddenValue value, 'atomId'
-      type: 'remote-object', id: v8Util.getHiddenValue value, 'atomId'
-    else if value? and typeof value is 'object'
-      ret = type: 'object', name: value.constructor.name, members: []
-      for prop, field of value
-        ret.members.push
-          name: prop
-          value: valueToMeta(if isCircular(field, visited) then null else field)
-      ret
-    else if typeof value is 'function' and v8Util.getHiddenValue value, 'returnValue'
-      type: 'function-with-return-value', value: valueToMeta(value())
-    else if typeof value is 'function'
-      type: 'function', id: callbacksRegistry.add(value), location: v8Util.getHiddenValue value, 'location'
-    else
-      type: 'value', value: value
-
-  Array::slice.call(args).map valueToMeta
-
-### Convert meta data from browser into real value. ###
-metaToValue = (meta) ->
-  switch meta.type
-    when 'value' then meta.value
-    when 'array' then (metaToValue(el) for el in meta.members)
-    when 'buffer' then new Buffer(meta.value)
-    when 'promise' then Promise.resolve(then: metaToValue(meta.then))
-    when 'error' then metaToPlainObject meta
-    when 'date' then new Date(meta.value)
-    when 'exception'
-      throw new Error("#{meta.message}\n#{meta.stack}")
-    else
-      if meta.type is 'function'
-        ### A shadow class to represent the remote function object. ###
-        ret =
-        class RemoteFunction
-          constructor: ->
-            if @constructor == RemoteFunction
-              ### Constructor call. ###
-              obj = ipcRenderer.sendSync 'ATOM_BROWSER_CONSTRUCTOR', meta.id, wrapArgs(arguments)
-
-              ###
-                Returning object in constructor will replace constructed object
-                with the returned object.
-                http://stackoverflow.com/questions/1978049/what-values-can-a-constructor-return-to-avoid-returning-this
-              ###
-              return metaToValue obj
-            else
-              ### Function call. ###
-              obj = ipcRenderer.sendSync 'ATOM_BROWSER_FUNCTION_CALL', meta.id, wrapArgs(arguments)
-              return metaToValue obj
-      else
-        ret = v8Util.createObjectWithName meta.name
-
-      ### Polulate delegate members. ###
-      for member in meta.members
-        if member.type is 'function'
-          ret[member.name] = createRemoteMemberFunction meta.id, member.name
-        else
-          Object.defineProperty ret, member.name, createRemoteMemberProperty(meta.id, member.name)
-
-      ###
-        Track delegate object's life time, and tell the browser to clean up
-        when the object is GCed.
-      ###
-      v8Util.setDestructor ret, ->
-        ipcRenderer.send 'ATOM_BROWSER_DEREFERENCE', meta.id
-
-      ### Remember object's id. ###
-      v8Util.setHiddenValue ret, 'atomId', meta.id
-
-      ret
-
-### Construct a plain object from the meta. ###
-metaToPlainObject = (meta) ->
-  obj = switch meta.type
-    when 'error' then new Error
-    else {}
-  obj[name] = value for {name, value} in meta.members
-  obj
-
-###
-  Create a RemoteMemberFunction instance.
-  This function's content should not be inlined into metaToValue, otherwise V8
-  may consider it circular reference.
-###
-createRemoteMemberFunction = (metaId, name) ->
-  class RemoteMemberFunction
-    constructor: ->
-      if @constructor is RemoteMemberFunction
-        ### Constructor call. ###
-        ret = ipcRenderer.sendSync 'ATOM_BROWSER_MEMBER_CONSTRUCTOR', metaId, name, wrapArgs(arguments)
-        return metaToValue ret
-      else
-        ### Call member function. ###
-        ret = ipcRenderer.sendSync 'ATOM_BROWSER_MEMBER_CALL', metaId, name, wrapArgs(arguments)
-        return metaToValue ret
-
-###
-  Create configuration for defineProperty.
-  This function's content should not be inlined into metaToValue, otherwise V8
-  may consider it circular reference.
-###
-createRemoteMemberProperty = (metaId, name) ->
-  enumerable: true,
-  configurable: false,
-  set: (value) ->
-    ### Set member data. ###
-    ipcRenderer.sendSync 'ATOM_BROWSER_MEMBER_SET', metaId, name, value
-    value
-  get: ->
-    ### Get member data. ###
-    metaToValue ipcRenderer.sendSync('ATOM_BROWSER_MEMBER_GET', metaId, name)
-
-### Browser calls a callback in renderer. ###
-ipcRenderer.on 'ATOM_RENDERER_CALLBACK', (event, id, args) ->
-  callbacksRegistry.apply id, metaToValue(args)
-
-### A callback in browser is released. ###
-ipcRenderer.on 'ATOM_RENDERER_RELEASE_CALLBACK', (event, id) ->
-  callbacksRegistry.remove id
-
-### List all built-in modules in browser process. ###
-browserModules = require '../../../browser/api/lib/exports/electron'
-### And add a helper receiver for each one. ###
-for name of browserModules
-  do (name) ->
-    Object.defineProperty exports, name, get: -> exports.getBuiltin name
-
-###
-  Get remote module.
-  (Just like node's require, the modules are cached permanently, note that this
-  is safe leak since the object is not expected to get freed in browser)
-###
-moduleCache = {}
-exports.require = (module) ->
-  return moduleCache[module] if moduleCache[module]?
-
-  meta = ipcRenderer.sendSync 'ATOM_BROWSER_REQUIRE', module
-  moduleCache[module] = metaToValue meta
-
-### Optimize require('electron'). ###
-moduleCache.electron = exports
-
-### Alias to remote.require('electron').xxx. ###
-builtinCache = {}
-exports.getBuiltin = (module) ->
-  return builtinCache[module] if builtinCache[module]?
-
-  meta = ipcRenderer.sendSync 'ATOM_BROWSER_GET_BUILTIN', module
-  builtinCache[module] = metaToValue meta
-
-### Get current BrowserWindow object. ###
-windowCache = null
-exports.getCurrentWindow = ->
-  return windowCache if windowCache?
-  meta = ipcRenderer.sendSync 'ATOM_BROWSER_CURRENT_WINDOW'
-  windowCache = metaToValue meta
-
-### Get current WebContents object. ###
-webContentsCache = null
-exports.getCurrentWebContents = ->
-  return webContentsCache if webContentsCache?
-  meta = ipcRenderer.sendSync 'ATOM_BROWSER_CURRENT_WEB_CONTENTS'
-  webContentsCache = metaToValue meta
-
-### Get a global object in browser. ###
-exports.getGlobal = (name) ->
-  meta = ipcRenderer.sendSync 'ATOM_BROWSER_GLOBAL', name
-  metaToValue meta
-
-### Get the process object in browser. ###
-processCache = null
-exports.__defineGetter__ 'process', ->
-  processCache = exports.getGlobal('process') unless processCache?
-  processCache
-
-### Create a funtion that will return the specifed value when called in browser. ###
-exports.createFunctionWithReturnValue = (returnValue) ->
-  func = -> returnValue
-  v8Util.setHiddenValue func, 'returnValue', true
-  func
-
-### Get the guest WebContents from guestInstanceId. ###
-exports.getGuestWebContents = (guestInstanceId) ->
-  meta = ipcRenderer.sendSync 'ATOM_BROWSER_GUEST_WEB_CONTENTS', guestInstanceId
-  metaToValue meta

atom/renderer/api/lib/remote.js

@@ -0,0 +1,394 @@
+var CallbacksRegistry, browserModules, builtinCache, callbacksRegistry, createRemoteMemberFunction, createRemoteMemberProperty, fn, ipcRenderer, isCircular, metaToPlainObject, metaToValue, moduleCache, name, processCache, ref, v8Util, webContentsCache, windowCache, wrapArgs,
+  indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; };
+
+ref = require('electron'), ipcRenderer = ref.ipcRenderer, CallbacksRegistry = ref.CallbacksRegistry;
+
+v8Util = process.atomBinding('v8_util');
+
+callbacksRegistry = new CallbacksRegistry;
+
+
+/* Check for circular reference. */
+
+isCircular = function(field, visited) {
+  if (typeof field === 'object') {
+    if (indexOf.call(visited, field) >= 0) {
+      return true;
+    }
+    visited.push(field);
+  }
+  return false;
+};
+
+
+/* Convert the arguments object into an array of meta data. */
+
+wrapArgs = function(args, visited) {
+  var valueToMeta;
+  if (visited == null) {
+    visited = [];
+  }
+  valueToMeta = function(value) {
+    var field, prop, ret;
+    if (Array.isArray(value)) {
+      return {
+        type: 'array',
+        value: wrapArgs(value, visited)
+      };
+    } else if (Buffer.isBuffer(value)) {
+      return {
+        type: 'buffer',
+        value: Array.prototype.slice.call(value, 0)
+      };
+    } else if (value instanceof Date) {
+      return {
+        type: 'date',
+        value: value.getTime()
+      };
+    } else if ((value != null ? value.constructor.name : void 0) === 'Promise') {
+      return {
+        type: 'promise',
+        then: valueToMeta(value.then.bind(value))
+      };
+    } else if ((value != null) && typeof value === 'object' && v8Util.getHiddenValue(value, 'atomId')) {
+      return {
+        type: 'remote-object',
+        id: v8Util.getHiddenValue(value, 'atomId')
+      };
+    } else if ((value != null) && typeof value === 'object') {
+      ret = {
+        type: 'object',
+        name: value.constructor.name,
+        members: []
+      };
+      for (prop in value) {
+        field = value[prop];
+        ret.members.push({
+          name: prop,
+          value: valueToMeta(isCircular(field, visited) ? null : field)
+        });
+      }
+      return ret;
+    } else if (typeof value === 'function' && v8Util.getHiddenValue(value, 'returnValue')) {
+      return {
+        type: 'function-with-return-value',
+        value: valueToMeta(value())
+      };
+    } else if (typeof value === 'function') {
+      return {
+        type: 'function',
+        id: callbacksRegistry.add(value),
+        location: v8Util.getHiddenValue(value, 'location')
+      };
+    } else {
+      return {
+        type: 'value',
+        value: value
+      };
+    }
+  };
+  return Array.prototype.slice.call(args).map(valueToMeta);
+};
+
+
+/* Convert meta data from browser into real value. */
+
+metaToValue = function(meta) {
+  var RemoteFunction, el, i, j, len, len1, member, ref1, ref2, results, ret;
+  switch (meta.type) {
+    case 'value':
+      return meta.value;
+    case 'array':
+      ref1 = meta.members;
+      results = [];
+      for (i = 0, len = ref1.length; i < len; i++) {
+        el = ref1[i];
+        results.push(metaToValue(el));
+      }
+      return results;
+    case 'buffer':
+      return new Buffer(meta.value);
+    case 'promise':
+      return Promise.resolve({
+        then: metaToValue(meta.then)
+      });
+    case 'error':
+      return metaToPlainObject(meta);
+    case 'date':
+      return new Date(meta.value);
+    case 'exception':
+      throw new Error(meta.message + "\n" + meta.stack);
+      break;
+    default:
+      if (meta.type === 'function') {
+
+        /* A shadow class to represent the remote function object. */
+        ret = RemoteFunction = (function() {
+          function RemoteFunction() {
+            var obj;
+            if (this.constructor === RemoteFunction) {
+
+              /* Constructor call. */
+              obj = ipcRenderer.sendSync('ATOM_BROWSER_CONSTRUCTOR', meta.id, wrapArgs(arguments));
+
+              /*
+                Returning object in constructor will replace constructed object
+                with the returned object.
+                http://stackoverflow.com/questions/1978049/what-values-can-a-constructor-return-to-avoid-returning-this
+               */
+              return metaToValue(obj);
+            } else {
+
+              /* Function call. */
+              obj = ipcRenderer.sendSync('ATOM_BROWSER_FUNCTION_CALL', meta.id, wrapArgs(arguments));
+              return metaToValue(obj);
+            }
+          }
+
+          return RemoteFunction;
+
+        })();
+      } else {
+        ret = v8Util.createObjectWithName(meta.name);
+      }
+
+      /* Polulate delegate members. */
+      ref2 = meta.members;
+      for (j = 0, len1 = ref2.length; j < len1; j++) {
+        member = ref2[j];
+        if (member.type === 'function') {
+          ret[member.name] = createRemoteMemberFunction(meta.id, member.name);
+        } else {
+          Object.defineProperty(ret, member.name, createRemoteMemberProperty(meta.id, member.name));
+        }
+      }
+
+      /*
+        Track delegate object's life time, and tell the browser to clean up
+        when the object is GCed.
+       */
+      v8Util.setDestructor(ret, function() {
+        return ipcRenderer.send('ATOM_BROWSER_DEREFERENCE', meta.id);
+      });
+
+      /* Remember object's id. */
+      v8Util.setHiddenValue(ret, 'atomId', meta.id);
+      return ret;
+  }
+};
+
+
+/* Construct a plain object from the meta. */
+
+metaToPlainObject = function(meta) {
+  var i, len, name, obj, ref1, ref2, value;
+  obj = (function() {
+    switch (meta.type) {
+      case 'error':
+        return new Error;
+      default:
+        return {};
+    }
+  })();
+  ref1 = meta.members;
+  for (i = 0, len = ref1.length; i < len; i++) {
+    ref2 = ref1[i], name = ref2.name, value = ref2.value;
+    obj[name] = value;
+  }
+  return obj;
+};
+
+
+/*
+  Create a RemoteMemberFunction instance.
+  This function's content should not be inlined into metaToValue, otherwise V8
+  may consider it circular reference.
+ */
+
+createRemoteMemberFunction = function(metaId, name) {
+  var RemoteMemberFunction;
+  return RemoteMemberFunction = (function() {
+    function RemoteMemberFunction() {
+      var ret;
+      if (this.constructor === RemoteMemberFunction) {
+
+        /* Constructor call. */
+        ret = ipcRenderer.sendSync('ATOM_BROWSER_MEMBER_CONSTRUCTOR', metaId, name, wrapArgs(arguments));
+        return metaToValue(ret);
+      } else {
+
+        /* Call member function. */
+        ret = ipcRenderer.sendSync('ATOM_BROWSER_MEMBER_CALL', metaId, name, wrapArgs(arguments));
+        return metaToValue(ret);
+      }
+    }
+
+    return RemoteMemberFunction;
+
+  })();
+};
+
+
+/*
+  Create configuration for defineProperty.
+  This function's content should not be inlined into metaToValue, otherwise V8
+  may consider it circular reference.
+ */
+
+createRemoteMemberProperty = function(metaId, name) {
+  return {
+    enumerable: true,
+    configurable: false,
+    set: function(value) {
+
+      /* Set member data. */
+      ipcRenderer.sendSync('ATOM_BROWSER_MEMBER_SET', metaId, name, value);
+      return value;
+    },
+    get: function() {
+
+      /* Get member data. */
+      return metaToValue(ipcRenderer.sendSync('ATOM_BROWSER_MEMBER_GET', metaId, name));
+    }
+  };
+};
+
+
+/* Browser calls a callback in renderer. */
+
+ipcRenderer.on('ATOM_RENDERER_CALLBACK', function(event, id, args) {
+  return callbacksRegistry.apply(id, metaToValue(args));
+});
+
+
+/* A callback in browser is released. */
+
+ipcRenderer.on('ATOM_RENDERER_RELEASE_CALLBACK', function(event, id) {
+  return callbacksRegistry.remove(id);
+});
+
+
+/* List all built-in modules in browser process. */
+
+browserModules = require('../../../browser/api/lib/exports/electron');
+
+
+/* And add a helper receiver for each one. */
+
+fn = function(name) {
+  return Object.defineProperty(exports, name, {
+    get: function() {
+      return exports.getBuiltin(name);
+    }
+  });
+};
+for (name in browserModules) {
+  fn(name);
+}
+
+
+/*
+  Get remote module.
+  (Just like node's require, the modules are cached permanently, note that this
+  is safe leak since the object is not expected to get freed in browser)
+ */
+
+moduleCache = {};
+
+exports.require = function(module) {
+  var meta;
+  if (moduleCache[module] != null) {
+    return moduleCache[module];
+  }
+  meta = ipcRenderer.sendSync('ATOM_BROWSER_REQUIRE', module);
+  return moduleCache[module] = metaToValue(meta);
+};
+
+
+/* Optimize require('electron'). */
+
+moduleCache.electron = exports;
+
+
+/* Alias to remote.require('electron').xxx. */
+
+builtinCache = {};
+
+exports.getBuiltin = function(module) {
+  var meta;
+  if (builtinCache[module] != null) {
+    return builtinCache[module];
+  }
+  meta = ipcRenderer.sendSync('ATOM_BROWSER_GET_BUILTIN', module);
+  return builtinCache[module] = metaToValue(meta);
+};
+
+
+/* Get current BrowserWindow object. */
+
+windowCache = null;
+
+exports.getCurrentWindow = function() {
+  var meta;
+  if (windowCache != null) {
+    return windowCache;
+  }
+  meta = ipcRenderer.sendSync('ATOM_BROWSER_CURRENT_WINDOW');
+  return windowCache = metaToValue(meta);
+};
+
+
+/* Get current WebContents object. */
+
+webContentsCache = null;
+
+exports.getCurrentWebContents = function() {
+  var meta;
+  if (webContentsCache != null) {
+    return webContentsCache;
+  }
+  meta = ipcRenderer.sendSync('ATOM_BROWSER_CURRENT_WEB_CONTENTS');
+  return webContentsCache = metaToValue(meta);
+};
+
+
+/* Get a global object in browser. */
+
+exports.getGlobal = function(name) {
+  var meta;
+  meta = ipcRenderer.sendSync('ATOM_BROWSER_GLOBAL', name);
+  return metaToValue(meta);
+};
+
+
+/* Get the process object in browser. */
+
+processCache = null;
+
+exports.__defineGetter__('process', function() {
+  if (processCache == null) {
+    processCache = exports.getGlobal('process');
+  }
+  return processCache;
+});
+
+
+/* Create a funtion that will return the specifed value when called in browser. */
+
+exports.createFunctionWithReturnValue = function(returnValue) {
+  var func;
+  func = function() {
+    return returnValue;
+  };
+  v8Util.setHiddenValue(func, 'returnValue', true);
+  return func;
+};
+
+
+/* Get the guest WebContents from guestInstanceId. */
+
+exports.getGuestWebContents = function(guestInstanceId) {
+  var meta;
+  meta = ipcRenderer.sendSync('ATOM_BROWSER_GUEST_WEB_CONTENTS', guestInstanceId);
+  return metaToValue(meta);
+};

atom/renderer/api/lib/screen.coffee

@@ -1 +0,0 @@
-module.exports = require('electron').remote.screen

atom/renderer/api/lib/screen.js

@@ -0,0 +1 @@
+module.exports = require('electron').remote.screen;

atom/renderer/api/lib/web-frame.coffee

@@ -1,9 +0,0 @@
-{deprecate} = require 'electron'
-{webFrame} = process.atomBinding 'web_frame'
-
-### Deprecated. ###
-deprecate.rename webFrame, 'registerUrlSchemeAsSecure', 'registerURLSchemeAsSecure'
-deprecate.rename webFrame, 'registerUrlSchemeAsBypassingCSP', 'registerURLSchemeAsBypassingCSP'
-deprecate.rename webFrame, 'registerUrlSchemeAsPrivileged', 'registerURLSchemeAsPrivileged'
-
-module.exports = webFrame

atom/renderer/api/lib/web-frame.js

@@ -0,0 +1,16 @@
+var deprecate, webFrame;
+
+deprecate = require('electron').deprecate;
+
+webFrame = process.atomBinding('web_frame').webFrame;
+
+
+/* Deprecated. */
+
+deprecate.rename(webFrame, 'registerUrlSchemeAsSecure', 'registerURLSchemeAsSecure');
+
+deprecate.rename(webFrame, 'registerUrlSchemeAsBypassingCSP', 'registerURLSchemeAsBypassingCSP');
+
+deprecate.rename(webFrame, 'registerUrlSchemeAsPrivileged', 'registerURLSchemeAsPrivileged');
+
+module.exports = webFrame;