Move JavaScript to root lib/ folder

lib/renderer/api/desktop-capturer.js

@@ -0,0 +1,47 @@
+const ipcRenderer = require('electron').ipcRenderer;
+const nativeImage = require('electron').nativeImage;
+
+var nextId = 0;
+var includes = [].includes;
+
+var getNextId = function() {
+  return ++nextId;
+};
+
+// |options.type| can not be empty and has to include 'window' or 'screen'.
+var 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 = includes.call(options.types, 'window');
+  captureScreen = includes.call(options.types, 'screen');
+  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;
+    })());
+  });
+};

lib/renderer/api/exports/electron.js

@@ -0,0 +1,38 @@
+const 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');
+    }
+  }
+});

lib/renderer/api/ipc-renderer.js

@@ -0,0 +1,27 @@
+const binding = process.atomBinding('ipc');
+const v8Util = process.atomBinding('v8_util');
+
+var slice = [].slice;
+
+// Created by init.coffee.
+const 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;

lib/renderer/api/ipc.js

@@ -0,0 +1,31 @@
+const ipcRenderer = require('electron').ipcRenderer;
+const deprecate = require('electron').deprecate;
+const EventEmitter = require('events').EventEmitter;
+
+var slice = [].slice;
+
+// This module is deprecated, we mirror everything from ipcRenderer.
+deprecate.warn('ipc module', 'require("electron").ipcRenderer');
+
+// Routes events of ipcRenderer.
+var ipc = new EventEmitter;
+
+ipcRenderer.emit = function() {
+  var channel = arguments[0];
+  var 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 (var method in ipcRenderer) {
+  if (method.startsWith('send')) {
+    ipc[method] = ipcRenderer[method];
+  }
+}
+
+deprecate.rename(ipc, 'sendChannel', 'send');
+
+deprecate.rename(ipc, 'sendChannelSync', 'sendSync');
+
+module.exports = ipc;

lib/renderer/api/remote.js

@@ -0,0 +1,306 @@
+'use strict';
+
+const ipcRenderer = require('electron').ipcRenderer;
+const CallbacksRegistry = require('electron').CallbacksRegistry;
+const v8Util = process.atomBinding('v8_util');
+const IDWeakMap = process.atomBinding('id_weak_map').IDWeakMap;
+
+const callbacksRegistry = new CallbacksRegistry;
+
+var includes = [].includes;
+
+var remoteObjectCache = new IDWeakMap;
+
+// Check for circular reference.
+var isCircular = function(field, visited) {
+  if (typeof field === 'object') {
+    if (includes.call(visited, field)) {
+      return true;
+    }
+    visited.push(field);
+  }
+  return false;
+};
+
+// Convert the arguments object into an array of meta data.
+var 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);
+};
+
+// Populate object's members from descriptors.
+// This matches |getObjectMemebers| in rpc-server.
+let setObjectMembers = function(object, metaId, members) {
+  for (let member of members) {
+    if (object.hasOwnProperty(member.name))
+      continue;
+
+    let descriptor = { enumerable: member.enumerable };
+    if (member.type === 'method') {
+      let remoteMemberFunction = function() {
+        if (this && this.constructor === remoteMemberFunction) {
+          // Constructor call.
+          let ret = ipcRenderer.sendSync('ATOM_BROWSER_MEMBER_CONSTRUCTOR', metaId, member.name, wrapArgs(arguments));
+          return metaToValue(ret);
+        } else {
+          // Call member function.
+          let ret = ipcRenderer.sendSync('ATOM_BROWSER_MEMBER_CALL', metaId, member.name, wrapArgs(arguments));
+          return metaToValue(ret);
+        }
+      };
+      descriptor.writable = true;
+      descriptor.configurable = true;
+      descriptor.value = remoteMemberFunction;
+    } else if (member.type === 'get') {
+      descriptor.get = function() {
+        return metaToValue(ipcRenderer.sendSync('ATOM_BROWSER_MEMBER_GET', metaId, member.name));
+      };
+
+      // Only set setter when it is writable.
+      if (member.writable) {
+        descriptor.set = function(value) {
+          ipcRenderer.sendSync('ATOM_BROWSER_MEMBER_SET', metaId, member.name, value);
+          return value;
+        };
+      }
+    }
+
+    Object.defineProperty(object, member.name, descriptor);
+  }
+};
+
+// Populate object's prototype from descriptor.
+// This matches |getObjectPrototype| in rpc-server.
+let setObjectPrototype = function(object, metaId, descriptor) {
+  if (descriptor === null)
+    return;
+  let proto = {};
+  setObjectMembers(proto, metaId, descriptor.members);
+  setObjectPrototype(proto, metaId, descriptor.proto);
+  Object.setPrototypeOf(object, proto);
+};
+
+// Convert meta data from browser into real value.
+let metaToValue = function(meta) {
+  var el, i, len, ref1, 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);
+    default:
+      if (remoteObjectCache.has(meta.id))
+        return remoteObjectCache.get(meta.id);
+
+      if (meta.type === 'function') {
+        // A shadow class to represent the remote function object.
+        let remoteFunction = function() {
+          if (this && this.constructor === remoteFunction) {
+            // Constructor call.
+            let 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.
+            let obj = ipcRenderer.sendSync('ATOM_BROWSER_FUNCTION_CALL', meta.id, wrapArgs(arguments));
+            return metaToValue(obj);
+          }
+        };
+        ret = remoteFunction;
+      } else {
+        ret = {};
+      }
+
+      // Populate delegate members.
+      setObjectMembers(ret, meta.id, meta.members);
+      // Populate delegate prototype.
+      setObjectPrototype(ret, meta.id, meta.proto);
+
+      // Set constructor.name to object's name.
+      Object.defineProperty(ret.constructor, 'name', { value: meta.name });
+
+      // Track delegate object's life time, and tell the browser to clean up
+      // when the object is GCed.
+      v8Util.setDestructor(ret, function() {
+        ipcRenderer.send('ATOM_BROWSER_DEREFERENCE', meta.id);
+      });
+
+      // Remember object's id.
+      v8Util.setHiddenValue(ret, 'atomId', meta.id);
+      remoteObjectCache.set(meta.id, ret);
+      return ret;
+  }
+};
+
+// Construct a plain object from the meta.
+var 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;
+};
+
+// 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.
+const browserModules = require('../../../browser/api/lib/exports/electron');
+
+// And add a helper receiver for each one.
+var fn = function(name) {
+  return Object.defineProperty(exports, name, {
+    get: function() {
+      return exports.getBuiltin(name);
+    }
+  });
+};
+for (var name in browserModules) {
+  fn(name);
+}
+
+// Get remote module.
+exports.require = function(module) {
+  return metaToValue(ipcRenderer.sendSync('ATOM_BROWSER_REQUIRE', module));
+};
+
+// Alias to remote.require('electron').xxx.
+exports.getBuiltin = function(module) {
+  return metaToValue(ipcRenderer.sendSync('ATOM_BROWSER_GET_BUILTIN', module));
+};
+
+// Get current BrowserWindow.
+exports.getCurrentWindow = function() {
+  return metaToValue(ipcRenderer.sendSync('ATOM_BROWSER_CURRENT_WINDOW'));
+};
+
+// Get current WebContents object.
+exports.getCurrentWebContents = function() {
+  return metaToValue(ipcRenderer.sendSync('ATOM_BROWSER_CURRENT_WEB_CONTENTS'));
+};
+
+// Get a global object in browser.
+exports.getGlobal = function(name) {
+  return metaToValue(ipcRenderer.sendSync('ATOM_BROWSER_GLOBAL', name));
+};
+
+// Get the process object in browser.
+exports.__defineGetter__('process', function() {
+  return exports.getGlobal('process');
+});
+
+// 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);
+};

lib/renderer/api/screen.js

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

