Merge remote-tracking branch 'refs/remotes/atom/master'

2015-10-10 06:01:01 +03:00 · 2015-10-10 06:01:01 +03:00 · e682dc7544
commit e682dc7544
parent cb22b88e6a 8127bbc992
29 changed files with 809 additions and 90 deletions
--- a/.travis.yml
+++ b/.travis.yml
@ -10,6 +10,7 @@ os:
  - osx
 env:
  - TARGET_ARCH=x64
+osx_image: xcode7

 matrix:
  include:
--- a/atom/app/atom_content_client.cc
+++ b/atom/app/atom_content_client.cc
@ -99,7 +99,7 @@ void AtomContentClient::AddAdditionalSchemes(
 void AtomContentClient::AddPepperPlugins(
    std::vector<content::PepperPluginInfo>* plugins) {
  auto command_line = base::CommandLine::ForCurrentProcess();
-  auto flash_path = command_line->GetSwitchValueNative(
+  auto flash_path = command_line->GetSwitchValuePath(
      switches::kPpapiFlashPath);
  if (flash_path.empty())
    return;
@ -108,7 +108,7 @@ void AtomContentClient::AddPepperPlugins(
      switches::kPpapiFlashVersion);

  plugins->push_back(
-      CreatePepperFlashInfo(base::FilePath(flash_path), flash_version));
+      CreatePepperFlashInfo(flash_path, flash_version));
 }

 }  // namespace atom
--- a/atom/browser/api/atom_api_app.cc
+++ b/atom/browser/api/atom_api_app.cc
@ -20,6 +20,7 @@
 #include "atom/common/native_mate_converters/callback.h"
 #include "atom/common/native_mate_converters/file_path_converter.h"
 #include "atom/common/node_includes.h"
+#include "atom/common/options_switches.h"
 #include "base/command_line.h"
 #include "base/environment.h"
 #include "base/files/file_path.h"
@ -27,6 +28,7 @@
 #include "brightray/browser/brightray_paths.h"
 #include "content/public/browser/client_certificate_delegate.h"
 #include "content/public/browser/gpu_data_manager.h"
+#include "content/public/common/content_switches.h"
 #include "native_mate/dictionary.h"
 #include "native_mate/object_template_builder.h"
 #include "net/ssl/ssl_cert_request_info.h"
@ -301,6 +303,16 @@ namespace {

 void AppendSwitch(const std::string& switch_string, mate::Arguments* args) {
  auto command_line = base::CommandLine::ForCurrentProcess();
+
+  if (switch_string == atom::switches::kPpapiFlashPath ||
+      switch_string == atom::switches::kClientCertificate ||
+      switch_string == switches::kLogNetLog) {
+    base::FilePath path;
+    args->GetNext(&path);
+    command_line->AppendSwitchPath(switch_string, path);
+    return;
+  }
+
  std::string value;
  if (args->GetNext(&value))
    command_line->AppendSwitchASCII(switch_string, value);
--- a/atom/browser/api/atom_api_web_contents.cc
+++ b/atom/browser/api/atom_api_web_contents.cc
@ -31,6 +31,7 @@
 #include "chrome/browser/printing/print_view_manager_basic.h"
 #include "chrome/browser/printing/print_preview_message_handler.h"
 #include "content/common/view_messages.h"
+#include "content/public/browser/browser_plugin_guest_manager.h"
 #include "content/public/browser/favicon_status.h"
 #include "content/public/browser/native_web_keyboard_event.h"
 #include "content/public/browser/navigation_details.h"
@ -51,6 +52,7 @@
 #include "net/url_request/static_http_user_agent_settings.h"
 #include "net/url_request/url_request_context.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
+#include "ui/base/l10n/l10n_util.h"

 #include "atom/common/node_includes.h"

@ -62,9 +64,21 @@ struct PrintSettings {
 };

 void SetUserAgentInIO(scoped_refptr<net::URLRequestContextGetter> getter,
+                      std::string accept_lang,
                      std::string user_agent) {
  getter->GetURLRequestContext()->set_http_user_agent_settings(
-      new net::StaticHttpUserAgentSettings("en-us,en", user_agent));
+      new net::StaticHttpUserAgentSettings(
+          net::HttpUtil::GenerateAcceptLanguageHeader(accept_lang),
+          user_agent));
+}
+
+bool NotifyZoomLevelChanged(
+    double level, content::WebContents* guest_web_contents) {
+  guest_web_contents->SendToAllFrames(
+      new AtomViewMsg_SetZoomLevel(MSG_ROUTING_NONE, level));
+
+  // Return false to iterate over all guests.
+  return false;
 }

 }  // namespace