lib/renderer/api/web-frame.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const deprecate = require('electron').deprecate;
+const EventEmitter = require('events').EventEmitter;
+
+const webFrame = process.atomBinding('web_frame').webFrame;
+
+// webFrame is an EventEmitter.
+webFrame.__proto__ = EventEmitter.prototype;
+
+// Lots of webview would subscribe to webFrame's events.
+webFrame.setMaxListeners(0);
+
+// Deprecated.
+deprecate.rename(webFrame, 'registerUrlSchemeAsSecure', 'registerURLSchemeAsSecure');
+deprecate.rename(webFrame, 'registerUrlSchemeAsBypassingCSP', 'registerURLSchemeAsBypassingCSP');
+deprecate.rename(webFrame, 'registerUrlSchemeAsPrivileged', 'registerURLSchemeAsPrivileged');
+
+module.exports = webFrame;

lib/renderer/chrome-api.js

@@ -0,0 +1,13 @@
+const url = require('url');
+const chrome = window.chrome = window.chrome || {};
+
+chrome.extension = {
+  getURL: function(path) {
+    return url.format({
+      protocol: location.protocol,
+      slashes: true,
+      hostname: location.hostname,
+      pathname: path
+    });
+  }
+};

lib/renderer/init.js

@@ -0,0 +1,139 @@
+'use strict';
+
+const events = require('events');
+const path = require('path');
+const Module = require('module');
+
+// We modified the original process.argv to let node.js load the
+// atom-renderer.js, we need to restore it here.
+process.argv.splice(1, 1);
+
+// Clear search paths.
+require(path.resolve(__dirname, '..', '..', 'common', 'lib', 'reset-search-paths'));
+
+// Import common settings.
+require(path.resolve(__dirname, '..', '..', 'common', 'lib', 'init'));
+
+var globalPaths = Module.globalPaths;
+
+if (!process.env.ELECTRON_HIDE_INTERNAL_MODULES) {
+  globalPaths.push(path.resolve(__dirname, '..', 'api', 'lib'));
+}
+
+// Expose public APIs.
+globalPaths.push(path.resolve(__dirname, '..', 'api', 'lib', 'exports'));
+
+// The global variable will be used by ipc for event dispatching
+var v8Util = process.atomBinding('v8_util');
+
+v8Util.setHiddenValue(global, 'ipc', new events.EventEmitter);
+
+// Use electron module after everything is ready.
+const electron = require('electron');
+
+// Call webFrame method.
+electron.ipcRenderer.on('ELECTRON_INTERNAL_RENDERER_WEB_FRAME_METHOD', (event, method, args) => {
+  electron.webFrame[method].apply(electron.webFrame, args);
+});
+
+electron.ipcRenderer.on('ELECTRON_INTERNAL_RENDERER_ASYNC_WEB_FRAME_METHOD', (event, requestId, method, args) => {
+  const responseCallback = function(result) {
+    event.sender.send(`ELECTRON_INTERNAL_BROWSER_ASYNC_WEB_FRAME_RESPONSE_${requestId}`, result);
+  };
+  args.push(responseCallback);
+  electron.webFrame[method].apply(electron.webFrame, args);
+});
+
+// Process command line arguments.
+var nodeIntegration = 'false';
+var preloadScript = null;
+
+var ref = process.argv;
+var i, len, arg;
+for (i = 0, len = ref.length; i < len; i++) {
+  arg = ref[i];
+  if (arg.indexOf('--guest-instance-id=') === 0) {
+    // This is a guest web view.
+    process.guestInstanceId = parseInt(arg.substr(arg.indexOf('=') + 1));
+  } else if (arg.indexOf('--opener-id=') === 0) {
+    // This is a guest BrowserWindow.
+    process.openerId = parseInt(arg.substr(arg.indexOf('=') + 1));
+  } else if (arg.indexOf('--node-integration=') === 0) {
+    nodeIntegration = arg.substr(arg.indexOf('=') + 1);
+  } else if (arg.indexOf('--preload=') === 0) {
+    preloadScript = arg.substr(arg.indexOf('=') + 1);
+  }
+}
+
+if (location.protocol === 'chrome-devtools:') {
+  // Override some inspector APIs.
+  require('./inspector');
+  nodeIntegration = 'true';
+} else if (location.protocol === 'chrome-extension:') {
+  // Add implementations of chrome API.
+  require('./chrome-api');
+  nodeIntegration = 'true';
+} else {
+  // Override default web functions.
+  require('./override');
+
+  // Load webview tag implementation.
+  if (process.guestInstanceId == null) {
+    require('./web-view/web-view');
+    require('./web-view/web-view-attributes');
+  }
+}
+
+if (nodeIntegration === 'true' || nodeIntegration === 'all' || nodeIntegration === 'except-iframe' || nodeIntegration === 'manual-enable-iframe') {
+  // Export node bindings to global.
+  global.require = require;
+  global.module = module;
+
+  // Set the __filename to the path of html file if it is file: protocol.
+  if (window.location.protocol === 'file:') {
+    var pathname = process.platform === 'win32' && window.location.pathname[0] === '/' ? window.location.pathname.substr(1) : window.location.pathname;
+    global.__filename = path.normalize(decodeURIComponent(pathname));
+    global.__dirname = path.dirname(global.__filename);
+
+    // Set module's filename so relative require can work as expected.
+    module.filename = global.__filename;
+
+    // Also search for module under the html file.
+    module.paths = module.paths.concat(Module._nodeModulePaths(global.__dirname));
+  } else {
+    global.__filename = __filename;
+    global.__dirname = __dirname;
+  }
+
+  // Redirect window.onerror to uncaughtException.
+  window.onerror = function(message, filename, lineno, colno, error) {
+    if (global.process.listeners('uncaughtException').length > 0) {
+      global.process.emit('uncaughtException', error);
+      return true;
+    } else {
+      return false;
+    }
+  };
+} else {
+  // Delete Node's symbols after the Environment has been loaded.
+  process.once('loaded', function() {
+    delete global.process;
+    delete global.setImmediate;
+    delete global.clearImmediate;
+    return delete global.global;
+  });
+}
+
+// Load the script specfied by the "preload" attribute.
+if (preloadScript) {
+  try {
+    require(preloadScript);
+  } catch (error) {
+    if (error.code === 'MODULE_NOT_FOUND') {
+      console.error("Unable to load preload script " + preloadScript);
+    } else {
+      console.error(error);
+      console.error(error.stack);
+    }
+  }
+}

lib/renderer/inspector.js

@@ -0,0 +1,81 @@
+window.onload = function() {
+  // Use menu API to show context menu.
+  InspectorFrontendHost.showContextMenuAtPoint = createMenu;
+
+  // Use dialog API to override file chooser dialog.
+  return WebInspector.createFileSelectorElement = createFileSelectorElement;
+};
+
+var convertToMenuTemplate = function(items) {
+  var fn, i, item, len, template;
+  template = [];
+  fn = function(item) {
+    var transformed;
+    transformed = item.type === 'subMenu' ? {
+      type: 'submenu',
+      label: item.label,
+      enabled: item.enabled,
+      submenu: convertToMenuTemplate(item.subItems)
+    } : item.type === 'separator' ? {
+      type: 'separator'
+    } : item.type === 'checkbox' ? {
+      type: 'checkbox',
+      label: item.label,
+      enabled: item.enabled,
+      checked: item.checked
+    } : {
+      type: 'normal',
+      label: item.label,
+      enabled: item.enabled
+    };
+    if (item.id != null) {
+      transformed.click = function() {
+        DevToolsAPI.contextMenuItemSelected(item.id);
+        return DevToolsAPI.contextMenuCleared();
+      };
+    }
+    return template.push(transformed);
+  };
+  for (i = 0, len = items.length; i < len; i++) {
+    item = items[i];
+    fn(item);
+  }
+  return template;
+};
+
+var createMenu = function(x, y, items) {
+  const remote = require('electron').remote;
+  const Menu = remote.Menu;
+  const menu = Menu.buildFromTemplate(convertToMenuTemplate(items));
+
+  // The menu is expected to show asynchronously.
+  return setTimeout(function() {
+    return menu.popup(remote.getCurrentWindow());
+  });
+};
+
+var showFileChooserDialog = function(callback) {
+  var dialog, files, remote;
+  remote = require('electron').remote;
+  dialog = remote.dialog;
+  files = dialog.showOpenDialog({});
+  if (files != null) {
+    return callback(pathToHtml5FileObject(files[0]));
+  }
+};
+
+var pathToHtml5FileObject = function(path) {
+  var blob, fs;
+  fs = require('fs');
+  blob = new Blob([fs.readFileSync(path)]);
+  blob.name = path;
+  return blob;
+};
+
+var createFileSelectorElement = function(callback) {
+  var fileSelectorElement;
+  fileSelectorElement = document.createElement('span');
+  fileSelectorElement.style.display = 'none';
+  fileSelectorElement.click = showFileChooserDialog.bind(this, callback);
+  return fileSelectorElement;
+};