@ -133,7 +147,6 @@ struct Converter<net::HttpResponseHeaders*> {
      std::string value;
      while (headers->EnumerateHeaderLines(&iter, &key, &value)) {
        key = base::StringToLowerASCII(key);
-        value = base::StringToLowerASCII(value);
        if (response_headers.HasKey(key)) {
          base::ListValue* values = nullptr;
          if (response_headers.GetList(key, &values))
@ -528,6 +541,7 @@ bool WebContents::OnMessageReceived(const IPC::Message& message) {
    IPC_MESSAGE_HANDLER(AtomViewHostMsg_Message, OnRendererMessage)
    IPC_MESSAGE_HANDLER_DELAY_REPLY(AtomViewHostMsg_Message_Sync,
                                    OnRendererMessageSync)
+    IPC_MESSAGE_HANDLER(AtomViewHostMsg_ZoomLevelChanged, OnZoomLevelChanged)
    IPC_MESSAGE_UNHANDLED(handled = false)
  IPC_END_MESSAGE_MAP()

@ -637,8 +651,10 @@ void WebContents::SetUserAgent(const std::string& user_agent) {
  web_contents()->SetUserAgentOverride(user_agent);
  scoped_refptr<net::URLRequestContextGetter> getter =
      web_contents()->GetBrowserContext()->GetRequestContext();
+
+  auto accept_lang = l10n_util::GetApplicationLocale("");
  getter->GetNetworkTaskRunner()->PostTask(FROM_HERE,
-      base::Bind(&SetUserAgentInIO, getter, user_agent));
+      base::Bind(&SetUserAgentInIO, getter, accept_lang, user_agent));
 }

 std::string WebContents::GetUserAgent() {
@ -1033,6 +1049,15 @@ void WebContents::OnRendererMessageSync(const base::string16& channel,
  EmitWithSender(base::UTF16ToUTF8(channel), web_contents(), message, args);
 }

+void WebContents::OnZoomLevelChanged(double level) {
+  auto manager = web_contents()->GetBrowserContext()->GetGuestManager();
+  if (!manager)
+    return;
+  manager->ForEachGuest(web_contents(),
+                        base::Bind(&NotifyZoomLevelChanged,
+                                   level));
+}
+
 // static
 mate::Handle<WebContents> WebContents::CreateFrom(
    v8::Isolate* isolate, content::WebContents* web_contents) {
--- a/atom/browser/api/atom_api_web_contents.h
+++ b/atom/browser/api/atom_api_web_contents.h
@ -247,6 +247,10 @@ class WebContents : public mate::TrackableObject<WebContents>,
                             const base::ListValue& args,
                             IPC::Message* message);

+  // Called when guests need to be notified of
+  // embedders' zoom level change.
+  void OnZoomLevelChanged(double level);
+
  v8::Global<v8::Value> session_;
  v8::Global<v8::Value> devtools_web_contents_;

--- a/atom/browser/default_app/main.js
+++ b/atom/browser/default_app/main.js
@ -18,6 +18,9 @@ for (var i = 0; i < argv.length; i++) {
  if (argv[i] == '--version' || argv[i] == '-v') {
    option.version = true;
    break;
+  } else if (argv[i].match(/^--app=/)) {
+    option.file = argv[i].split('=')[1];
+    break;
  } else if (argv[i] == '--help' || argv[i] == '-h') {
    option.help = true;
    break;
--- a/atom/browser/lib/guest-window-manager.coffee
+++ b/atom/browser/lib/guest-window-manager.coffee
@ -67,7 +67,7 @@ ipc.on 'ATOM_SHELL_GUEST_WINDOW_MANAGER_WINDOW_METHOD', (event, guestId, method,
 ipc.on 'ATOM_SHELL_GUEST_WINDOW_MANAGER_WINDOW_POSTMESSAGE', (event, guestId, message, targetOrigin) ->
  guestContents = BrowserWindow.fromId(guestId)?.webContents
  if guestContents?.getUrl().indexOf(targetOrigin) is 0 or targetOrigin is '*'
-    guestContents.send 'ATOM_SHELL_GUEST_WINDOW_POSTMESSAGE', message, targetOrigin
+    guestContents.send 'ATOM_SHELL_GUEST_WINDOW_POSTMESSAGE', guestId, message, targetOrigin

 ipc.on 'ATOM_SHELL_GUEST_WINDOW_MANAGER_WINDOW_OPENER_POSTMESSAGE', (event, guestId, message, targetOrigin, sourceOrigin) ->
  embedder = v8Util.getHiddenValue event.sender, 'embedder'
--- a/atom/browser/mac/atom_application.mm
+++ b/atom/browser/mac/atom_application.mm
@ -43,11 +43,20 @@
  atom::Browser::Get()->OpenURL(base::SysNSStringToUTF8(url));
 }

+- (bool)voiceOverEnabled {
+  NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
+  [defaults addSuiteNamed:@"com.apple.universalaccess"];
+  [defaults synchronize];
+
+  return [defaults boolForKey:@"voiceOverOnOffKey"];
+}
+
 - (void)accessibilitySetValue:(id)value forAttribute:(NSString *)attribute {
  // Undocumented attribute that VoiceOver happens to set while running.
  // Chromium uses this too, even though it's not exactly right.
  if ([attribute isEqualToString:@"AXEnhancedUserInterface"]) {
-    [self updateAccessibilityEnabled:[value boolValue]];
+    bool enableAccessibility = ([self voiceOverEnabled] && [value boolValue]);
+    [self updateAccessibilityEnabled:enableAccessibility];
  }
  return [super accessibilitySetValue:value forAttribute:attribute];
 }
--- a/atom/common/api/api_messages.h
+++ b/atom/common/api/api_messages.h
@ -30,6 +30,12 @@ IPC_SYNC_MESSAGE_ROUTED2_1(AtomViewHostMsg_Message_Sync,
                           base::ListValue /* arguments */,
                           base::string16 /* result (in JSON) */)

+IPC_MESSAGE_ROUTED1(AtomViewHostMsg_ZoomLevelChanged,
+                    double /* level */)
+
+IPC_MESSAGE_ROUTED1(AtomViewMsg_SetZoomLevel,
+                    double /* level */)
+
 IPC_MESSAGE_ROUTED2(AtomViewMsg_Message,
                    base::string16 /* channel */,
                    base::ListValue /* arguments */)
--- a/atom/common/platform_util_mac.mm
+++ b/atom/common/platform_util_mac.mm
@ -20,7 +20,7 @@ void ShowItemInFolder(const base::FilePath& full_path) {
  DCHECK([NSThread isMainThread]);
  NSString* path_string = base::SysUTF8ToNSString(full_path.value());
  if (!path_string || ![[NSWorkspace sharedWorkspace] selectFile:path_string
-                                        inFileViewerRootedAtPath:nil])
+                                        inFileViewerRootedAtPath:@""])
    LOG(WARNING) << "NSWorkspace failed to select file " << full_path.value();
 }

--- a/atom/renderer/api/atom_api_web_frame.cc
+++ b/atom/renderer/api/atom_api_web_frame.cc
@ -4,11 +4,13 @@

 #include "atom/renderer/api/atom_api_web_frame.h"

+#include "atom/common/api/api_messages.h"
 #include "atom/common/native_mate_converters/callback.h"
 #include "atom/common/native_mate_converters/gfx_converter.h"
 #include "atom/common/native_mate_converters/string16_converter.h"
 #include "atom/renderer/api/atom_api_spell_check_client.h"
 #include "content/public/renderer/render_frame.h"
+#include "content/public/renderer/render_view.h"
 #include "native_mate/dictionary.h"
 #include "native_mate/object_template_builder.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
@ -34,6 +36,10 @@ void WebFrame::SetName(const std::string& name) {
 }

 double WebFrame::SetZoomLevel(double level) {
+  auto render_view = content::RenderView::FromWebView(web_frame_->view());
+  // Notify guests if any for zoom level change.
+  render_view->Send(
+      new AtomViewHostMsg_ZoomLevelChanged(MSG_ROUTING_NONE, level));
  return web_frame_->view()->setZoomLevel(level);
 }

--- a/atom/renderer/atom_renderer_client.cc
+++ b/atom/renderer/atom_renderer_client.cc
@ -6,6 +6,7 @@

 #include <string>

+#include "atom/common/api/api_messages.h"
 #include "atom/common/api/atom_bindings.h"
 #include "atom/common/node_bindings.h"
 #include "atom/common/node_includes.h"
@ -21,11 +22,13 @@
 #include "content/public/renderer/render_frame.h"
 #include "content/public/renderer/render_frame_observer.h"
 #include "content/public/renderer/render_thread.h"
+#include "ipc/ipc_message_macros.h"
 #include "third_party/WebKit/public/web/WebCustomElement.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebPluginParams.h"
 #include "third_party/WebKit/public/web/WebKit.h"
 #include "third_party/WebKit/public/web/WebRuntimeFeatures.h"
+#include "third_party/WebKit/public/web/WebView.h"

 #if defined(OS_WIN)
 #include <shlobj.h>
@ -64,6 +67,22 @@ class AtomRenderFrameObserver : public content::RenderFrameObserver {
        render_frame()->GetWebFrame(), context);
  }

+  bool OnMessageReceived(const IPC::Message& message) {
+    bool handled = true;
+    IPC_BEGIN_MESSAGE_MAP(AtomRenderFrameObserver, message)
+      IPC_MESSAGE_HANDLER(AtomViewMsg_SetZoomLevel, OnSetZoomLevel)
+      IPC_MESSAGE_UNHANDLED(handled = false)
+    IPC_END_MESSAGE_MAP()
+
+    return handled;
+  }
+
+  void OnSetZoomLevel(double level) {
+    auto view = render_frame()->GetWebFrame()->view();
+    if (view)
+      view->setZoomLevel(level);
+  }
+
 private:
  AtomRendererClient* renderer_client_;

--- a/docs-translations/es/README.md
+++ b/docs-translations/es/README.md
@ -1,32 +1,33 @@
 ## Guías

-* [Distribución de aplicaciones](tutorial/application-distribution.md)
-* [Empaquetamiento de aplicaciones](tutorial/application-packaging.md)
-* [Utilizando módulos nativos](tutorial/using-native-node-modules.md)
-* [Depurando el proceso principal](tutorial/debugging-main-process.md)
+* [Platfaformas Soportadas](tutorial/supported-platforms.md)
+* [Distribución de la Aplicacion](tutorial/application-distribution.md)
+* [Empaquetamiento de la Aplicacion](tutorial/application-packaging.md)
+* [Utilizando Módulos Node Nativos](tutorial/using-native-node-modules.md)
+* [Depurando el Proceso Principal](tutorial/debugging-main-process.md)
 * [Utilizando Selenium y WebDriver](tutorial/using-selenium-and-webdriver.md)
 * [Extensión DevTools](tutorial/devtools-extension.md)
-* [Utilizando el plugin pepper flash](tutorial/using-pepper-flash-plugin.md)
+* [Utilizando el plugin Pepper Flash](tutorial/using-pepper-flash-plugin.md)

 ## Tutoriales

-* [Introducción](../../docs/tutorial/quick-start.md)
-* [Integración con el entorno de escritorio](../../docs/tutorial/desktop-environment-integration.md)
-* [Detección del evento en línea/fuera de línea](../../docs/tutorial/online-offline-events.md)
+* [Introducción](tutorial/quick-start.md)
+* [Integración con el entorno de escritorio](tutorial/desktop-environment-integration.md)
+* [Detección del evento en línea/fuera de línea](tutorial/online-offline-events.md)

-## API
+## Referencias a la API

-* [Sinopsis](../../docs/api/synopsis.md)
-* [Proceso](../../docs/api/process.md)
-* [Parámetros CLI soportados (Chrome)](../../docs/api/chrome-command-line-switches.md)
+* [Sinopsis](api/synopsis.md)
+* [Proceso](api/process.md)
+* [Parámetros CLI soportados (Chrome)](api/chrome-command-line-switches.md)

-Elementos DOM customizados:
+### Elementos DOM personalizados:

 * [Objeto `File`](../../docs/api/file-object.md)
 * [Etiqueta `<webview>`](../../docs/api/web-view-tag.md)
 * [Función `window.open`](../../docs/api/window-open.md)

-Módulos del proceso principal:
+### Módulos del Proceso Principal:

 * [app](../../docs/api/app.md)
 * [auto-updater](../../docs/api/auto-updater.md)
@ -34,21 +35,23 @@ Módulos del proceso principal:
 * [content-tracing](../../docs/api/content-tracing.md)
 * [dialog](../../docs/api/dialog.md)
 * [global-shortcut](../../docs/api/global-shortcut.md)
-* [ipc (main process)](../../docs/api/ipc-main-process.md)
+* [ipc (proceso principal)](../../docs/api/ipc-main-process.md)
 * [menu](../../docs/api/menu.md)
 * [menu-item](../../docs/api/menu-item.md)
 * [power-monitor](../../docs/api/power-monitor.md)
 * [power-save-blocker](../../docs/api/power-save-blocker.md)
 * [protocol](../../docs/api/protocol.md)
+* [session](../../docs/api/session.md)
+* [web-contents](../../docs/api/web-contents.md)
 * [tray](../../docs/api/tray.md)

-Módulos del renderer (página web):
+### Módulos del proceso de renderizado (Página Web):

-* [ipc (renderer)](../../docs/api/ipc-renderer.md)
+* [ipc (renderizador)](../../docs/api/ipc-renderer.md)
 * [remote](../../docs/api/remote.md)
 * [web-frame](../../docs/api/web-frame.md)

-Módulos de ambos procesos:
+### Módulos de Ambos Procesos:

 * [clipboard](../../docs/api/clipboard.md)
 * [crash-reporter](../../docs/api/crash-reporter.md)
@ -58,11 +61,11 @@ Módulos de ambos procesos:

 ## Desarrollo

-* [Guía de estilo](../../docs/development/coding-style.md)
-* [Estructura de directorio](../../docs/development/source-code-directory-structure.md)
-* [Diferencias técnicas con NW.js (anteriormente conocido como node-webkit)](../../docs/development/atom-shell-vs-node-webkit.md)
-* [Sistema de compilación](../../docs/development/build-system-overview.md)
-* [Instrucciones de compilación (Mac)](../../docs/development/build-instructions-osx.md)
-* [Instrucciones de compilación (Windows)](../../docs/development/build-instructions-windows.md)
-* [Instrucciones de compilación (Linux)](../../docs/development/build-instructions-linux.md)
-* [Configurando un servidor de símbolos en el depurador](../../docs/development/setting-up-symbol-server.md)
+* [Guía de Estilo](development/coding-style.md)
+* [Estructura de los directorios del Código Fuente](../../development/source-code-directory-structure.md)
+* [Diferencias Técnicas con NW.js (anteriormente conocido como node-webkit)](../../development/atom-shell-vs-node-webkit.md)
+* [Repaso del Sistema de Compilación](../../development/build-system-overview.md)
+* [Instrucciones de Compilación (Mac)](../../development/build-instructions-osx.md)
+* [Instrucciones de Compilación (Windows)](../../development/build-instructions-windows.md)
+* [Instrucciones de Compilación (Linux)](../../development/build-instructions-linux.md)
+* [Configurando un Servidor de Símbolos en el depurador](../../development/setting-up-symbol-server.md)
--- a/docs-translations/es/api/chrome-command-line-switches.md
+++ b/docs-translations/es/api/chrome-command-line-switches.md
@ -0,0 +1,119 @@
+# Parámetros CLI soportados (Chrome)
+
+Esta página lista las líneas de comandos usadas por el navegador Chrome que también son 
+soportadas por Electron. Puedes usar [app.commandLine.appendSwitch][append-switch] para
+anexarlas en el script principal de tu aplicación antes de que el evento [ready][ready] del
+modulo [app][app] sea emitido:
+
+```javascript
+var app = require('app');
+app.commandLine.appendSwitch('remote-debugging-port', '8315');
+app.commandLine.appendSwitch('host-rules', 'MAP * 127.0.0.1');
+
+app.on('ready', function() {
+  // Your code here
+});
+```
+
+## --client-certificate=`path`
+
+Establece el `path` del archivo de certificado del cliente.
+
+## --ignore-connections-limit=`domains`
+
+Ignora el límite de conexiones para la lista de `domains` separados por `,`.
+
+## --disable-http-cache
+
+Deshabilita la cacheé del disco para las peticiones HTTP.
+
+## --remote-debugging-port=`port`
+
+Habilita la depuración remota a través de HTTP en el puerto especificado.
+
+## --proxy-server=`address:port`
+
+Usa un servidor proxy especificado, que sobreescribe la configuración del sistema.
+Este cambio solo afecta peticiones HTTP y HTTPS.
+
+## --proxy-pac-url=`url`
+
+Utiliza el script PAC en la `url` especificada.
+
+## --no-proxy-server
+
+No usa un servidor proxy y siempre establece conexiones directas. Anula cualquier 
+otra bandera de servidor proxy bandera que se pase.
+
+## --host-rules=`rules`
+
+Una lista separada por comas de `rules` (reglas) que controlan cómo se asignan los
+nombres de host.
+
+Por ejemplo:
+
+* `MAP * 127.0.0.1` Obliga a todos los nombres de host a ser asignados a 127.0.0.1
+* `MAP *.google.com proxy` Obliga todos los subdominios google.com a resolverse con
+  "proxy".
+* `MAP test.com [::1]:77` Obliga a  resolver "test.com" con un bucle invertido de IPv6. 
+  También obligará a que el puerto de la dirección respuesta sea 77.
+* `MAP * baz, EXCLUDE www.google.com` Reasigna todo a "baz", excepto a "www.google.com".
+
+Estas asignaciones especifican el host final en una petición de red (Anfitrión de la conexión TCP
+y de resolución de conexión directa, y el `CONNECT` en una conexión proxy HTTP, y el host final de 
+la conexión proxy `SOCKS`).
+
+## --host-resolver-rules=`rules`
+
+Como `--host-rules` pero estas `rules` solo se aplican al solucionador.
+
+[app]: app.md
+[append-switch]: app.md#appcommandlineappendswitchswitch-value
+[ready]: app.md#event-ready
+
+## --ignore-certificate-errors
+
+Ignora errores de certificado relacionados.
+
+## --ppapi-flash-path=`path`
+
+Asigna la ruta `path` del pepper flash plugin.
+
+## --ppapi-flash-version=`version`
+
+Asigna la versión `version` del pepper flash plugin.
+
+## --log-net-log=`path`
+
+Permite guardar y escribir eventos de registros de red en `path`.
+
+## --ssl-version-fallback-min=`version`
+
+Establece la versión mínima de SSL/TLS ("tls1", "tls1.1" o "tls1.2") que 
+el repliegue de TLC aceptará.
+
+## --enable-logging
+
+Imprime el registro de Chromium en consola.
+
+Este cambio no puede ser usado en `app.commandLine.appendSwitch` ya que se analiza antes de que la 
+aplicación del usuario este cargada.
+
+## --v=`log_level`
+
+Da el maximo nivel activo de V-logging por defecto; 0 es el predeterminado. Valores positivos
+son normalmente usados para los niveles de V-logging.
+
+Este modificador sólo funciona cuando también se pasa `--enable-logging`.
+
+## --vmodule=`pattern`
+
+Da los niveles máximos de V-logging por módulo para sobreescribir el valor dado por 
+`--v`. Ej. `my_module=2,foo*=3` cambiaria el nivel de registro para todo el código
+el archivos de origen `my_module.*` y `foo*.*`.
+
+Cualquier patron que contiene un slash o un slash invertido será probado contra toda la ruta
+y no sólo con el módulo. Ej. `*/foo/bar/*=2` cambiaría el nivel de registro para todo el código
+en los archivos origen bajo un directorio `foo/bar`.
+
+Este modificador sólo funciona cuando también se pasa `--enable-logging`.
--- a/docs-translations/es/api/process.md
+++ b/docs-translations/es/api/process.md
@ -0,0 +1,47 @@
+# process
+
+El objeto `process` en Electron tiene las siguientes diferencias con respecto 
+al node convencional: 
+
+* `process.type` String - El tipo del proceso puede ser `browser` (ej. proceso
+   principal) o `renderer`.
+* `process.versions['electron']` String - Versión de Electron.
+* `process.versions['chrome']` String - Versión de Chromium.
+* `process.resourcesPath` String - Ruta al código fuente JavaScript.
+
+## Events
+
+### Event: 'loaded'
+
+Se emite cuando Electron ha cargado su script de inicialización interna y
+está comenzando a cargar la página web o el script principal.
+
+Puede ser usado por el script precargado para añadir de nuevo los símbolos globales 
+de Node eliminados, al alcance global cuando la integración de Node está apagada:
+
+```js
+// preload.js
+var _setImmediate = setImmediate;
+var _clearImmediate = clearImmediate;
+process.once('loaded', function() {
+  global.setImmediate = _setImmediate;
+  global.clearImmediate = _clearImmediate;
+});
+```
+
+## Methods
+
+El objeto `process` tiene los siguientes métodos:
+
+### `process.hang`
+
+Interrumpe el hilo principal del proceso actual.
+
+
+### process.setFdLimit(maxDescriptors) _OS X_ _Linux_
+
+* `maxDescriptors` Integer
+
+Establece el límite dinámico del descriptor del archivo en `maxDescriptors`
+o en el límite estricto del Sistema Operativo, el que sea menor para el 
+proceso actual.
--- a/docs-translations/es/api/synopsis.md
+++ b/docs-translations/es/api/synopsis.md
@ -0,0 +1,47 @@
+# Synopsis
+
+Todos los [Módulos integrados de Node.js](http://nodejs.org/api/) se encuentran
+disponibles en Electron y módulos de terceros son támbien totalmente compatibles
+(incluyendo los [módulos nativos](../tutorial/using-native-node-modules.md)).
+
+Electron también provee algunos módulos integrados adicionales para desarrollar 
+aplicaciones nativas de escritorio. Algunos módulos sólo se encuentran disponibles
+en el proceso principal, algunos sólo en el proceso renderer (pagina web), y
+algunos pueden ser usados en ambos procesos.
+
+La regla básica es: Si un módulo es 
+[GUI](https://es.wikipedia.org/wiki/Interfaz_gráfica_de_usuario) o de bajo nivel, 
+entonces solo estará disponible en el proceso principal. Necesitas familiarizarte 
+con el concepto de [scripts para proceso principal vs scripts para proceso renderer]
+(../tutorial/quick-start.md#the-main-process) para ser capaz de usar esos módulos.
+
+El script del proceso principal es como un script normal de Node.js:
+
+```javascript
+var app = require('app');
+var BrowserWindow = require('browser-window');
+
+var window = null;
+
+app.on('ready', function() {
+  window = new BrowserWindow({width: 800, height: 600});
+  window.loadUrl('https://github.com');
+});
+```
+
+El proceso renderer no es diferente de una página web normal, excepto por la 
+capacidad extra de utilizar módulos de node:
+
+```html
+<!DOCTYPE html>
+<html>
+  <body>
+    <script>
+      var remote = require('remote');
+      console.log(remote.require('app').getVersion());
+    </script>
+  </body>
+</html>
+```
+
+Para ejecutar tu aplicación, lee [Ejecutar la aplicación](../tutorial/quick-start.md#run-your-app).
--- a/docs-translations/es/styleguide.md
+++ b/docs-translations/es/styleguide.md
@ -0,0 +1,100 @@
+# Gúia de estilo de Electron
+
+Encuentra el apartado correcto para cada tarea: [leer la documentación de Electron](#reading-electron-documentation)
+o [escribir documentación para Electron](#writing-electron-documentation).
+
+## Escribir Documentación para Electron
+
+Estas son las maneras en las que construimos la documentación de Electron.
+
+- Máximo un título `h1` por página.
+- Utilizar `bash` en lugar de `cmd` en los bloques de código (por el resaltado
+  de sintaxis).
+- Los títulos `h1` en el documento deben corresponder al nombre del objeto
+  (ej. `browser-window` → `BrowserWindow`).
+  - Archivos separados por guiones, mas sin embargo, es correcto.
+- No subtítulos seguidos por otros subtítulos, añadir por lo menos un enunciado
+  de descripción.
+- Métodos de cabecera son delimitados con apóstrofes: `codigo`.
+- Cabeceras de Eventos son delimitados con 'comillas' simples.
+- No generar listas de mas de dos niveles (debido al renderizador de Markdown
+  desafortunadamente).
+- Agregar títulos de sección: Eventos, Métodos de Clases y Métodos de Instancia.
+- Utilizar 'deberá' en lugar de 'debería' al describir resultados.
+- Eventos y Métodos son cabeceras `h3`.
+- Argumentos opcionales escritos como `function (required[, optional])`.
+- Argumentos opcionales son denotados cuando se llaman en listas.
+- Delimitador de línea de 80-columnas.
+- Métodos específicos de Plataformas son denotados en italicas seguidas por la cabecera del método.
+  - ```### `method(foo, bar)` _OS X_```
+- Preferir 'en el ___ proceso' en lugar de 'sobre el'
+
+### Traducciones de la Documentación
+
+Traducciones de documentos de Electron se encuentran dentro del folder
+`docs-translations`.
+
+Para agregar otro set (o un set parcial):
+
+- Crear un subdirectorio nombrado igual a la abreviación del lenguaje.
+- Dentro de ese subdirectorio, duplicar el directorio de `docs`, manteniendo los
+  mismos nombres de directorios y archivos.
+- Traducir los archivos.
+- Actualizar el `README.md` dentro del subdirectorio del lenguaje apuntando a
+  los archivos que has traducido.
+- Agregar un enlace al folder de tu traducción en la sección principal Electron
+[README](https://github.com/atom/electron#documentation-translations).
+
+## Leyendo la Documentación de Electron
+
+Estos son algunos consejos para entender la syntaxis de la documentación de
+Electron.
+
+### Métodos
+
+Un ejemplo de la documentación del [método](https://developer.mozilla.org/en-US/docs/Glossary/Method):
+
+---
+
+`methodName(required[, optional]))`
+
+* `require` String, **required**
+* `optional` Integer
+
+---
+
+El nombre del método es seguido por los argumentos que recibe. Argumentos
+opcionales son denotados por corchetes rodeados por el argumento opcional y la
+coma requerida si el argumento opcional fuera seguido por otro argumento.
+
+Debajo del método se encuentra mas información detallada de cada uno de los
+argumentos. El tipo de argumento es denotado por los tipos comúnes:
+[`String`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String),
+[`Number`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number),
+[`Object`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object),
+[`Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)
+o un tipo personalizado como el [`webContent`](api/web-content.md) de Electron.
+
+### Eventos
+
+Un ejemplo de documentación del [evento](https://developer.mozilla.org/en-US/docs/Web/API/Event):
+
+---
+
+Event: 'wake-up'
+
+Returns:
+
+* `time` String
+
+---
+
+El evento es una cadena que es utilizada luego de un método observador `.on`. Si
+regresa un valor, el y su tipo son denotados abajo. Si se estaba a la escucha y
+respondió a este evento se debería ver así:
+
+```javascript
+Alarm.on('wake-up', function(time) {
+  console.log(time)
+})
+```
--- a/docs-translations/es/tutorial/application-distribution.md
+++ b/docs-translations/es/tutorial/application-distribution.md
@ -1,10 +1,11 @@
-# Distribución de aplicaciones
+# Distribución de la Aplicación

-Para distribuir tu aplicación con Electron, debes nombrar al directorio de tu aplicación
-como `app`, y ponerlo bajo el directorio de recursos de Electron (en OSX es `Electron.app/Contents/Resources/`,
-en Linux y Windows es `resources/`):
+Para distribuir tu aplicación con Electron, el directorio que contiene la
+aplicación deberá llamarse `app`, y ser colocado debajo del directorio de
+recursos de Electron (en OSX es `Electron.app/Contents/Resources/`, en Linux y
+Windows es `resources/`), de esta forma:

-En OSX:
+En OS X:

 ```text
 electron/Electron.app/Contents/Resources/app/
@ -22,18 +23,19 @@ electron/resources/app
 └── index.html
 ```

-Posteriormente ejecutas `Electron.app` (o `electron` en Linux, `electron.exe` en Windows),
-y Electron iniciará la aplicación.  El directorio `electron` será la distribución que recibirán los usuarios finales.
+Luego ejecutar `Electron.app` (o `electron` en Linux, `electron.exe` en Windows),
+y Electron será iniciado como tu aplicación. El directorio `electron` será
+entonces tu distribución que recibirán los usuarios finales.

-## Empaquetando tu aplicación como un archivo
+## Empaquetando tu aplicación en un archivo

-Además de copiar todos tus archivos fuente para la distribución, también puedes
-empaquetar tu aplicación como un archivo [asar](https://github.com/atom/asar)
-y de esta forma evitar la exposición del código fuente de tu aplicación a los usuarios.
+Además de distribuir tu aplicación al copiar todos los archivos de código fuente,
+también puedes empaquetar tu aplicación como un archivo [asar](https://github.com/atom/asar)
+y de esta forma evitar exponer del código fuente de tu aplicación a los usuarios.

-Para usar un archivo `asar` en reemplazo de la carpeta `app`, debes renombrar
-el archivo a `app.asar`, y ponerlo bajo el directorio de recursos de Electron (como arriba),
-Electron intentará leer el archivo y ejecutar la aplicación desde él.
+Para utilizar un archivo `asar` en reemplazo del directorio `app`, debes de
+renombrar el archivo a `app.asar`, y colocarlo por debajo el directorio de recursos
+de Electron (ver en seguida), Electron intentará leer el archivo y arrancar desde el.

 En OS X:

@ -49,30 +51,33 @@ electron/resources/
 └── app.asar
 ```

-Más detalles en [Empaquetamiento de aplicaciones](application-packaging-es.md).
+Más detalles en [Empaquetado de Aplicaciones](application-packaging.md).

-## Rebranding con binarios descargados
+## Redefinición con Binarios Descargados

-Luego de empaquetar tu aplicación con Electron, podría ser útil agregar tu marca
-antes de realizar la distribución.
+Luego de empaquetar tu aplicación en Electron, querrás redefinir Electron antes
+de distribuirlo a los usuarios.

 ### Windows

-Puedes renombrar `electron.exe` a cualquier nombre que desees, y editar su ícono y otras informaciones
-con herramientas como [rcedit](https://github.com/atom/rcedit) o [ResEdit](http://www.resedit.net).
+Puedes renombrar `electron.exe` a cualquier nombre que desees, y editar su ícono
+y otra información con herramientas como [rcedit](https://github.com/atom/rcedit)
+o [ResEdit](http://www.resedit.net).

-### OS X
+### OSX

-Puedes renombrar `Electron.app` a cualquier nombre que desees. También debes modificar los campos 
-`CFBundleDisplayName`, `CFBundleIdentifier` y `CFBundleName` en los siguientes archivos:
+Puedes renombrar `Electron.app` a cualquier nombre que desees, y tendrás que
+renombrar los campos `CFBundleDisplayName`, `CFBundleIdentifier` y `CFBundleName`
+en los siguientes archivos:

 * `Electron.app/Contents/Info.plist`
 * `Electron.app/Contents/Frameworks/Electron Helper.app/Contents/Info.plist`

-También puedes renombrar el helper de la aplicación para evitar que aparezca como  `Electron Helper`
-en el Monitor de Actividades.
+También puedes renombrar el helper de la aplicación para evitar que aparezca
+como `Electron Helper` en el Monitor de Actividades. Pero asegurate de renombrar
+el nombre de archivo del ejecutable.

-La estructura de una aplicación renombrada sería así:
+La estructura de una aplicación renombrada será:

 ```
 MyApp.app/Contents
@ -98,17 +103,19 @@ MyApp.app/Contents

 Puedes renombrar el ejectuable `electron` a cualquier nombre que desees.

-## Rebranding desde el código fuente de Electron
+## Redefinición mediante la recompilación de Electron desde el código fuente

-También es posible agregar tu marca a Electron mediante un build personalizado.
-Para realizar esto debes modificar el archivo `atom.gyp`.
+También es posible redefinir Electron cambiando el nombre del producto y
+compilandolo desde sus fuentes. Para realizar esto necesitas modificar el
+archivo `atom.gyp` y realizar una compilación desde cero.

 ### grunt-build-atom-shell

-La modificación del código de Electron para agregar tu marca puede resultar complicada, una tarea Grunt
-se ha creado para manejar esto de forma automatizada:
-
+La modificación a mano del código de Electron y su compilación puede resultar
+complicada, por lo cual se ha generado una tarea Grunt para manejar esto de
+forma automaticamente:
 [grunt-build-atom-shell](https://github.com/paulcbetts/grunt-build-atom-shell).

-Esta tarea se encargará de modificar el archivo `.gyp`, compilar el código
-y reconstruir los módulos nativos de la aplicación para que coincidan con el nuevo nombre.
+Esta tarea se encargará de modificar el archivo `.gyp`, compilar el código desde
+las fuentes, y luego reconstruir los módulos nativos de la aplicación para que
+coincidan con el nuevo nombre del ejecutable.
--- a/docs-translations/ko-KR/api/auto-updater.md
+++ b/docs-translations/ko-KR/api/auto-updater.md
@ -2,9 +2,9 @@

 **이 모듈은 현재 OS X에서만 사용할 수 있습니다.**

-Windows 어플리케이션 인스톨러를 생성하려면 [atom/grunt-electron-installer](https://github.com/atom/grunt-electron-installer)를 참고하세요.
+Windows 인스톨러를 생성하려면 [atom/grunt-electron-installer](https://github.com/atom/grunt-electron-installer)를 참고하세요.

-`auto-updater` 모듈은 [Squirrel.Mac](https://github.com/Squirrel/Squirrel.Mac) 프레임워크의 간단한 Wrapper입니다.
+`auto-updater` 모듈은 [Squirrel.Mac](https://github.com/Squirrel/Squirrel.Mac) 프레임워크의 간단한 wrapper 입니다.

 Squirrel.Mac은 업데이트 설치를 위해 `.app` 폴더에
 [codesign](https://developer.apple.com/library/mac/documentation/Darwin/Reference/ManPages/man1/codesign.1.html)
@ -14,23 +14,23 @@ Squirrel.Mac은 업데이트 설치를 위해 `.app` 폴더에

 Squirrel은 어플리케이션이 **안전하고 투명한 업데이트**를 제공할 수 있도록 하는데 초점이 맞춰진 OS X 프레임워크입니다.

-Squirrel은 사용자에게 어플리케이션의 업데이트를 알릴 필요 없이 서버가 지시하는 버전을 받아온 후 자동으로 업데이트합니다.
-이 기능을 사용하면 Squirrel을 통해 클라이언트의 어플리케이션을 지능적으로 업데이트 할 수 있습니다.
+Squirrel은 사용자에게 어플리케이션의 업데이트를 알릴 필요 없이 자동으로 서버가 지시하는 버전을 받아 어플리케이션을 업데이트합니다.
+지능적으로 클라이언트 어플리케이션을 업데이트 할 수 있습니다.

-또한 요청시 커스텀 헤더 또는 요청 본문에 인증 정보를 포함시킬 수 있습니다.
-서버에선 이러한 요청을 분류 처리하여 적당한 업데이트를 제공할 수 있습니다.
+업데이트 요청은 커스텀 헤더 또는 요청 본문에 인증 정보를 포함시킬 수 있습니다.
+이에 따라 서버에선 이러한 요청을 분석 처리하여 사용자에게 적당한 업데이트를 제공할 수 있습니다.

 Squirrel JSON 업데이트 요청시 처리는 반드시 어떤 업데이트가 필요한지 요청의 기준에 맞춰 동적으로 생성되어야 합니다.
-Squirrel은 사용해야 하는 업데이트 선택하는 과정을 서버에 의존합니다. [서버 지원](#server-support)을 참고하세요.
+Squirrel은 사용해야 하는 업데이트 선택하는 과정을 서버에 의존합니다. [서버 지원](#서버-지원)을 참고하세요.

 Squirrel의 인스톨러는 오류에 관대하게 설계되었습니다. 그리고 업데이트가 유효한지 확인합니다.

 ## 업데이트 요청

-Squirrel은 업데이트 확인을 위해 클라이언트 어플리케이션의 요청은 무시합니다.
-Squirrel은 응답을 분석해야 할 책임이 있기 때문에 `Accept: application/json`이 요청 헤더에 추가됩니다.
+Squirrel은 클라이언트 어플리케이션이 업데이트 확인을 위해 제공하는 요청을 무시합니다.
+Squirrel이 응답을 분석할 수 있어야하기 때문에 요청 헤더에 `Accept: application/json` 헤더가 추가됩니다.

-업데이트 응답과 본문 포맷에 대한 요구 사항은 [Server Support](#server-support)를 참고하세요.
+업데이트 응답과 본문 포맷에 대한 요구 사항은 [서버 지원](#서버-지원)를 참고하세요.

 업데이트 요청에는 서버가 해당 어플리케이션이 어떤 버전을 사용해야 하는지 판단하기 위해 *반드시* 버전 식별자를 포함시켜야 합니다.
 추가로 OS 버전, 사용자 이름 같은 다른 식별 기준을 포함하여 서버에서 적합한 어플리케이션을 제공할 수 있도록 할 수 있습니다.
@ -46,7 +46,7 @@ autoUpdater.setFeedUrl('http://mycompany.com/myapp/latest?version=' + app.getVer

 ## 서버 지원

-업데이트를 제공하는 서버는 반드시 클라이언트로부터 받은 [Update Request](#update-requests)를 기반으로 업데이트를 처리할 수 있어야 합니다.
+업데이트를 제공하는 서버는 반드시 클라이언트로부터 받은 [업데이트 요청](#업데이트-요청)을 기반으로 업데이트를 처리할 수 있어야 합니다.

 만약 업데이트 요청이 들어오면 서버는 반드시 [200 OK](http://tools.ietf.org/html/rfc2616#section-10.2.1) 상태 코드를 포함한
 [업데이트 JSON](#update-json-format)을 본문으로 보내야 합니다.
--- a/docs-translations/pt-BR/tutorial/quick-start.md
+++ b/docs-translations/pt-BR/tutorial/quick-start.md
@ -0,0 +1,192 @@
+# Introdução
+
+Electron permite criar aplicações desktop com puro JavaScript através de
+um runtime com APIs ricas e nativas. Você pode ver isso como uma variação do
+runtime do io.js que é focado em aplicações desktop em vez de web servers.
+
+Isso não significa que o Electron é uma ligação em JavaScript para blibliotécas
+de interface gráfica (GUI). Em vez disso, Electron usa páginas web como 
+interface gráfica, então você pode ver isso também como um navegador Chromium
+mínimo, controlado por JavaScript.
+
+### Processo Principal
+
+No Electron, o processo que executa o script principal (main) do `package.json` 
+é chamado __processo principal__. O script que roda no processo principal pode
+mostrar uma GUI criando páginas web.
+
+### Processo Renderizador
+
+Desde que o Electron usa o Chromium para mostrar as páginas web, a arquitetura
+multi-processo do Chromium também é usada. Cada página web no Electron roda em
+seu próprio processo, o que é chamado de __processo renderizador__.
+
+Em navegadores comuns, as páginas web normalmente rodam em um ambiente em sandbox
+e não tem permissão de acesso para recursos nativos. Usuários Electron, entretanto,
+tem o poder de usar as APIs do io.js nas páginas web, permitindo interações de baixo
+nível no sistema operacional.
+
+### Diferenças Entre o Processo Principal e o Processo Renderizador
+
+O processo principal cria as páginas web criando instâncias de `BrowserWindow`.
+Cada instância de `BrowserWindow` roda a página web em seu próprio processo renderizador.
+Quando uma instância de `BrowserWindow` é destruída, o processo renderizador
+correspondente também é finalizado.
+
+O processo principal gerência todas as páginas web de seus processos renderizadores
+correspondentes. Cada processo renderizador é isolado e toma conta de sua
+respectiva página web.
+
+Nas páginas web, chamar APIs nativas relacionadas à GUI não é permitido porque
+gerênciar recursos de GUI em páginas web é muito perigoso e torna fácil o vazamento de 
+recursos. Se você quer realizar operações com GUI em páginas web, o processo
+renderizador da página web deve se comunicar com o processo principal para requisitar
+que o processo principal realize estas operações.
+
+No Electron, nós fornecemos o módulo [ipc](../../../docs/api/ipc-renderer.md) para
+comunicação entre o processo principal e o processo renderizador. Que é também um
+módulo [remoto](../../../docs/api/remote.md) para comunicação RPC.
+
+## Crie seu Primeiro App Electron
+
+Geralmente, um app Electron é estruturado assim:
+
+```text
+your-app/
+├── package.json
+├── main.js
+└── index.html
+```
+
+O formato de `package.json` é exatamente o mesmo que os dos módulos do Node, e
+e o script especificado pelo campo `main` é o script de inicialização do seu app,
+que irá executar o processo principal. Um exemplo do seu `package.json` deve parecer
+com isso:
+
+```json
+{
+  "name"    : "your-app",
+  "version" : "0.1.0",
+  "main"    : "main.js"
+}
+```
+
+__Nota__: Se o campo `main` não estiver presente no `package.jso`, o Electron irá 
+tentar carregar um `index.js`
+
+O `main.js` deve criar as janelas e os manipuladores de eventos do sistema, um típico
+exemplo:
+
+```javascript
+var app = require('app');  // Módulo para controlar o ciclo de vida do app.
+var BrowserWindow = require('browser-window');  // Módulo para criar uma janela nativa do browser.
+
+// Relate falhas para nossos servidores.
+require('crash-reporter').start();
+
+// Mantenha uma referência global para o objeto window, se você não o fizer,
+// a janela será fechada automaticamente quando o objeto JavaScript for 
+// coletado pelo garbage collector.
+var mainWindow = null;
+
+// Sair quando todas as janelas estiverem fechadas.
+app.on('window-all-closed', function() {
+  // No OS X é comum para as aplicações na barra de menu
+  // continuarem ativas até que o usuário saia explicitamente
+  // com Cmd + Q
+  if (process.platform != 'darwin') {
+    app.quit();
+  }
+});
+
+// Esse método irá ser chamado quando o Electron finalizar
+// a inicialização e estiver pronto para criar janelas do browser.
+app.on('ready', function() {
+  // Criar a janela do navegador.
+  mainWindow = new BrowserWindow({width: 800, height: 600});
+
+  // e carrega o index.html do app.
+  mainWindow.loadUrl('file://' + __dirname + '/index.html');
+
+  // Abre os DevTools.
+  mainWindow.openDevTools();
+
+  // Emitido quando a janela é fechada.
+  mainWindow.on('closed', function() {
+    // Desfaz a referência para o objeto window, normalmente você deverá
+    // guardar as janelas em um array se seu app suportar várias janelas,
+    // essa é a hora que você deverá deletar o elemento correspondente.
+    mainWindow = null;
+  });
+});
+```
+
+Finalmente o `index.html` é a página web que você quer mostrar:
+
+```html
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="UTF-8">
+    <title>Hello World!</title>
+  </head>
+  <body>
+    <h1>Hello World!</h1>
+    Nós estamos usando io.js <script>document.write(process.version)</script>
+    e Electron <script>document.write(process.versions['electron'])</script>.
+  </body>
+</html>
+```
+
+## Execute seu App
+
+Uma vez que você criou seus arquivos `main.js`, `index.html, e `package.json` iniciais,
+você provavelmente vai querer tentar executar seu app localmente para testa-lo a ter
+certeza que funciona como você espera.
+
+### electron-prebuilt
+
+Se você instalou `electron-prebuilt` globalmente com `npm`, então você irá precisar apenas
+rodar o seguinte comando no diretório fonte do seu app:
+
+```bash
+electron .
+```
+
+Se você o instalou localmente, então execute:
+
+```bash
+./node_modules/.bin/electron .
+```
+
+### Binário do Electron Baixado Manualmente
+
+Se você baixou o Electron manualmente, você pode também usar o binário incluído para
+executar seu app diretamente.
+
+#### Windows
+
+```bash
+$ .\electron\electron.exe your-app\
+```
+
+#### Linux
+
+```bash
+$ ./electron/electron your-app/
+```
+
+#### OS X
+
+```bash
+$ ./Electron.app/Contents/MacOS/Electron your-app/
+```
+
+`Electron.app` aqui é uma parte do pacote de lançamento do Electron, você pode baixa-lo
+[aqui](https://github.com/atom/electron/releases).
+
+### Executar como uma distribuição
+
+Depois de terminar seu app, você pode criar uma distribuição seguindo o guia 
+[Application Distribution](./application-distribution.md) e então executar o app
+empacotado.
--- a/docs/api/global-shortcut.md
+++ b/docs/api/global-shortcut.md
@ -16,7 +16,7 @@ app.on('ready', function() {
  // Register a 'ctrl+x' shortcut listener.
  var ret = globalShortcut.register('ctrl+x', function() {
    console.log('ctrl+x is pressed');
-  })
+  });

  if (!ret) {
    console.log('registration failed');
@ -62,4 +62,4 @@ Unregisters the global shortcut of `accelerator`.

 ### `globalShortcut.unregisterAll()`

-Unregisters all the global shortcuts.
+Unregisters all of the global shortcuts.
--- a/docs/api/protocol.md
+++ b/docs/api/protocol.md
@ -140,7 +140,7 @@ which sends a file as a response.
 Intercepts `scheme` protocol and uses `handler` as the protocol's new handler
 which sends a `String` as a response.

-## `protocol.interceptBufferProtocol(scheme, handler[, completion])`
+### `protocol.interceptBufferProtocol(scheme, handler[, completion])`

 * `scheme` String
 * `handler` Function
@ -149,7 +149,7 @@ which sends a `String` as a response.
 Intercepts `scheme` protocol and uses `handler` as the protocol's new handler
 which sends a `Buffer` as a response.

-## `protocol.interceptHttpProtocol(scheme, handler[, completion])`
+### `protocol.interceptHttpProtocol(scheme, handler[, completion])`

 * `scheme` String
 * `handler` Function
@ -158,7 +158,7 @@ which sends a `Buffer` as a response.
 Intercepts `scheme` protocol and uses `handler` as the protocol's new handler
 which sends a new HTTP request as a response.

-## `protocol.uninterceptProtocol(scheme[, completion])`
+### `protocol.uninterceptProtocol(scheme[, completion])`

 * `scheme` String
 * `completion` Function
--- a/docs/styleguide.md
+++ b/docs/styleguide.md
@ -65,7 +65,11 @@ notated by brackets surrounding the optional argument as well as the comma
 required if this optional argument follows another argument.

 Below the method is more detailed information on each of the arguments. The type
-of argument is notated by either the common types: [`String`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String), [`Number`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number), [`Object`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object), [`Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)
+of argument is notated by either the common types:
+[`String`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String),
+[`Number`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number),
+[`Object`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object),
+[`Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)
 or a custom type like Electron's [`webContent`](api/web-content.md).

 ### Events
--- a/package.json
+++ b/package.json
@ -4,7 +4,9 @@
    "asar": "^0.8.0",
    "coffee-script": "^1.9.2",
    "coffeelint": "^1.9.4",
-    "request": "*",
+    "request": "*"
+  },
+  "optionalDependencies": {
    "runas": "^3.0.0"
  },
  "private": true,
--- a/spec/package.json
+++ b/spec/package.json
@ -5,14 +5,16 @@
  "version": "0.1.0",
  "devDependencies": {
    "basic-auth": "^1.0.0",
-    "ffi": "2.0.0",
    "formidable": "1.0.16",
    "graceful-fs": "3.0.5",
    "mocha": "2.1.0",
    "q": "0.9.7",
-    "runas": "3.x",
    "temp": "0.8.1",
    "walkdir": "0.0.7",
    "ws": "0.7.2"
+  },
+  "optionalDependencies": {
+    "ffi": "2.0.0",
+    "runas": "3.x"
  }
 }
--- a/toolchain.gypi
+++ b/toolchain.gypi
@ -9,6 +9,9 @@
    'sysroot%': '',

    'variables': {
+      # The minimum OS X SDK version to use.
+      'mac_sdk_min%': '10.10',
+
      # Set ARM architecture version.
      'arm_version%': 7,

@ -17,6 +20,7 @@
    },

    # Copy conditionally-set variables out one scope.
+    'mac_sdk_min%': '<(mac_sdk_min)',
    'arm_version%': '<(arm_version)',
    'arm_neon%': '<(arm_neon)',

@ -35,6 +39,11 @@
        'source_root': '<!(cd <(DEPTH) && pwd -P)',
      }],  # OS!="win"

+      # Search for the available version of SDK.
+      ['OS=="mac"', {
+        'mac_sdk%': '<!(python <(DEPTH)/tools/mac/find_sdk.py <(mac_sdk_min))',
+      }],
+
      # Set default compiler flags depending on ARM version.
      ['arm_version==6', {
        'arm_arch%': 'armv6',
@ -94,6 +103,15 @@
      },
    }],  # clang==1

+    # Specify the SDKROOT.
+    ['OS=="mac"', {
+      'target_defaults': {
+        'xcode_settings': {
+          'SDKROOT': 'macosx<(mac_sdk)',  # -isysroot
+        },
+      },
+    }],
+
    # Setup sysroot environment.
    ['OS=="linux" and target_arch in ["arm", "ia32"]', {
      'variables': {
--- a/tools/mac/find_sdk.py
+++ b/tools/mac/find_sdk.py
@ -0,0 +1,93 @@
+#!/usr/bin/env python
+# Copyright (c) 2012 The Chromium Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Prints the lowest locally available SDK version greater than or equal to a
+given minimum sdk version to standard output.
+
+Usage:
+  python find_sdk.py 10.6  # Ignores SDKs < 10.6
+"""
+
+import os
+import re
+import subprocess
+import sys
+
+
+from optparse import OptionParser
+
+
+def parse_version(version_str):
+  """'10.6' => [10, 6]"""
+  return map(int, re.findall(r'(\d+)', version_str))
+
+
+def main():
+  parser = OptionParser()
+  parser.add_option("--verify",
+                    action="store_true", dest="verify", default=False,
+                    help="return the sdk argument and warn if it doesn't exist")
+  parser.add_option("--sdk_path",
+                    action="store", type="string", dest="sdk_path", default="",
+                    help="user-specified SDK path; bypasses verification")
+  parser.add_option("--print_sdk_path",
+                    action="store_true", dest="print_sdk_path", default=False,
+                    help="Additionaly print the path the SDK (appears first).")
+  options, args = parser.parse_args()
+  if len(args) != 1:
+    parser.error('Please specify a minimum SDK version')
+  min_sdk_version = args[0]
+
+  job = subprocess.Popen(['xcode-select', '-print-path'],
+                         stdout=subprocess.PIPE,
+                         stderr=subprocess.STDOUT)
+  out, err = job.communicate()
+  if job.returncode != 0:
+    print >> sys.stderr, out
+    print >> sys.stderr, err
+    raise Exception(('Error %d running xcode-select, you might have to run '
+      '|sudo xcode-select --switch /Applications/Xcode.app/Contents/Developer| '
+      'if you are using Xcode 4.') % job.returncode)
+  # The Developer folder moved in Xcode 4.3.
+  xcode43_sdk_path = os.path.join(
+      out.rstrip(), 'Platforms/MacOSX.platform/Developer/SDKs')
+  if os.path.isdir(xcode43_sdk_path):
+    sdk_dir = xcode43_sdk_path
+  else:
+    sdk_dir = os.path.join(out.rstrip(), 'SDKs')
+  sdks = [re.findall('^MacOSX(10\.\d+)\.sdk$', s) for s in os.listdir(sdk_dir)]
+  sdks = [s[0] for s in sdks if s]  # [['10.5'], ['10.6']] => ['10.5', '10.6']
+  sdks = [s for s in sdks  # ['10.5', '10.6'] => ['10.6']
+          if parse_version(s) >= parse_version(min_sdk_version)]
+  if not sdks:
+    raise Exception('No %s+ SDK found' % min_sdk_version)
+  best_sdk = sorted(sdks, key=parse_version)[0]
+
+  if options.verify and best_sdk != min_sdk_version and not options.sdk_path:
+    print >> sys.stderr, ''
+    print >> sys.stderr, '                                           vvvvvvv'
+    print >> sys.stderr, ''
+    print >> sys.stderr, \
+        'This build requires the %s SDK, but it was not found on your system.' \
+        % min_sdk_version
+    print >> sys.stderr, \
+        'Either install it, or explicitly set mac_sdk in your GYP_DEFINES.'
+    print >> sys.stderr, ''
+    print >> sys.stderr, '                                           ^^^^^^^'
+    print >> sys.stderr, ''
+    return min_sdk_version
+
+  if options.print_sdk_path:
+    print subprocess.check_output(['xcodebuild', '-version', '-sdk',
+                                   'macosx' + best_sdk, 'Path']).strip()
+
+  return best_sdk
+
+
+if __name__ == '__main__':
+  if sys.platform != 'darwin':
+    raise Exception("This script only runs on Mac")
+  print main()
+  sys.exit(0)
--- a/vendor/brightray
+++ b/vendor/brightray
@ -1 +1 @@
-Subproject commit c25b9b27845a308e6a6a5966dad057d721b1f3d1
+Subproject commit 375436a777a793f4815f38c13a5226fcd82de567
--- a/vendor/crashpad
+++ b/vendor/crashpad
@ -1 +1 @@
-Subproject commit e6a0d433b0ee399eecce2bef671794771052ffdb
+Subproject commit 5b777419c303d8aa7930239d8ef755475f1ede57