lib/renderer/override.js

@@ -0,0 +1,230 @@
+const ipcRenderer = require('electron').ipcRenderer;
+const remote = require('electron').remote;
+
+var slice = [].slice;
+
+// Helper function to resolve relative url.
+var a = window.top.document.createElement('a');
+
+var resolveURL = function(url) {
+  a.href = url;
+  return a.href;
+};
+
+// Window object returned by "window.open".
+var BrowserWindowProxy = (function() {
+  BrowserWindowProxy.proxies = {};
+
+  BrowserWindowProxy.getOrCreate = function(guestId) {
+    var base;
+    return (base = this.proxies)[guestId] != null ? base[guestId] : base[guestId] = new BrowserWindowProxy(guestId);
+  };
+
+  BrowserWindowProxy.remove = function(guestId) {
+    return delete this.proxies[guestId];
+  };
+
+  function BrowserWindowProxy(guestId1) {
+    this.guestId = guestId1;
+    this.closed = false;
+    ipcRenderer.once("ATOM_SHELL_GUEST_WINDOW_MANAGER_WINDOW_CLOSED_" + this.guestId, (function(_this) {
+      return function() {
+        BrowserWindowProxy.remove(_this.guestId);
+        return _this.closed = true;
+      };
+    })(this));
+  }
+
+  BrowserWindowProxy.prototype.close = function() {
+    return ipcRenderer.send('ATOM_SHELL_GUEST_WINDOW_MANAGER_WINDOW_CLOSE', this.guestId);
+  };
+
+  BrowserWindowProxy.prototype.focus = function() {
+    return ipcRenderer.send('ATOM_SHELL_GUEST_WINDOW_MANAGER_WINDOW_METHOD', this.guestId, 'focus');
+  };
+
+  BrowserWindowProxy.prototype.blur = function() {
+    return ipcRenderer.send('ATOM_SHELL_GUEST_WINDOW_MANAGER_WINDOW_METHOD', this.guestId, 'blur');
+  };
+
+  BrowserWindowProxy.prototype.postMessage = function(message, targetOrigin) {
+    if (targetOrigin == null) {
+      targetOrigin = '*';
+    }
+    return ipcRenderer.send('ATOM_SHELL_GUEST_WINDOW_MANAGER_WINDOW_POSTMESSAGE', this.guestId, message, targetOrigin, location.origin);
+  };
+
+  BrowserWindowProxy.prototype["eval"] = function() {
+    var args;
+    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
+    return ipcRenderer.send.apply(ipcRenderer, ['ATOM_SHELL_GUEST_WINDOW_MANAGER_WEB_CONTENTS_METHOD', this.guestId, 'executeJavaScript'].concat(slice.call(args)));
+  };
+
+  return BrowserWindowProxy;
+
+})();
+
+if (process.guestInstanceId == null) {
+  // Override default window.close.
+  window.close = function() {
+    return remote.getCurrentWindow().close();
+  };
+}
+
+// Make the browser window or guest view emit "new-window" event.
+window.open = function(url, frameName, features) {
+  var feature, guestId, i, ints, j, len, len1, name, options, ref1, ref2, value;
+  if (frameName == null) {
+    frameName = '';
+  }
+  if (features == null) {
+    features = '';
+  }
+  options = {};
+  ints = ['x', 'y', 'width', 'height', 'min-width', 'max-width', 'min-height', 'max-height', 'zoom-factor'];
+
+  // Make sure to get rid of excessive whitespace in the property name
+  ref1 = features.split(/,\s*/);
+  for (i = 0, len = ref1.length; i < len; i++) {
+    feature = ref1[i];
+    ref2 = feature.split(/\s*=/), name = ref2[0], value = ref2[1];
+    options[name] = value === 'yes' || value === '1' ? true : value === 'no' || value === '0' ? false : value;
+  }
+  if (options.left) {
+    if (options.x == null) {
+      options.x = options.left;
+    }
+  }
+  if (options.top) {
+    if (options.y == null) {
+      options.y = options.top;
+    }
+  }
+  if (options.title == null) {
+    options.title = frameName;
+  }
+  if (options.width == null) {
+    options.width = 800;
+  }
+  if (options.height == null) {
+    options.height = 600;
+  }
+
+  // Resolve relative urls.
+  url = resolveURL(url);
+  for (j = 0, len1 = ints.length; j < len1; j++) {
+    name = ints[j];
+    if (options[name] != null) {
+      options[name] = parseInt(options[name], 10);
+    }
+  }
+  guestId = ipcRenderer.sendSync('ATOM_SHELL_GUEST_WINDOW_MANAGER_WINDOW_OPEN', url, frameName, options);
+  if (guestId) {
+    return BrowserWindowProxy.getOrCreate(guestId);
+  } else {
+    return null;
+  }
+};
+
+// Use the dialog API to implement alert().
+window.alert = function(message, title) {
+  var buttons;
+  if (title == null) {
+    title = '';
+  }
+  buttons = ['OK'];
+  message = message.toString();
+  remote.dialog.showMessageBox(remote.getCurrentWindow(), {
+    message: message,
+    title: title,
+    buttons: buttons
+  });
+
+  // Alert should always return undefined.
+};
+
+// And the confirm().
+window.confirm = function(message, title) {
+  var buttons, cancelId;
+  if (title == null) {
+    title = '';
+  }
+  buttons = ['OK', 'Cancel'];
+  cancelId = 1;
+  return !remote.dialog.showMessageBox(remote.getCurrentWindow(), {
+    message: message,
+    title: title,
+    buttons: buttons,
+    cancelId: cancelId
+  });
+};
+
+// But we do not support prompt().
+window.prompt = function() {
+  throw new Error('prompt() is and will not be supported.');
+};
+
+if (process.openerId != null) {
+  window.opener = BrowserWindowProxy.getOrCreate(process.openerId);
+}
+
+ipcRenderer.on('ATOM_SHELL_GUEST_WINDOW_POSTMESSAGE', function(event, sourceId, message, sourceOrigin) {
+  // Manually dispatch event instead of using postMessage because we also need to
+  // set event.source.
+  event = document.createEvent('Event');
+  event.initEvent('message', false, false);
+  event.data = message;
+  event.origin = sourceOrigin;
+  event.source = BrowserWindowProxy.getOrCreate(sourceId);
+  return window.dispatchEvent(event);
+});
+
+// Forward history operations to browser.
+var sendHistoryOperation = function() {
+  var args;
+  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
+  return ipcRenderer.send.apply(ipcRenderer, ['ATOM_SHELL_NAVIGATION_CONTROLLER'].concat(slice.call(args)));
+};
+
+var getHistoryOperation = function() {
+  var args;
+  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
+  return ipcRenderer.sendSync.apply(ipcRenderer, ['ATOM_SHELL_SYNC_NAVIGATION_CONTROLLER'].concat(slice.call(args)));
+};
+
+window.history.back = function() {
+  return sendHistoryOperation('goBack');
+};
+
+window.history.forward = function() {
+  return sendHistoryOperation('goForward');
+};
+
+window.history.go = function(offset) {
+  return sendHistoryOperation('goToOffset', offset);
+};
+
+Object.defineProperty(window.history, 'length', {
+  get: function() {
+    return getHistoryOperation('length');
+  }
+});
+
+// Make document.hidden and document.visibilityState return the correct value.
+Object.defineProperty(document, 'hidden', {
+  get: function() {
+    var currentWindow;
+    currentWindow = remote.getCurrentWindow();
+    return currentWindow.isMinimized() || !currentWindow.isVisible();
+  }
+});
+
+Object.defineProperty(document, 'visibilityState', {
+  get: function() {
+    if (document.hidden) {
+      return "hidden";
+    } else {
+      return "visible";
+    }
+  }
+});

lib/renderer/web-view/guest-view-internal.js

@@ -0,0 +1,112 @@
+const ipcRenderer = require('electron').ipcRenderer;
+const webFrame = require('electron').webFrame;
+
+var slice = [].slice;
+var requestId = 0;
+
+var WEB_VIEW_EVENTS = {
+  'load-commit': ['url', 'isMainFrame'],
+  'did-finish-load': [],
+  'did-fail-load': ['errorCode', 'errorDescription', 'validatedURL'],
+  'did-frame-finish-load': ['isMainFrame'],
+  'did-start-loading': [],
+  'did-stop-loading': [],
+  'did-get-response-details': ['status', 'newURL', 'originalURL', 'httpResponseCode', 'requestMethod', 'referrer', 'headers'],
+  'did-get-redirect-request': ['oldURL', 'newURL', 'isMainFrame'],
+  'dom-ready': [],
+  'console-message': ['level', 'message', 'line', 'sourceId'],
+  'devtools-opened': [],
+  'devtools-closed': [],
+  'devtools-focused': [],
+  'new-window': ['url', 'frameName', 'disposition', 'options'],
+  'will-navigate': ['url'],
+  'did-navigate': ['url'],
+  'did-navigate-in-page': ['url'],
+  'close': [],
+  'crashed': [],
+  'gpu-crashed': [],
+  'plugin-crashed': ['name', 'version'],
+  'media-started-playing': [],
+  'media-paused': [],
+  'did-change-theme-color': ['themeColor'],
+  'destroyed': [],
+  'page-title-updated': ['title', 'explicitSet'],
+  'page-favicon-updated': ['favicons'],
+  'enter-html-full-screen': [],
+  'leave-html-full-screen': [],
+  'found-in-page': ['result']
+};
+
+var DEPRECATED_EVENTS = {
+  'page-title-updated': 'page-title-set'
+};
+
+var dispatchEvent = function() {
+  var args, domEvent, eventKey, eventName, f, i, j, len, ref1, webView;
+  webView = arguments[0], eventName = arguments[1], eventKey = arguments[2], args = 4 <= arguments.length ? slice.call(arguments, 3) : [];
+  if (DEPRECATED_EVENTS[eventName] != null) {
+    dispatchEvent.apply(null, [webView, DEPRECATED_EVENTS[eventName], eventKey].concat(slice.call(args)));
+  }
+  domEvent = new Event(eventName);
+  ref1 = WEB_VIEW_EVENTS[eventKey];
+  for (i = j = 0, len = ref1.length; j < len; i = ++j) {
+    f = ref1[i];
+    domEvent[f] = args[i];
+  }
+  webView.dispatchEvent(domEvent);
+  if (eventName === 'load-commit') {
+    return webView.onLoadCommit(domEvent);
+  }
+};
+
+module.exports = {
+  registerEvents: function(webView, viewInstanceId) {
+    ipcRenderer.on("ATOM_SHELL_GUEST_VIEW_INTERNAL_DISPATCH_EVENT-" + viewInstanceId, function() {
+      var eventName = arguments[1];
+      var args = 3 <= arguments.length ? slice.call(arguments, 2) : [];
+      return dispatchEvent.apply(null, [webView, eventName, eventName].concat(slice.call(args)));
+    });
+    ipcRenderer.on("ATOM_SHELL_GUEST_VIEW_INTERNAL_IPC_MESSAGE-" + viewInstanceId, function() {
+      var channel = arguments[1];
+      var args = 3 <= arguments.length ? slice.call(arguments, 2) : [];
+      var domEvent = new Event('ipc-message');
+      domEvent.channel = channel;
+      domEvent.args = slice.call(args);
+      return webView.dispatchEvent(domEvent);
+    });
+    return ipcRenderer.on("ATOM_SHELL_GUEST_VIEW_INTERNAL_SIZE_CHANGED-" + viewInstanceId, function() {
+      var args, domEvent, f, i, j, len, ref1;
+      args = 2 <= arguments.length ? slice.call(arguments, 1) : [];
+      domEvent = new Event('size-changed');
+      ref1 = ['oldWidth', 'oldHeight', 'newWidth', 'newHeight'];
+      for (i = j = 0, len = ref1.length; j < len; i = ++j) {
+        f = ref1[i];
+        domEvent[f] = args[i];
+      }
+      return webView.onSizeChanged(domEvent);
+    });
+  },
+  deregisterEvents: function(viewInstanceId) {
+    ipcRenderer.removeAllListeners("ATOM_SHELL_GUEST_VIEW_INTERNAL_DISPATCH_EVENT-" + viewInstanceId);
+    ipcRenderer.removeAllListeners("ATOM_SHELL_GUEST_VIEW_INTERNAL_IPC_MESSAGE-" + viewInstanceId);
+    return ipcRenderer.removeAllListeners("ATOM_SHELL_GUEST_VIEW_INTERNAL_SIZE_CHANGED-" + viewInstanceId);
+  },
+  createGuest: function(params, callback) {
+    requestId++;
+    ipcRenderer.send('ATOM_SHELL_GUEST_VIEW_MANAGER_CREATE_GUEST', params, requestId);
+    return ipcRenderer.once("ATOM_SHELL_RESPONSE_" + requestId, callback);
+  },
+  attachGuest: function(elementInstanceId, guestInstanceId, params) {
+    ipcRenderer.send('ATOM_SHELL_GUEST_VIEW_MANAGER_ATTACH_GUEST', elementInstanceId, guestInstanceId, params);
+    return webFrame.attachGuest(elementInstanceId);
+  },
+  destroyGuest: function(guestInstanceId) {
+    return ipcRenderer.send('ATOM_SHELL_GUEST_VIEW_MANAGER_DESTROY_GUEST', guestInstanceId);
+  },
+  setSize: function(guestInstanceId, params) {
+    return ipcRenderer.send('ATOM_SHELL_GUEST_VIEW_MANAGER_SET_SIZE', guestInstanceId, params);
+  },
+  setAllowTransparency: function(guestInstanceId, allowtransparency) {
+    return ipcRenderer.send('ATOM_SHELL_GUEST_VIEW_MANAGER_SET_ALLOW_TRANSPARENCY', guestInstanceId, allowtransparency);
+  }
+};

lib/renderer/web-view/web-view-attributes.js

@@ -0,0 +1,321 @@
+'use strict';
+
+const WebViewImpl = require('./web-view');
+const guestViewInternal = require('./guest-view-internal');
+const webViewConstants = require('./web-view-constants');
+const remote = require('electron').remote;
+
+// Helper function to resolve url set in attribute.
+var a = document.createElement('a');
+
+var resolveURL = function(url) {
+  a.href = url;
+  return a.href;
+};
+
+// Attribute objects.
+// Default implementation of a WebView attribute.
+class WebViewAttribute {
+  constructor(name, webViewImpl) {
+    this.name = name;
+    this.value = webViewImpl.webviewNode[name] || '';
+    this.webViewImpl = webViewImpl;
+    this.ignoreMutation = false;
+    this.defineProperty();
+  }
+
+  // Retrieves and returns the attribute's value.
+  getValue() {
+    return this.webViewImpl.webviewNode.getAttribute(this.name) || this.value;
+  }
+
+  // Sets the attribute's value.
+  setValue(value) {
+    return this.webViewImpl.webviewNode.setAttribute(this.name, value || '');
+  }
+
+  // Changes the attribute's value without triggering its mutation handler.
+  setValueIgnoreMutation(value) {
+    this.ignoreMutation = true;
+    this.setValue(value);
+    return this.ignoreMutation = false;
+  }
+
+  // Defines this attribute as a property on the webview node.
+  defineProperty() {
+    return Object.defineProperty(this.webViewImpl.webviewNode, this.name, {
+      get: (function(_this) {
+        return function() {
+          return _this.getValue();
+        };
+      })(this),
+      set: (function(_this) {
+        return function(value) {
+          return _this.setValue(value);
+        };
+      })(this),
+      enumerable: true
+    });
+  }
+
+  // Called when the attribute's value changes.
+  handleMutation() {}
+}
+
+// An attribute that is treated as a Boolean.
+class BooleanAttribute extends WebViewAttribute {
+  constructor(name, webViewImpl) {
+    super(name, webViewImpl);
+  }
+
+  getValue() {
+    return this.webViewImpl.webviewNode.hasAttribute(this.name);
+  }
+
+  setValue(value) {
+    if (!value) {
+      return this.webViewImpl.webviewNode.removeAttribute(this.name);
+    } else {
+      return this.webViewImpl.webviewNode.setAttribute(this.name, '');
+    }
+  }
+}
+
+// Attribute that specifies whether transparency is allowed in the webview.
+class AllowTransparencyAttribute extends BooleanAttribute {
+  constructor(webViewImpl) {
+    super(webViewConstants.ATTRIBUTE_ALLOWTRANSPARENCY, webViewImpl);
+  }
+
+  handleMutation() {
+    if (!this.webViewImpl.guestInstanceId) {
+      return;
+    }
+    return guestViewInternal.setAllowTransparency(this.webViewImpl.guestInstanceId, this.getValue());
+  }
+}
+
+// Attribute used to define the demension limits of autosizing.
+class AutosizeDimensionAttribute extends WebViewAttribute {
+  constructor(name, webViewImpl) {
+    super(name, webViewImpl);
+  }
+
+  getValue() {
+    return parseInt(this.webViewImpl.webviewNode.getAttribute(this.name)) || 0;
+  }
+
+  handleMutation() {
+    if (!this.webViewImpl.guestInstanceId) {
+      return;
+    }
+    return guestViewInternal.setSize(this.webViewImpl.guestInstanceId, {
+      enableAutoSize: this.webViewImpl.attributes[webViewConstants.ATTRIBUTE_AUTOSIZE].getValue(),
+      min: {
+        width: parseInt(this.webViewImpl.attributes[webViewConstants.ATTRIBUTE_MINWIDTH].getValue() || 0),
+        height: parseInt(this.webViewImpl.attributes[webViewConstants.ATTRIBUTE_MINHEIGHT].getValue() || 0)
+      },
+      max: {
+        width: parseInt(this.webViewImpl.attributes[webViewConstants.ATTRIBUTE_MAXWIDTH].getValue() || 0),
+        height: parseInt(this.webViewImpl.attributes[webViewConstants.ATTRIBUTE_MAXHEIGHT].getValue() || 0)
+      }
+    });
+  }
+}
+
+
+// Attribute that specifies whether the webview should be autosized.
+class AutosizeAttribute extends BooleanAttribute {
+  constructor(webViewImpl) {
+    super(webViewConstants.ATTRIBUTE_AUTOSIZE, webViewImpl);
+  }
+}
+
+AutosizeAttribute.prototype.handleMutation = AutosizeDimensionAttribute.prototype.handleMutation;
+
+// Attribute representing the state of the storage partition.
+class PartitionAttribute extends WebViewAttribute {
+  constructor(webViewImpl) {
+    super(webViewConstants.ATTRIBUTE_PARTITION, webViewImpl);
+    this.validPartitionId = true;
+  }
+
+  handleMutation(oldValue, newValue) {
+    newValue = newValue || '';
+
+    // The partition cannot change if the webview has already navigated.
+    if (!this.webViewImpl.beforeFirstNavigation) {
+      window.console.error(webViewConstants.ERROR_MSG_ALREADY_NAVIGATED);
+      this.setValueIgnoreMutation(oldValue);
+      return;
+    }
+    if (newValue === 'persist:') {
+      this.validPartitionId = false;
+      return window.console.error(webViewConstants.ERROR_MSG_INVALID_PARTITION_ATTRIBUTE);
+    }
+  }
+}
+
+// Attribute that handles the location and navigation of the webview.
+class SrcAttribute extends WebViewAttribute {
+  constructor(webViewImpl) {
+    super(webViewConstants.ATTRIBUTE_SRC, webViewImpl);
+    this.setupMutationObserver();
+  }
+
+  getValue() {
+    if (this.webViewImpl.webviewNode.hasAttribute(this.name)) {
+      return resolveURL(this.webViewImpl.webviewNode.getAttribute(this.name));
+    } else {
+      return this.value;
+    }
+  }
+
+  setValueIgnoreMutation(value) {
+    super.setValueIgnoreMutation(value);
+
+    // takeRecords() is needed to clear queued up src mutations. Without it, it
+    // is possible for this change to get picked up asyncronously by src's
+    // mutation observer |observer|, and then get handled even though we do not
+    // want to handle this mutation.
+    return this.observer.takeRecords();
+  }
+
+  handleMutation(oldValue, newValue) {
+
+    // Once we have navigated, we don't allow clearing the src attribute.
+    // Once <webview> enters a navigated state, it cannot return to a
+    // placeholder state.
+    if (!newValue && oldValue) {
+
+      // src attribute changes normally initiate a navigation. We suppress
+      // the next src attribute handler call to avoid reloading the page
+      // on every guest-initiated navigation.
+      this.setValueIgnoreMutation(oldValue);
+      return;
+    }
+    return this.parse();
+  }
+
+  // The purpose of this mutation observer is to catch assignment to the src
+  // attribute without any changes to its value. This is useful in the case
+  // where the webview guest has crashed and navigating to the same address
+  // spawns off a new process.
+  setupMutationObserver() {
+    var params;
+    this.observer = new MutationObserver((function(_this) {
+      return function(mutations) {
+        var i, len, mutation, newValue, oldValue;
+        for (i = 0, len = mutations.length; i < len; i++) {
+          mutation = mutations[i];
+          oldValue = mutation.oldValue;
+          newValue = _this.getValue();
+          if (oldValue !== newValue) {
+            return;
+          }
+          _this.handleMutation(oldValue, newValue);
+        }
+      };
+    })(this));
+    params = {
+      attributes: true,
+      attributeOldValue: true,
+      attributeFilter: [this.name]
+    };
+    return this.observer.observe(this.webViewImpl.webviewNode, params);
+  }
+
+  parse() {
+    var guestContents, httpreferrer, opts, useragent;
+    if (!this.webViewImpl.elementAttached || !this.webViewImpl.attributes[webViewConstants.ATTRIBUTE_PARTITION].validPartitionId || !this.getValue()) {
+      return;
+    }
+    if (this.webViewImpl.guestInstanceId == null) {
+      if (this.webViewImpl.beforeFirstNavigation) {
+        this.webViewImpl.beforeFirstNavigation = false;
+        this.webViewImpl.createGuest();
+      }
+      return;
+    }
+
+    // Navigate to |this.src|.
+    opts = {};
+    httpreferrer = this.webViewImpl.attributes[webViewConstants.ATTRIBUTE_HTTPREFERRER].getValue();
+    if (httpreferrer) {
+      opts.httpReferrer = httpreferrer;
+    }
+    useragent = this.webViewImpl.attributes[webViewConstants.ATTRIBUTE_USERAGENT].getValue();
+    if (useragent) {
+      opts.userAgent = useragent;
+    }
+    guestContents = remote.getGuestWebContents(this.webViewImpl.guestInstanceId);
+    return guestContents.loadURL(this.getValue(), opts);
+  }
+}
+
+// Attribute specifies HTTP referrer.
+class HttpReferrerAttribute extends WebViewAttribute {
+  constructor(webViewImpl) {
+    super(webViewConstants.ATTRIBUTE_HTTPREFERRER, webViewImpl);
+  }
+}
+
+// Attribute specifies user agent
+class UserAgentAttribute extends WebViewAttribute {
+  constructor(webViewImpl) {
+    super(webViewConstants.ATTRIBUTE_USERAGENT, webViewImpl);
+  }
+}
+
+// Attribute that set preload script.
+class PreloadAttribute extends WebViewAttribute {
+  constructor(webViewImpl) {
+    super(webViewConstants.ATTRIBUTE_PRELOAD, webViewImpl);
+  }
+
+  getValue() {
+    var preload, protocol;
+    if (!this.webViewImpl.webviewNode.hasAttribute(this.name)) {
+      return this.value;
+    }
+    preload = resolveURL(this.webViewImpl.webviewNode.getAttribute(this.name));
+    protocol = preload.substr(0, 5);
+    if (protocol !== 'file:') {
+      console.error(webViewConstants.ERROR_MSG_INVALID_PRELOAD_ATTRIBUTE);
+      preload = '';
+    }
+    return preload;
+  }
+}
+
+// Attribute that specifies the blink features to be enabled.
+class BlinkFeaturesAttribute extends WebViewAttribute {
+  constructor(webViewImpl) {
+    super(webViewConstants.ATTRIBUTE_BLINKFEATURES, webViewImpl);
+  }
+}
+
+// Sets up all of the webview attributes.
+WebViewImpl.prototype.setupWebViewAttributes = function() {
+  var attribute, autosizeAttributes, i, len, results;
+  this.attributes = {};
+  this.attributes[webViewConstants.ATTRIBUTE_ALLOWTRANSPARENCY] = new AllowTransparencyAttribute(this);
+  this.attributes[webViewConstants.ATTRIBUTE_AUTOSIZE] = new AutosizeAttribute(this);
+  this.attributes[webViewConstants.ATTRIBUTE_PARTITION] = new PartitionAttribute(this);
+  this.attributes[webViewConstants.ATTRIBUTE_SRC] = new SrcAttribute(this);
+  this.attributes[webViewConstants.ATTRIBUTE_HTTPREFERRER] = new HttpReferrerAttribute(this);
+  this.attributes[webViewConstants.ATTRIBUTE_USERAGENT] = new UserAgentAttribute(this);
+  this.attributes[webViewConstants.ATTRIBUTE_NODEINTEGRATION] = new BooleanAttribute(webViewConstants.ATTRIBUTE_NODEINTEGRATION, this);
+  this.attributes[webViewConstants.ATTRIBUTE_PLUGINS] = new BooleanAttribute(webViewConstants.ATTRIBUTE_PLUGINS, this);
+  this.attributes[webViewConstants.ATTRIBUTE_DISABLEWEBSECURITY] = new BooleanAttribute(webViewConstants.ATTRIBUTE_DISABLEWEBSECURITY, this);
+  this.attributes[webViewConstants.ATTRIBUTE_ALLOWPOPUPS] = new BooleanAttribute(webViewConstants.ATTRIBUTE_ALLOWPOPUPS, this);
+  this.attributes[webViewConstants.ATTRIBUTE_PRELOAD] = new PreloadAttribute(this);
+  this.attributes[webViewConstants.ATTRIBUTE_BLINKFEATURES] = new BlinkFeaturesAttribute(this);
+  autosizeAttributes = [webViewConstants.ATTRIBUTE_MAXHEIGHT, webViewConstants.ATTRIBUTE_MAXWIDTH, webViewConstants.ATTRIBUTE_MINHEIGHT, webViewConstants.ATTRIBUTE_MINWIDTH];
+  results = [];
+  for (i = 0, len = autosizeAttributes.length; i < len; i++) {
+    attribute = autosizeAttributes[i];
+    results.push(this.attributes[attribute] = new AutosizeDimensionAttribute(attribute, this));
+  }
+  return results;
+};

lib/renderer/web-view/web-view-constants.js

@@ -0,0 +1,29 @@
+module.exports = {
+  // Attributes.
+  ATTRIBUTE_ALLOWTRANSPARENCY: 'allowtransparency',
+  ATTRIBUTE_AUTOSIZE: 'autosize',
+  ATTRIBUTE_MAXHEIGHT: 'maxheight',
+  ATTRIBUTE_MAXWIDTH: 'maxwidth',
+  ATTRIBUTE_MINHEIGHT: 'minheight',
+  ATTRIBUTE_MINWIDTH: 'minwidth',
+  ATTRIBUTE_NAME: 'name',
+  ATTRIBUTE_PARTITION: 'partition',
+  ATTRIBUTE_SRC: 'src',
+  ATTRIBUTE_HTTPREFERRER: 'httpreferrer',
+  ATTRIBUTE_NODEINTEGRATION: 'nodeintegration',
+  ATTRIBUTE_PLUGINS: 'plugins',
+  ATTRIBUTE_DISABLEWEBSECURITY: 'disablewebsecurity',
+  ATTRIBUTE_ALLOWPOPUPS: 'allowpopups',
+  ATTRIBUTE_PRELOAD: 'preload',
+  ATTRIBUTE_USERAGENT: 'useragent',
+  ATTRIBUTE_BLINKFEATURES: 'blinkfeatures',
+
+  // Internal attribute.
+  ATTRIBUTE_INTERNALINSTANCEID: 'internalinstanceid',
+
+  // Error messages.
+  ERROR_MSG_ALREADY_NAVIGATED: 'The object has already navigated, so its partition cannot be changed.',
+  ERROR_MSG_CANNOT_INJECT_SCRIPT: '<webview>: ' + 'Script cannot be injected into content until the page has loaded.',
+  ERROR_MSG_INVALID_PARTITION_ATTRIBUTE: 'Invalid partition attribute.',
+  ERROR_MSG_INVALID_PRELOAD_ATTRIBUTE: 'Only "file:" protocol is supported in "preload" attribute.'
+};

lib/renderer/web-view/web-view.js

@@ -0,0 +1,478 @@
+'use strict';
+
+const deprecate = require('electron').deprecate;
+const webFrame = require('electron').webFrame;
+const remote = require('electron').remote;
+const ipcRenderer = require('electron').ipcRenderer;
+
+const v8Util = process.atomBinding('v8_util');
+const guestViewInternal = require('./guest-view-internal');
+const webViewConstants = require('./web-view-constants');
+
+var hasProp = {}.hasOwnProperty;
+var slice = [].slice;
+
+// ID generator.
+var nextId = 0;
+
+var getNextId = function() {
+  return ++nextId;
+};
+
+// Represents the internal state of the WebView node.
+var WebViewImpl = (function() {
+  function WebViewImpl(webviewNode) {
+    var shadowRoot;
+    this.webviewNode = webviewNode;
+    v8Util.setHiddenValue(this.webviewNode, 'internal', this);
+    this.attached = false;
+    this.elementAttached = false;
+    this.beforeFirstNavigation = true;
+
+    // on* Event handlers.
+    this.on = {};
+    this.browserPluginNode = this.createBrowserPluginNode();
+    shadowRoot = this.webviewNode.createShadowRoot();
+    shadowRoot.innerHTML = '<style>:host { display: flex; }</style>';
+    this.setupWebViewAttributes();
+    this.setupFocusPropagation();
+    this.viewInstanceId = getNextId();
+    shadowRoot.appendChild(this.browserPluginNode);
+
+    // Subscribe to host's zoom level changes.
+    this.onZoomLevelChanged = (zoomLevel) => {
+      this.webviewNode.setZoomLevel(zoomLevel);
+    };
+    webFrame.on('zoom-level-changed', this.onZoomLevelChanged);
+  }
+
+  WebViewImpl.prototype.createBrowserPluginNode = function() {
+    // We create BrowserPlugin as a custom element in order to observe changes
+    // to attributes synchronously.
+    var browserPluginNode;
+    browserPluginNode = new WebViewImpl.BrowserPlugin();
+    v8Util.setHiddenValue(browserPluginNode, 'internal', this);
+    return browserPluginNode;
+  };
+
+  // Resets some state upon reattaching <webview> element to the DOM.
+  WebViewImpl.prototype.reset = function() {
+    // Unlisten the zoom-level-changed event.
+    webFrame.removeListener('zoom-level-changed', this.onZoomLevelChanged);
+
+    // If guestInstanceId is defined then the <webview> has navigated and has
+    // already picked up a partition ID. Thus, we need to reset the initialization
+    // state. However, it may be the case that beforeFirstNavigation is false BUT
+    // guestInstanceId has yet to be initialized. This means that we have not
+    // heard back from createGuest yet. We will not reset the flag in this case so
+    // that we don't end up allocating a second guest.
+    if (this.guestInstanceId) {
+      guestViewInternal.destroyGuest(this.guestInstanceId);
+      this.webContents = null;
+      this.guestInstanceId = void 0;
+      this.beforeFirstNavigation = true;
+      this.attributes[webViewConstants.ATTRIBUTE_PARTITION].validPartitionId = true;
+    }
+    return this.internalInstanceId = 0;
+  };
+
+  // Sets the <webview>.request property.
+  WebViewImpl.prototype.setRequestPropertyOnWebViewNode = function(request) {
+    return Object.defineProperty(this.webviewNode, 'request', {
+      value: request,
+      enumerable: true
+    });
+  };
+
+  WebViewImpl.prototype.setupFocusPropagation = function() {
+    if (!this.webviewNode.hasAttribute('tabIndex')) {
+
+      // <webview> needs a tabIndex in order to be focusable.
+      // TODO(fsamuel): It would be nice to avoid exposing a tabIndex attribute
+      // to allow <webview> to be focusable.
+      // See http://crbug.com/231664.
+      this.webviewNode.setAttribute('tabIndex', -1);
+    }
+    this.webviewNode.addEventListener('focus', (function(_this) {
+      return function() {
+        // Focus the BrowserPlugin when the <webview> takes focus.
+        return _this.browserPluginNode.focus();
+      };
+    })(this));
+    return this.webviewNode.addEventListener('blur', (function(_this) {
+      return function() {
+        // Blur the BrowserPlugin when the <webview> loses focus.
+        return _this.browserPluginNode.blur();
+      };
+    })(this));
+  };
+
+
+  // This observer monitors mutations to attributes of the <webview> and
+  // updates the BrowserPlugin properties accordingly. In turn, updating
+  // a BrowserPlugin property will update the corresponding BrowserPlugin
+  // attribute, if necessary. See BrowserPlugin::UpdateDOMAttribute for more
+  // details.
+  WebViewImpl.prototype.handleWebviewAttributeMutation = function(attributeName, oldValue, newValue) {
+    if (!this.attributes[attributeName] || this.attributes[attributeName].ignoreMutation) {
+      return;
+    }
+
+    // Let the changed attribute handle its own mutation;
+    return this.attributes[attributeName].handleMutation(oldValue, newValue);
+  };
+
+  WebViewImpl.prototype.handleBrowserPluginAttributeMutation = function(attributeName, oldValue, newValue) {
+    if (attributeName === webViewConstants.ATTRIBUTE_INTERNALINSTANCEID && !oldValue && !!newValue) {
+      this.browserPluginNode.removeAttribute(webViewConstants.ATTRIBUTE_INTERNALINSTANCEID);
+      this.internalInstanceId = parseInt(newValue);
+
+      // Track when the element resizes using the element resize callback.
+      webFrame.registerElementResizeCallback(this.internalInstanceId, this.onElementResize.bind(this));
+      if (!this.guestInstanceId) {
+        return;
+      }
+      return guestViewInternal.attachGuest(this.internalInstanceId, this.guestInstanceId, this.buildParams());
+    }
+  };
+
+  WebViewImpl.prototype.onSizeChanged = function(webViewEvent) {
+    var maxHeight, maxWidth, minHeight, minWidth, newHeight, newWidth, node, width;
+    newWidth = webViewEvent.newWidth;
+    newHeight = webViewEvent.newHeight;
+    node = this.webviewNode;
+    width = node.offsetWidth;
+
+    // Check the current bounds to make sure we do not resize <webview>
+    // outside of current constraints.
+    maxWidth = this.attributes[webViewConstants.ATTRIBUTE_MAXWIDTH].getValue() | width;
+    maxHeight = this.attributes[webViewConstants.ATTRIBUTE_MAXHEIGHT].getValue() | width;
+    minWidth = this.attributes[webViewConstants.ATTRIBUTE_MINWIDTH].getValue() | width;
+    minHeight = this.attributes[webViewConstants.ATTRIBUTE_MINHEIGHT].getValue() | width;
+    minWidth = Math.min(minWidth, maxWidth);
+    minHeight = Math.min(minHeight, maxHeight);
+    if (!this.attributes[webViewConstants.ATTRIBUTE_AUTOSIZE].getValue() || (newWidth >= minWidth && newWidth <= maxWidth && newHeight >= minHeight && newHeight <= maxHeight)) {
+      node.style.width = newWidth + 'px';
+      node.style.height = newHeight + 'px';
+
+      // Only fire the DOM event if the size of the <webview> has actually
+      // changed.
+      return this.dispatchEvent(webViewEvent);
+    }
+  };
+
+  WebViewImpl.prototype.onElementResize = function(newSize) {
+    // Dispatch the 'resize' event.
+    var resizeEvent;
+    resizeEvent = new Event('resize', {
+      bubbles: true
+    });
+    resizeEvent.newWidth = newSize.width;
+    resizeEvent.newHeight = newSize.height;
+    this.dispatchEvent(resizeEvent);
+    if (this.guestInstanceId) {
+      return guestViewInternal.setSize(this.guestInstanceId, {
+        normal: newSize
+      });
+    }
+  };
+
+  WebViewImpl.prototype.createGuest = function() {
+    return guestViewInternal.createGuest(this.buildParams(), (function(_this) {
+      return function(event, guestInstanceId) {
+        return _this.attachWindow(guestInstanceId);
+      };
+    })(this));
+  };
+
+  WebViewImpl.prototype.dispatchEvent = function(webViewEvent) {
+    return this.webviewNode.dispatchEvent(webViewEvent);
+  };
+
+  // Adds an 'on<event>' property on the webview, which can be used to set/unset
+  // an event handler.
+  WebViewImpl.prototype.setupEventProperty = function(eventName) {
+    var propertyName;
+    propertyName = 'on' + eventName.toLowerCase();
+    return Object.defineProperty(this.webviewNode, propertyName, {
+      get: (function(_this) {
+        return function() {
+          return _this.on[propertyName];
+        };
+      })(this),
+      set: (function(_this) {
+        return function(value) {
+          if (_this.on[propertyName]) {
+            _this.webviewNode.removeEventListener(eventName, _this.on[propertyName]);
+          }
+          _this.on[propertyName] = value;
+          if (value) {
+            return _this.webviewNode.addEventListener(eventName, value);
+          }
+        };
+      })(this),
+      enumerable: true
+    });
+  };
+
+  // Updates state upon loadcommit.
+  WebViewImpl.prototype.onLoadCommit = function(webViewEvent) {
+    var newValue, oldValue;
+    oldValue = this.webviewNode.getAttribute(webViewConstants.ATTRIBUTE_SRC);
+    newValue = webViewEvent.url;
+    if (webViewEvent.isMainFrame && (oldValue !== newValue)) {
+
+      // Touching the src attribute triggers a navigation. To avoid
+      // triggering a page reload on every guest-initiated navigation,
+      // we do not handle this mutation.
+      return this.attributes[webViewConstants.ATTRIBUTE_SRC].setValueIgnoreMutation(newValue);
+    }
+  };
+
+  WebViewImpl.prototype.onAttach = function(storagePartitionId) {
+    return this.attributes[webViewConstants.ATTRIBUTE_PARTITION].setValue(storagePartitionId);
+  };
+
+  WebViewImpl.prototype.buildParams = function() {
+    var attribute, attributeName, css, elementRect, params, ref1;
+    params = {
+      instanceId: this.viewInstanceId,
+      userAgentOverride: this.userAgentOverride
+    };
+    ref1 = this.attributes;
+    for (attributeName in ref1) {
+      if (!hasProp.call(ref1, attributeName)) continue;
+      attribute = ref1[attributeName];
+      params[attributeName] = attribute.getValue();
+    }
+
+    // When the WebView is not participating in layout (display:none)
+    // then getBoundingClientRect() would report a width and height of 0.
+    // However, in the case where the WebView has a fixed size we can
+    // use that value to initially size the guest so as to avoid a relayout of
+    // the on display:block.
+    css = window.getComputedStyle(this.webviewNode, null);
+    elementRect = this.webviewNode.getBoundingClientRect();
+    params.elementWidth = parseInt(elementRect.width) || parseInt(css.getPropertyValue('width'));
+    params.elementHeight = parseInt(elementRect.height) || parseInt(css.getPropertyValue('height'));
+    return params;
+  };
+
+  WebViewImpl.prototype.attachWindow = function(guestInstanceId) {
+    this.guestInstanceId = guestInstanceId;
+    this.webContents = remote.getGuestWebContents(this.guestInstanceId);
+    if (!this.internalInstanceId) {
+      return true;
+    }
+    return guestViewInternal.attachGuest(this.internalInstanceId, this.guestInstanceId, this.buildParams());
+  };
+
+  return WebViewImpl;
+
+})();
+
+// Registers browser plugin <object> custom element.
+var registerBrowserPluginElement = function() {
+  var proto;
+  proto = Object.create(HTMLObjectElement.prototype);
+  proto.createdCallback = function() {
+    this.setAttribute('type', 'application/browser-plugin');
+    this.setAttribute('id', 'browser-plugin-' + getNextId());
+
+    // The <object> node fills in the <webview> container.
+    return this.style.flex = '1 1 auto';
+  };
+  proto.attributeChangedCallback = function(name, oldValue, newValue) {
+    var internal;
+    internal = v8Util.getHiddenValue(this, 'internal');
+    if (!internal) {
+      return;
+    }
+    return internal.handleBrowserPluginAttributeMutation(name, oldValue, newValue);
+  };
+  proto.attachedCallback = function() {
+    // Load the plugin immediately.
+    return this.nonExistentAttribute;
+  };
+  WebViewImpl.BrowserPlugin = webFrame.registerEmbedderCustomElement('browserplugin', {
+    "extends": 'object',
+    prototype: proto
+  });
+  delete proto.createdCallback;
+  delete proto.attachedCallback;
+  delete proto.detachedCallback;
+  return delete proto.attributeChangedCallback;
+};
+
+// Registers <webview> custom element.
+var registerWebViewElement = function() {
+  var createBlockHandler, createNonBlockHandler, i, j, len, len1, m, methods, nonblockMethods, proto;
+  proto = Object.create(HTMLObjectElement.prototype);
+  proto.createdCallback = function() {
+    return new WebViewImpl(this);
+  };
+  proto.attributeChangedCallback = function(name, oldValue, newValue) {
+    var internal;
+    internal = v8Util.getHiddenValue(this, 'internal');
+    if (!internal) {
+      return;
+    }
+    return internal.handleWebviewAttributeMutation(name, oldValue, newValue);
+  };
+  proto.detachedCallback = function() {
+    var internal;
+    internal = v8Util.getHiddenValue(this, 'internal');
+    if (!internal) {
+      return;
+    }
+    guestViewInternal.deregisterEvents(internal.viewInstanceId);
+    internal.elementAttached = false;
+    return internal.reset();
+  };
+  proto.attachedCallback = function() {
+    var internal;
+    internal = v8Util.getHiddenValue(this, 'internal');
+    if (!internal) {
+      return;
+    }
+    if (!internal.elementAttached) {
+      guestViewInternal.registerEvents(internal, internal.viewInstanceId);
+      internal.elementAttached = true;
+      return internal.attributes[webViewConstants.ATTRIBUTE_SRC].parse();
+    }
+  };
+
+  // Public-facing API methods.
+  methods = [
+    'getURL',
+    'loadURL',
+    'getTitle',
+    'isLoading',
+    'isWaitingForResponse',
+    'stop',
+    'reload',
+    'reloadIgnoringCache',
+    'canGoBack',
+    'canGoForward',
+    'canGoToOffset',
+    'clearHistory',
+    'goBack',
+    'goForward',
+    'goToIndex',
+    'goToOffset',
+    'isCrashed',
+    'setUserAgent',
+    'getUserAgent',
+    'openDevTools',
+    'closeDevTools',
+    'isDevToolsOpened',
+    'isDevToolsFocused',
+    'inspectElement',
+    'setAudioMuted',
+    'isAudioMuted',
+    'undo',
+    'redo',
+    'cut',
+    'copy',
+    'paste',
+    'pasteAndMatchStyle',
+    'delete',
+    'selectAll',
+    'unselect',
+    'replace',
+    'replaceMisspelling',
+    'findInPage',
+    'stopFindInPage',
+    'getId',
+    'downloadURL',
+    'inspectServiceWorker',
+    'print',
+    'printToPDF',
+  ];
+  nonblockMethods = [
+    'insertCSS',
+    'insertText',
+    'send',
+    'sendInputEvent',
+    'setZoomFactor',
+    'setZoomLevel',
+    'setZoomLevelLimits',
+  ];
+
+  // Forward proto.foo* method calls to WebViewImpl.foo*.
+  createBlockHandler = function(m) {
+    return function() {
+      var args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
+      var internal = v8Util.getHiddenValue(this, 'internal');
+      if (internal.webContents) {
+        return internal.webContents[m].apply(internal.webContents, args);
+      } else {
+        throw new Error(`Cannot call ${m} because the webContents is unavailable. The WebView must be attached to the DOM and the dom-ready event emitted before this method can be called.`);
+      }
+    };
+  };
+  for (i = 0, len = methods.length; i < len; i++) {
+    m = methods[i];
+    proto[m] = createBlockHandler(m);
+  }
+  createNonBlockHandler = function(m) {
+    return function() {
+      var args, internal;
+      args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
+      internal = v8Util.getHiddenValue(this, 'internal');
+      return ipcRenderer.send.apply(ipcRenderer, ['ATOM_BROWSER_ASYNC_CALL_TO_GUEST_VIEW', null, internal.guestInstanceId, m].concat(slice.call(args)));
+    };
+  };
+  for (j = 0, len1 = nonblockMethods.length; j < len1; j++) {
+    m = nonblockMethods[j];
+    proto[m] = createNonBlockHandler(m);
+  }
+
+  proto.executeJavaScript = function(code, hasUserGesture, callback) {
+    var internal = v8Util.getHiddenValue(this, 'internal');
+    if (typeof hasUserGesture === "function") {
+      callback = hasUserGesture;
+      hasUserGesture = false;
+    }
+    let requestId = getNextId();
+    ipcRenderer.send('ATOM_BROWSER_ASYNC_CALL_TO_GUEST_VIEW', requestId, internal.guestInstanceId, "executeJavaScript", code, hasUserGesture);
+    ipcRenderer.once(`ATOM_RENDERER_ASYNC_CALL_TO_GUEST_VIEW_RESPONSE_${requestId}`, function(event, result) {
+      if (callback)
+        callback(result);
+    });
+  };
+
+  // WebContents associated with this webview.
+  proto.getWebContents = function() {
+    var internal = v8Util.getHiddenValue(this, 'internal');
+    return internal.webContents;
+  };
+
+  // Deprecated.
+  deprecate.rename(proto, 'getUrl', 'getURL');
+  window.WebView = webFrame.registerEmbedderCustomElement('webview', {
+    prototype: proto
+  });
+
+  // Delete the callbacks so developers cannot call them and produce unexpected
+  // behavior.
+  delete proto.createdCallback;
+  delete proto.attachedCallback;
+  delete proto.detachedCallback;
+  return delete proto.attributeChangedCallback;
+};
+
+var useCapture = true;
+
+var listener = function(event) {
+  if (document.readyState === 'loading') {
+    return;
+  }
+  registerBrowserPluginElement();
+  registerWebViewElement();
+  return window.removeEventListener(event.type, listener, useCapture);
+};
+
+window.addEventListener('readystatechange', listener, true);
+
+module.exports = WebViewImpl;