v1.7.16

fix: Update to latest libcc for 1-7-x

.circleci/config.yml

@@ -0,0 +1,524 @@
+
+version: 2
+jobs:
+  electron-linux-arm:
+    docker:
+      - image: electronbuilds/electron:0.0.7
+        environment:
+          TARGET_ARCH: arm
+    resource_class: 2xlarge
+    steps:
+      - checkout
+      - run:
+          name: Check for release
+          command: |
+            if [ -n "${RUN_RELEASE_BUILD}" ]; then
+              echo 'release build triggered from api'
+              echo 'export ELECTRON_RELEASE=1 TRIGGERED_BY_API=1' >> $BASH_ENV
+            fi
+      - run:
+         name: Bootstrap
+         command: |
+           if [ "$ELECTRON_RELEASE" == "1" ]; then
+              echo 'Bootstrapping Electron for release build'
+              script/bootstrap.py --target_arch=$TARGET_ARCH
+           else
+              echo 'Bootstrapping Electron for debug build'
+              script/bootstrap.py --target_arch=$TARGET_ARCH --dev
+           fi
+      - run: npm run lint
+      - run:
+         name: Build
+         command: |
+           if [ "$ELECTRON_RELEASE" == "1" ]; then
+              echo 'Building Electron for release'
+              script/build.py -c R
+           else
+              echo 'Building Electron for debug'
+              script/build.py -c D
+           fi
+      - run:
+          name: Create distribution
+          command: |
+             if [ "$ELECTRON_RELEASE" == "1" ]; then
+                echo 'Creating Electron release distribution'
+                script/create-dist.py
+             else
+                echo 'Skipping create distribution because build is not for release'
+             fi
+      - run:
+          name: Upload distribution
+          command: |
+             if [ "$ELECTRON_RELEASE" == "1" ] && [ "$TRIGGERED_BY_API" != "1" ]; then
+                echo 'Uploading Electron release distribution to github releases'
+                script/upload.py
+             elif [ "$ELECTRON_RELEASE" == "1" ] && [ "$TRIGGERED_BY_API" == "1" ]; then
+                echo 'Uploading Electron release distribution to s3'
+                script/upload.py --upload_to_s3
+             else
+                echo 'Skipping upload distribution because build is not for release'
+             fi
+      - run:
+          name: Zip out directory
+          command: |
+            if [ "$ELECTRON_RELEASE" != "1" ]; then
+              zip -r electron.zip out/D
+            fi
+      - persist_to_workspace:
+          root: /home/builduser
+          paths:
+            - project/out
+      - store_artifacts:
+          path: electron.zip
+  electron-linux-ia32:
+    docker:
+      - image: electronbuilds/electron:0.0.7
+        environment:
+          TARGET_ARCH: ia32
+          DISPLAY: ':99.0'
+    resource_class: xlarge
+    steps:
+      - checkout
+      - run:
+          name: Setup for headless testing
+          command: sh -e /etc/init.d/xvfb start
+      - run:
+          name: Check for release
+          command: |
+            if [ -n "${RUN_RELEASE_BUILD}" ]; then
+              echo 'release build triggered from api'
+              echo 'export ELECTRON_RELEASE=1 TRIGGERED_BY_API=1' >> $BASH_ENV
+            fi
+      - run:
+         name: Bootstrap
+         command: |
+           if [ "$ELECTRON_RELEASE" == "1" ]; then
+              echo 'Bootstrapping Electron for release build'
+              script/bootstrap.py --target_arch=$TARGET_ARCH
+           else
+              echo 'Bootstrapping Electron for debug build'
+              script/bootstrap.py --target_arch=$TARGET_ARCH --dev
+           fi
+      - run: npm run lint
+      - run:
+         name: Build
+         command: |
+           if [ "$ELECTRON_RELEASE" == "1" ]; then
+              echo 'Building Electron for release'
+              script/build.py -c R
+           else
+              echo 'Building Electron for debug'
+              script/build.py -c D
+           fi
+      - run:
+          name: Create distribution
+          command: |
+             if [ "$ELECTRON_RELEASE" == "1" ]; then
+                echo 'Creating Electron release distribution'
+                script/create-dist.py
+             else
+                echo 'Skipping create distribution because build is not for release'
+             fi
+      - run:
+          name: Upload distribution
+          command: |
+             if [ "$ELECTRON_RELEASE" == "1" ] && [ "$TRIGGERED_BY_API" != "1" ]; then
+                echo 'Uploading Electron release distribution to github releases'
+                script/upload.py
+             elif [ "$ELECTRON_RELEASE" == "1" ] && [ "$TRIGGERED_BY_API" == "1" ]; then
+                echo 'Uploading Electron release distribution to s3'
+                script/upload.py --upload_to_s3
+             else
+                echo 'Skipping upload distribution because build is not for release'
+             fi
+      - run:
+          name: Test
+          environment:
+            MOCHA_FILE: junit/test-results.xml
+            MOCHA_REPORTER: mocha-junit-reporter
+          command: |
+             if [ "$ELECTRON_RELEASE" != "1" ]; then
+                echo 'Testing Electron debug build'
+                out/D/electron --version
+                mkdir junit
+                script/test.py --ci
+             else
+                echo 'Skipping testing on release build'
+             fi
+      - run:
+          name: Verify FFmpeg
+          command: |
+             if [ "$ELECTRON_RELEASE" != "1" ]; then
+                echo 'Verifying ffmpeg on debug build'
+                script/verify-ffmpeg.py
+             else
+                echo 'Skipping verify ffmpeg on release build'
+             fi
+      - store_test_results:
+          path: junit
+      - store_artifacts:
+          path: junit
+  electron-linux-mips64el:
+    docker:
+      - image: electronbuilds/electron:0.0.7
+        environment:
+          TARGET_ARCH: mips64el
+    resource_class: xlarge
+    steps:
+      - checkout
+      - run:
+          name: Check for release
+          command: |
+            if [ -n "${RUN_RELEASE_BUILD}" ]; then
+              echo 'release build triggered from api'
+              echo 'export ELECTRON_RELEASE=1 TRIGGERED_BY_API=1' >> $BASH_ENV
+            fi
+      - run:
+         name: Bootstrap
+         command: |
+           if [ "$ELECTRON_RELEASE" == "1" ]; then
+              echo 'Bootstrapping Electron for release build'
+              script/bootstrap.py --target_arch=$TARGET_ARCH
+           else
+              echo 'Bootstrapping Electron for debug build'
+              script/bootstrap.py --target_arch=$TARGET_ARCH --dev
+           fi
+      - run: npm run lint
+      - run:
+         name: Build
+         command: |
+           if [ "$ELECTRON_RELEASE" == "1" ]; then
+              echo 'Building Electron for release'
+              script/build.py -c R
+           else
+              echo 'Building Electron for debug'
+              script/build.py -c D
+           fi
+      - run:
+          name: Create distribution
+          command: |
+             if [ "$ELECTRON_RELEASE" == "1" ]; then
+                echo 'Creating Electron release distribution'
+                script/create-dist.py
+             else
+                echo 'Skipping create distribution because build is not for release'
+             fi
+      - run:
+          name: Upload distribution
+          command: |
+             if [ "$ELECTRON_RELEASE" == "1" ] && [ "$TRIGGERED_BY_API" != "1" ]; then
+                echo 'Uploading Electron release distribution to github releases'
+                script/upload.py
+             elif [ "$ELECTRON_RELEASE" == "1" ] && [ "$TRIGGERED_BY_API" == "1" ]; then
+                echo 'Uploading Electron release distribution to s3'
+                script/upload.py --upload_to_s3
+             else
+                echo 'Skipping upload distribution because build is not for release'
+             fi
+
+  electron-linux-x64:
+    docker:
+      - image: electronbuilds/electron:0.0.7
+        environment:
+          TARGET_ARCH: x64
+          DISPLAY: ':99.0'
+    resource_class: xlarge
+    steps:
+      - checkout
+      - run:
+          name: Setup for headless testing
+          command: sh -e /etc/init.d/xvfb start
+      - run:
+          name: Check for release
+          command: |
+            if [ -n "${RUN_RELEASE_BUILD}" ]; then
+              echo 'release build triggered from api'
+              echo 'export ELECTRON_RELEASE=1 TRIGGERED_BY_API=1' >> $BASH_ENV
+            fi
+      - run:
+         name: Bootstrap
+         command: |
+           if [ "$ELECTRON_RELEASE" == "1" ]; then
+              echo 'Bootstrapping Electron for release build'
+              script/bootstrap.py --target_arch=$TARGET_ARCH
+           else
+              echo 'Bootstrapping Electron for debug build'
+              script/bootstrap.py --target_arch=$TARGET_ARCH --dev
+           fi
+      - run: npm run lint
+      - run:
+         name: Build
+         command: |
+           if [ "$ELECTRON_RELEASE" == "1" ]; then
+              echo 'Building Electron for release'
+              script/build.py -c R
+           else
+              echo 'Building Electron for debug'
+              script/build.py -c D
+           fi
+      - run:
+          name: Create distribution
+          command: |
+             if [ "$ELECTRON_RELEASE" == "1" ]; then
+                echo 'Creating Electron release distribution'
+                script/create-dist.py
+             else
+                echo 'Skipping create distribution because build is not for release'
+             fi
+      - run:
+          name: Upload distribution
+          command: |
+             if [ "$ELECTRON_RELEASE" == "1" ] && [ "$TRIGGERED_BY_API" != "1" ]; then
+                echo 'Uploading Electron release distribution to github releases'
+                script/upload.py
+             elif [ "$ELECTRON_RELEASE" == "1" ] && [ "$TRIGGERED_BY_API" == "1" ]; then
+                echo 'Uploading Electron release distribution to s3'
+                script/upload.py --upload_to_s3
+             else
+                echo 'Skipping upload distribution because build is not for release'
+             fi
+      - run:
+          name: Test
+          environment:
+            MOCHA_FILE: junit/test-results.xml
+            MOCHA_REPORTER: mocha-junit-reporter
+          command: |
+             if [ "$ELECTRON_RELEASE" != "1" ]; then
+                echo 'Testing Electron debug build'
+                mkdir junit
+                script/test.py --ci
+             else
+                echo 'Skipping testing on release build'
+             fi
+      - run:
+          name: Verify FFmpeg
+          command: |
+             if [ "$ELECTRON_RELEASE" != "1" ]; then
+                echo 'Verifying ffmpeg on debug build'
+                script/verify-ffmpeg.py
+             else
+                echo 'Skipping verify ffmpeg on release build'
+             fi
+      - run:
+          name: Generate Typescript Definitions
+          command: npm run create-typescript-definitions
+      - store_test_results:
+          path: junit
+      - store_artifacts:
+          path: junit
+      - store_artifacts:
+          path: out/electron.d.ts
+      - store_artifacts:
+          path: out/electron-api.json
+
+  electron-osx-x64:
+    environment:
+      TARGET_ARCH: x64
+    macos:
+      xcode: "8.3.3"
+    steps:
+      - checkout
+      - run:
+          name: Install node
+          command: |
+            brew update
+            brew install node@8
+            brew link node@8 --force
+      - run:
+          name: Check for release
+          command: |
+            if [ -n "${RUN_RELEASE_BUILD}" ]; then
+              echo 'release build triggered from api'
+              echo 'export ELECTRON_RELEASE=1 TRIGGERED_BY_API=1' >> $BASH_ENV
+            fi
+      - run:
+         name: Bootstrap
+         command: |
+           if [ "$ELECTRON_RELEASE" == "1" ]; then
+              echo 'Bootstrapping Electron for release build'
+              script/bootstrap.py --target_arch=$TARGET_ARCH
+           else
+              echo 'Bootstrapping Electron for debug build'
+              script/bootstrap.py --target_arch=$TARGET_ARCH --dev
+           fi
+      - run: npm run lint
+      - run:
+         name: Build
+         command: |
+           if [ "$ELECTRON_RELEASE" == "1" ]; then
+              echo 'Building Electron for release'
+              script/build.py -c R
+           else
+              echo 'Building Electron for debug'
+              script/build.py -c D
+           fi
+      - run:
+          name: Create distribution
+          command: |
+             if [ "$ELECTRON_RELEASE" == "1" ]; then
+                echo 'Creating Electron release distribution'
+                script/create-dist.py
+             else
+                echo 'Skipping create distribution because build is not for release'
+             fi
+      - run:
+          name: Upload distribution
+          command: |
+             if [ "$ELECTRON_RELEASE" == "1" ] && [ "$TRIGGERED_BY_API" != "1" ]; then
+                echo 'Uploading Electron release distribution to github releases'
+                script/upload.py
+             elif [ "$ELECTRON_RELEASE" == "1" ] && [ "$TRIGGERED_BY_API" == "1" ]; then
+                echo 'Uploading Electron release distribution to s3'
+                script/upload.py --upload_to_s3
+             else
+                echo 'Skipping upload distribution because build is not for release'
+             fi
+      - run:
+          name: Test
+          environment:
+            MOCHA_FILE: junit/test-results.xml
+            MOCHA_REPORTER: mocha-junit-reporter
+          command: |
+             if [ "$ELECTRON_RELEASE" != "1" ]; then
+                echo 'Testing Electron debug build'
+                mkdir junit
+                script/test.py --ci
+             else
+                echo 'Skipping testing on release build'
+             fi
+      - run:
+          name: Verify FFmpeg
+          command: |
+             if [ "$ELECTRON_RELEASE" != "1" ]; then
+                echo 'Verifying ffmpeg on debug build'
+                script/verify-ffmpeg.py
+             else
+                echo 'Skipping verify ffmpeg on release build'
+             fi
+      - run:
+          name: Generate Typescript Definitions
+          command: npm run create-typescript-definitions
+      - store_test_results:
+          path: junit
+      - store_artifacts:
+          path: junit
+      - store_artifacts:
+          path: out/electron.d.ts
+      - store_artifacts:
+          path: out/electron-api.json
+
+  electron-mas-x64:
+    environment:
+      TARGET_ARCH: x64
+      MAS_BUILD: 1
+    macos:
+      xcode: "8.3.3"
+    steps:
+      - checkout
+      - run:
+          name: Install node
+          command: |
+            brew update
+            brew install node@8
+            brew link node@8 --force
+      - run:
+          name: Check for release
+          command: |
+            if [ -n "${RUN_RELEASE_BUILD}" ]; then
+              echo 'release build triggered from api'
+              echo 'export ELECTRON_RELEASE=1 TRIGGERED_BY_API=1' >> $BASH_ENV
+            fi
+      - run:
+         name: Bootstrap
+         command: |
+           if [ "$ELECTRON_RELEASE" == "1" ]; then
+              echo 'Bootstrapping Electron for release build'
+              script/bootstrap.py --target_arch=$TARGET_ARCH
+           else
+              echo 'Bootstrapping Electron for debug build'
+              script/bootstrap.py --target_arch=$TARGET_ARCH --dev
+           fi
+      - run: npm run lint
+      - run:
+         name: Build
+         command: |
+           if [ "$ELECTRON_RELEASE" == "1" ]; then
+              echo 'Building Electron for release'
+              script/build.py -c R
+           else
+              echo 'Building Electron for debug'
+              script/build.py -c D
+           fi
+      - run:
+          name: Create distribution
+          command: |
+             if [ "$ELECTRON_RELEASE" == "1" ]; then
+                echo 'Creating Electron release distribution'
+                script/create-dist.py
+             else
+                echo 'Skipping create distribution because build is not for release'
+             fi
+      - run:
+          name: Upload distribution
+          command: |
+             if [ "$ELECTRON_RELEASE" == "1" ] && [ "$TRIGGERED_BY_API" != "1" ]; then
+                echo 'Uploading Electron release distribution to github releases'
+                script/upload.py
+             elif [ "$ELECTRON_RELEASE" == "1" ] && [ "$TRIGGERED_BY_API" == "1" ]; then
+                echo 'Uploading Electron release distribution to s3'
+                script/upload.py --upload_to_s3
+             else
+                echo 'Skipping upload distribution because build is not for release'
+             fi
+      - run:
+          name: Test
+          environment:
+            MOCHA_FILE: junit/test-results.xml
+            MOCHA_REPORTER: mocha-junit-reporter
+          command: |
+             if [ "$ELECTRON_RELEASE" != "1" ]; then
+                echo 'Testing Electron debug build'
+                mkdir junit
+                script/test.py --ci
+             else
+                echo 'Skipping testing on release build'
+             fi
+      - run:
+          name: Verify FFmpeg
+          command: |
+             if [ "$ELECTRON_RELEASE" != "1" ]; then
+                echo 'Verifying ffmpeg on debug build'
+                script/verify-ffmpeg.py
+             else
+                echo 'Skipping verify ffmpeg on release build'
+             fi
+      - run:
+          name: Generate Typescript Definitions
+          command: npm run create-typescript-definitions
+      - store_test_results:
+          path: junit
+      - store_artifacts:
+          path: junit
+      - store_artifacts:
+          path: out/electron.d.ts
+      - store_artifacts:
+          path: out/electron-api.json
+
+
+workflows:
+  version: 2
+  build-arm:
+    jobs:
+      - electron-linux-arm
+  build-ia32:
+    jobs:
+      - electron-linux-ia32
+  build-x64:
+    jobs:
+      - electron-linux-x64
+  build-osx-x64:
+    jobs:
+      - electron-osx-x64
+  build-mas-x64:
+    jobs:
+      - electron-mas-x64

Jenkinsfile

@@ -0,0 +1,44 @@
+pipeline {
+  agent none
+  stages {
+    stage('Build') {
+      parallel {
+        stage('electron-osx-x64') {
+            agent {
+              label 'osx'
+            }
+            steps {
+              sh 'script/bootstrap.py --target_arch=x64 --dev'
+              sh 'npm run lint'
+              sh 'script/build.py -c D'
+              sh 'script/test.py --ci --rebuild_native_modules'
+            }
+            post {
+              always {
+                cleanWs()
+              }
+            }
+        }
+        stage('electron-mas-x64') {
+          agent {
+            label 'osx'
+          }
+          environment {
+            MAS_BUILD = '1'
+          }
+          steps {
+            sh 'script/bootstrap.py --target_arch=x64 --dev'
+            sh 'npm run lint'
+            sh 'script/build.py -c D'
+            sh 'script/test.py --ci --rebuild_native_modules'
+          }
+          post {
+            always {
+              cleanWs()
+            }
+          }
+        }
+      }
+    }
+  }
+}

appveyor.yml

@@ -1,25 +1,58 @@
-# appveyor file
-# http://www.appveyor.com/docs/appveyor-yml
-version: "{build}"
-
-os: Visual Studio 2015
-
-init:
-  - git config --global core.autocrlf input
-
-platform:
-  - x86
-  - x64
-
-install:
-  - cmd: SET PATH=C:\Program Files (x86)\MSBuild\14.0\bin\;%PATH%
-  - cmd: SET PATH=C:\python27;%PATH%
-  - cmd: python script/cibuild
-
-branches:
-  only:
-    - master
-
-# disable build and test phases
-build: off
-test: off
+build_cloud: electron-16
+image: electron-16-vs2015
+build_script:
+- ps: >-
+    if(($env:APPVEYOR_PULL_REQUEST_HEAD_REPO_NAME -split "/")[0] -eq ($env:APPVEYOR_REPO_NAME -split "/")[0]) {
+      Write-warning "Skipping PR build for branch"; Exit-AppveyorBuild
+    } else {
+      Add-Path "$env:ProgramFiles (x86)\Windows Kits\10\Debuggers\x64"
+      $env:path = "$env:ProgramFiles (x86)\Windows Kits\10\Debuggers\x64;$env:path"
+      if($env:APPVEYOR_SCHEDULED_BUILD -eq 'True')  {
+        $env:RUN_RELEASE_BUILD = "1"
+      }
+      $Message = (git log --format=%B -n 1 HEAD) | Out-String
+      if ((Test-Path Env:\RUN_RELEASE_BUILD)) {
+        $env:ELECTRON_RELEASE = '1'
+        Write-Output "release build triggered from api"
+      }
+      if ((Test-Path Env:\ELECTRON_RELEASE)) {
+        Write-Output "Running release build"
+        python script\bootstrap.py --target_arch=$env:TARGET_ARCH
+        python script\build.py -c R
+        python script\create-dist.py
+      } else {
+        Write-Output "Running debug build"
+        python script\bootstrap.py --target_arch=$env:TARGET_ARCH --dev
+        python script\build.py -c D
+      }
+      if ($? -ne 'True') {
+        throw "Build failed with exit code $?"
+      } else {
+        "Build succeeded."
+      }
+      Push-AppveyorArtifact out
+    }
+test_script:
+- ps: >-
+    if (Test-Path Env:\ELECTRON_RELEASE) {
+      Write-Output "Skipping tests for release build"
+    } else {
+      Write-Output "Running tests for debug build"
+      python script\test.py --ci --rebuild_native_modules
+      if ($LASTEXITCODE -ne '0') {
+        throw "Tests failed with exit code $LASTEXITCODE"
+      } else {
+        Write-Output "Tests succeeded."
+      }
+      python script\verify-ffmpeg.py
+      if ($LASTEXITCODE -ne '0') {
+        throw "Verify ffmpeg failed with exit code $LASTEXITCODE"
+      } else {
+        "Verify ffmpeg succeeded."
+      }
+    }
+artifacts:
+- path: test-results.xml
+  name: test-results.xml
+deploy_script:
+- ps: "if (Test-Path Env:\\ELECTRON_RELEASE) {\n  if (Test-Path Env:\\RUN_RELEASE_BUILD) {\n    Write-Output \"Uploading Electron release distribution to s3\"\n    & python script\\upload.py --upload_to_s3\n  } else {\n    Write-Output \"Uploading Electron release distribution to github releases\"\n    & python script\\upload.py\n  }\n} else {\n  Write-Output \"Skipping upload distribution because build is not for release\"\n}"

atom/app/atom_library_main.h

@@ -10,7 +10,7 @@
 #if defined(OS_MACOSX)
 extern "C" {
 __attribute__((visibility("default")))
-int AtomMain(int argc, const char* argv[]);
+int AtomMain(int argc, char* argv[]);
 
 __attribute__((visibility("default")))
 int AtomInitializeICUandStartNode(int argc, char *argv[]);

atom/app/atom_library_main.mm

@@ -15,11 +15,11 @@
 #include "content/public/app/content_main.h"
 
 #if defined(OS_MACOSX)
-int AtomMain(int argc, const char* argv[]) {
+int AtomMain(int argc, char* argv[]) {
   atom::AtomMainDelegate delegate;
   content::ContentMainParams params(&delegate);
   params.argc = argc;
-  params.argv = argv;
+  params.argv = const_cast<const char**>(argv);
   atom::AtomCommandLine::Init(argc, argv);
   return content::ContentMain(params);
 }

atom/app/atom_main.cc

@@ -4,7 +4,8 @@
 
 #include "atom/app/atom_main.h"
 
-#include <stdlib.h>
+#include <cstdlib>
+#include <vector>
 
 #if defined(OS_WIN)
 #include <windows.h>  // windows.h must be included first
@@ -14,9 +15,11 @@
 #include <tchar.h>
 
 #include "atom/app/atom_main_delegate.h"
+#include "atom/app/command_line_args.h"
 #include "atom/common/crash_reporter/win/crash_service_main.h"
 #include "base/environment.h"
 #include "base/process/launch.h"
+#include "base/strings/utf_string_conversions.h"
 #include "base/win/windows_version.h"
 #include "content/public/app/sandbox_helper_win.h"
 #include "sandbox/win/src/sandbox_types.h"
@@ -51,59 +54,83 @@ bool IsEnvSet(const char* name) {
 
 #if defined(OS_WIN)
 int APIENTRY wWinMain(HINSTANCE instance, HINSTANCE, wchar_t* cmd, int) {
-  int argc = 0;
-  wchar_t** wargv = ::CommandLineToArgvW(::GetCommandLineW(), &argc);
+  struct Arguments {
+    int argc = 0;
+    wchar_t** argv = ::CommandLineToArgvW(::GetCommandLineW(), &argc);
+
+    ~Arguments() { LocalFree(argv); }
+  } arguments;
+
+  if (!arguments.argv)
+    return -1;
+
+#ifdef _DEBUG
+  // Don't display assert dialog boxes in CI test runs
+  static const auto kCI = "ELECTRON_CI";
+  bool is_ci = IsEnvSet(kCI);
+  if (!is_ci) {
+    for (int i = 0; i < arguments.argc; ++i) {
+      if (!_wcsicmp(arguments.argv[i], L"--ci")) {
+        is_ci = true;
+        _putenv_s(kCI, "1");  // set flag for child processes
+        break;
+      }
+    }
+  }
+  if (is_ci) {
+    _CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_DEBUG | _CRTDBG_MODE_FILE);
+    _CrtSetReportFile(_CRT_ERROR, _CRTDBG_FILE_STDERR);
+
+    _CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_DEBUG | _CRTDBG_MODE_FILE);
+    _CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
+
+    _set_error_mode(_OUT_TO_STDERR);
+  }
+#endif
 
   bool run_as_node = IsEnvSet(kRunAsNode);
 
-
   // Make sure the output is printed to console.
   if (run_as_node || !IsEnvSet("ELECTRON_NO_ATTACH_CONSOLE"))
     base::RouteStdioToConsole(false);
 
-  // Convert argv to to UTF8
-  char** argv = new char*[argc];
-  for (int i = 0; i < argc; i++) {
-    // Compute the size of the required buffer
-    DWORD size = WideCharToMultiByte(CP_UTF8,
-                                     0,
-                                     wargv[i],
-                                     -1,
-                                     NULL,
-                                     0,
-                                     NULL,
-                                     NULL);
-    if (size == 0) {
-      // This should never happen.
-      fprintf(stderr, "Could not convert arguments to utf8.");
-      exit(1);
-    }
-    // Do the actual conversion
-    argv[i] = new char[size];
-    DWORD result = WideCharToMultiByte(CP_UTF8,
-                                       0,
-                                       wargv[i],
-                                       -1,
-                                       argv[i],
-                                       size,
-                                       NULL,
-                                       NULL);
-    if (result == 0) {
-      // This should never happen.
-      fprintf(stderr, "Could not convert arguments to utf8.");
-      exit(1);
-    }
-  }
+#ifndef DEBUG
+  // Chromium has its own TLS subsystem which supports automatic destruction
+  // of thread-local data, and also depends on memory allocation routines
+  // provided by the CRT. The problem is that the auto-destruction mechanism
+  // uses a hidden feature of the OS loader which calls a callback on thread
+  // exit, but only after all loaded DLLs have been detached. Since the CRT is
+  // also a DLL, it happens that by the time Chromium's `OnThreadExit` function
+  // is called, the heap functions, though still in memory, no longer perform
+  // their duties, and when Chromium calls `free` on its buffer, it triggers
+  // an access violation error.
+  // We work around this problem by invoking Chromium's `OnThreadExit` in time
+  // from within the CRT's atexit facility, ensuring the heap functions are
+  // still active. The second invocation from the OS loader will be a no-op.
+  extern void NTAPI OnThreadExit(PVOID module, DWORD reason, PVOID reserved);
+  atexit([]() {
+    OnThreadExit(nullptr, DLL_THREAD_DETACH, nullptr);
+  });
+#endif
 
   if (run_as_node) {
-    // Now that argv conversion is done, we can finally start.
+    std::vector<char*> argv(arguments.argc);
+    std::transform(
+        arguments.argv, arguments.argv + arguments.argc, argv.begin(),
+        [](auto& a) { return _strdup(base::WideToUTF8(a).c_str()); });
+
     base::AtExitManager atexit_manager;
     base::i18n::InitializeICU();
-    return atom::NodeMain(argc, argv);
+    auto ret = atom::NodeMain(argv.size(), argv.data());
+    std::for_each(argv.begin(), argv.end(), free);
+    return ret;
   } else if (IsEnvSet("ELECTRON_INTERNAL_CRASH_SERVICE")) {
     return crash_service::Main(cmd);
   }
 
+  if (!atom::CheckCommandLineArguments(arguments.argc, arguments.argv))
+    return -1;
+
   sandbox::SandboxInterfaceInfo sandbox_info = {0};
   content::InitializeSandboxInfo(&sandbox_info);
   atom::AtomMainDelegate delegate;
@@ -111,33 +138,32 @@ int APIENTRY wWinMain(HINSTANCE instance, HINSTANCE, wchar_t* cmd, int) {
   content::ContentMainParams params(&delegate);
   params.instance = instance;
   params.sandbox_info = &sandbox_info;
-  atom::AtomCommandLine::Init(argc, argv);
-  atom::AtomCommandLine::InitW(argc, wargv);
+  atom::AtomCommandLine::Init(arguments.argc, arguments.argv);
   return content::ContentMain(params);
 }
 
 #elif defined(OS_LINUX)  // defined(OS_WIN)
 
-int main(int argc, const char* argv[]) {
+int main(int argc, char* argv[]) {
   if (IsEnvSet(kRunAsNode)) {
     base::i18n::InitializeICU();
     base::AtExitManager atexit_manager;
-    return atom::NodeMain(argc, const_cast<char**>(argv));
+    return atom::NodeMain(argc, argv);
   }
 
   atom::AtomMainDelegate delegate;
   content::ContentMainParams params(&delegate);
   params.argc = argc;
-  params.argv = argv;
+  params.argv = const_cast<const char**>(argv);
   atom::AtomCommandLine::Init(argc, argv);
   return content::ContentMain(params);
 }
 
 #else  // defined(OS_LINUX)
 
-int main(int argc, const char* argv[]) {
+int main(int argc, char* argv[]) {
   if (IsEnvSet(kRunAsNode)) {
-    return AtomInitializeICUandStartNode(argc, const_cast<char**>(argv));
+    return AtomInitializeICUandStartNode(argc, argv);
   }
 
   return AtomMain(argc, argv);

atom/app/command_line_args.h

@@ -0,0 +1,17 @@
+// Copyright (c) 2018 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_APP_COMMAND_LINE_ARGS_H_
+#define ATOM_APP_COMMAND_LINE_ARGS_H_
+
+#include "base/command_line.h"
+
+namespace atom {
+
+bool CheckCommandLineArguments(int argc, base::CommandLine::CharType** argv);
+
+}  // namespace atom
+
+#endif  // ATOM_APP_COMMAND_LINE_ARGS_H_
+

atom/browser/api/atom_api_app.cc

@@ -575,6 +575,12 @@ void App::OnFinishLaunching(const base::DictionaryValue& launch_info) {
   Emit("ready", launch_info);
 }
 
+void App::OnPreMainMessageLoopRun() {
+  if (process_singleton_) {
+    process_singleton_->OnBrowserReady();
+  }
+}
+
 void App::OnAccessibilitySupportChanged() {
   Emit("accessibility-support-changed", IsAccessibilitySupportEnabled());
 }
@@ -820,11 +826,7 @@ bool App::Relaunch(mate::Arguments* js_args) {
   }
 
   if (!override_argv) {
-#if defined(OS_WIN)
-    const relauncher::StringVector& argv = atom::AtomCommandLine::wargv();
-#else
     const relauncher::StringVector& argv = atom::AtomCommandLine::argv();
-#endif
     return relauncher::RelaunchApp(argv);
   }
 

atom/browser/api/atom_api_app.h

@@ -94,6 +94,7 @@ class App : public AtomBrowserClient::Delegate,
   base::FilePath GetAppPath() const;
   void RenderProcessReady(content::RenderProcessHost* host);
   void RenderProcessDisconnected(base::ProcessId host_pid);
+  void PreMainMessageLoopRun();
 
  protected:
   explicit App(v8::Isolate* isolate);
@@ -112,6 +113,7 @@ class App : public AtomBrowserClient::Delegate,
   void OnLogin(LoginHandler* login_handler,
                const base::DictionaryValue& request_details) override;
   void OnAccessibilitySupportChanged() override;
+  void OnPreMainMessageLoopRun() override;
 #if defined(OS_MACOSX)
   void OnContinueUserActivity(
       bool* prevent_default,

atom/browser/api/atom_api_notification.cc

@@ -67,6 +67,7 @@ Notification::Notification(v8::Isolate* isolate,
     opts.Get("replyPlaceholder", &reply_placeholder_);
     opts.Get("hasReply", &has_reply_);
     opts.Get("actions", &actions_);
+    opts.Get("sound", &sound_);
   }
 }
 
@@ -113,6 +114,10 @@ std::vector<brightray::NotificationAction> Notification::GetActions() const {
   return actions_;
 }
 
+base::string16 Notification::GetSound() const {
+  return sound_;
+}
+
 // Setters
 void Notification::SetTitle(const base::string16& new_title) {
   title_ = new_title;
@@ -143,6 +148,10 @@ void Notification::SetActions(
   actions_ = actions;
 }
 
+void Notification::SetSound(const base::string16& new_sound) {
+  sound_ = new_sound;
+}
+
 void Notification::NotificationAction(int index) {
   Emit("action", index);
 }
@@ -181,6 +190,7 @@ void Notification::Show() {
       options.has_reply = has_reply_;
       options.reply_placeholder = reply_placeholder_;
       options.actions = actions_;
+      options.sound = sound_;
       notification_->Show(options);
     }
   }
@@ -207,7 +217,9 @@ void Notification::BuildPrototype(v8::Isolate* isolate,
       .SetProperty("hasReply", &Notification::GetHasReply,
                    &Notification::SetHasReply)
       .SetProperty("actions", &Notification::GetActions,
-                   &Notification::SetActions);
+                   &Notification::SetActions)
+      .SetProperty("sound", &Notification::GetSound,
+                   &Notification::SetSound);
 }
 
 }  // namespace api

atom/browser/api/atom_api_notification.h

@@ -54,6 +54,7 @@ class Notification : public mate::TrackableObject<Notification>,
   base::string16 GetReplyPlaceholder() const;
   bool GetHasReply() const;
   std::vector<brightray::NotificationAction> GetActions() const;
+  base::string16 GetSound() const;
 
   // Prop Setters
   void SetTitle(const base::string16& new_title);
@@ -63,6 +64,7 @@ class Notification : public mate::TrackableObject<Notification>,
   void SetReplyPlaceholder(const base::string16& new_reply_placeholder);
   void SetHasReply(bool new_has_reply);
   void SetActions(const std::vector<brightray::NotificationAction>& actions);
+  void SetSound(const base::string16& sound);
 
  private:
   base::string16 title_;
@@ -75,6 +77,7 @@ class Notification : public mate::TrackableObject<Notification>,
   base::string16 reply_placeholder_;
   bool has_reply_ = false;
   std::vector<brightray::NotificationAction> actions_;
+  base::string16 sound_;
 
   brightray::NotificationPresenter* presenter_;
 

atom/browser/api/atom_api_web_contents.cc

@@ -370,8 +370,8 @@ WebContents::WebContents(v8::Isolate* isolate, const mate::Dictionary& options)
     options.Get("transparent", &transparent);
 
     content::WebContents::CreateParams params(session->browser_context());
-    auto* view = new OffScreenWebContentsView(
-        transparent, base::Bind(&WebContents::OnPaint, base::Unretained(this)));
+    auto* view = new OffScreenWebContentsView(transparent,
+        base::Bind(&WebContents::OnPaint, base::Unretained(this)));
     params.view = view;
     params.delegate_view = view;
 
@@ -1597,10 +1597,10 @@ void WebContents::StartPainting() {
     return;
 
 #if defined(ENABLE_OSR)
-  auto* osr_rwhv = static_cast<OffScreenRenderWidgetHostView*>(
-      web_contents()->GetRenderWidgetHostView());
-  if (osr_rwhv)
-    osr_rwhv->SetPainting(true);
+  const auto* wc_impl = static_cast<content::WebContentsImpl*>(web_contents());
+  auto* osr_wcv = static_cast<OffScreenWebContentsView*>(wc_impl->GetView());
+  if (osr_wcv)
+    osr_wcv->SetPainting(true);
 #endif
 }
 
@@ -1609,10 +1609,10 @@ void WebContents::StopPainting() {
     return;
 
 #if defined(ENABLE_OSR)
-  auto* osr_rwhv = static_cast<OffScreenRenderWidgetHostView*>(
-      web_contents()->GetRenderWidgetHostView());
-  if (osr_rwhv)
-    osr_rwhv->SetPainting(false);
+  const auto* wc_impl = static_cast<content::WebContentsImpl*>(web_contents());
+  auto* osr_wcv = static_cast<OffScreenWebContentsView*>(wc_impl->GetView());
+  if (osr_wcv)
+    osr_wcv->SetPainting(false);
 #endif
 }
 
@@ -1621,9 +1621,10 @@ bool WebContents::IsPainting() const {
     return false;
 
 #if defined(ENABLE_OSR)
-  const auto* osr_rwhv = static_cast<OffScreenRenderWidgetHostView*>(
-      web_contents()->GetRenderWidgetHostView());
-  return osr_rwhv && osr_rwhv->IsPainting();
+  const auto* wc_impl = static_cast<content::WebContentsImpl*>(web_contents());
+  auto* osr_wcv = static_cast<OffScreenWebContentsView*>(wc_impl->GetView());
+
+  return osr_wcv && osr_wcv->IsPainting();
 #else
   return false;
 #endif
@@ -1634,10 +1635,11 @@ void WebContents::SetFrameRate(int frame_rate) {
     return;
 
 #if defined(ENABLE_OSR)
-  auto* osr_rwhv = static_cast<OffScreenRenderWidgetHostView*>(
-      web_contents()->GetRenderWidgetHostView());
-  if (osr_rwhv)
-    osr_rwhv->SetFrameRate(frame_rate);
+  const auto* wc_impl = static_cast<content::WebContentsImpl*>(web_contents());
+  auto* osr_wcv = static_cast<OffScreenWebContentsView*>(wc_impl->GetView());
+
+  if (osr_wcv)
+    osr_wcv->SetFrameRate(frame_rate);
 #endif
 }
 
@@ -1646,9 +1648,10 @@ int WebContents::GetFrameRate() const {
     return 0;
 
 #if defined(ENABLE_OSR)
-  const auto* osr_rwhv = static_cast<OffScreenRenderWidgetHostView*>(
-      web_contents()->GetRenderWidgetHostView());
-  return osr_rwhv ? osr_rwhv->GetFrameRate() : 0;
+  const auto* wc_impl = static_cast<content::WebContentsImpl*>(web_contents());
+  auto* osr_wcv = static_cast<OffScreenWebContentsView*>(wc_impl->GetView());
+
+  return osr_wcv ? osr_wcv->GetFrameRate() : 0;
 #else
   return 0;
 #endif
@@ -1718,6 +1721,14 @@ v8::Local<v8::Value> WebContents::GetWebPreferences(v8::Isolate* isolate) {
   return mate::ConvertToV8(isolate, *web_preferences->web_preferences());
 }
 
+v8::Local<v8::Value> WebContents::GetLastWebPreferences(v8::Isolate* isolate) {
+  WebContentsPreferences* web_preferences =
+      WebContentsPreferences::FromWebContents(web_contents());
+  if (!web_preferences)
+    return v8::Null(isolate);
+  return mate::ConvertToV8(isolate, *web_preferences->last_web_preferences());
+}
+
 v8::Local<v8::Value> WebContents::GetOwnerBrowserWindow() {
   if (owner_window())
     return Window::From(isolate(), owner_window());
@@ -1848,6 +1859,7 @@ void WebContents::BuildPrototype(v8::Isolate* isolate,
       .SetMethod("_getZoomFactor", &WebContents::GetZoomFactor)
       .SetMethod("getType", &WebContents::GetType)
       .SetMethod("getWebPreferences", &WebContents::GetWebPreferences)
+      .SetMethod("getLastWebPreferences", &WebContents::GetLastWebPreferences)
       .SetMethod("getOwnerBrowserWindow", &WebContents::GetOwnerBrowserWindow)
       .SetMethod("hasServiceWorker", &WebContents::HasServiceWorker)
       .SetMethod("unregisterServiceWorker",

atom/browser/api/atom_api_web_contents.h

@@ -210,6 +210,7 @@ class WebContents : public mate::TrackableObject<WebContents>,
 
   // Returns the web preferences of current WebContents.
   v8::Local<v8::Value> GetWebPreferences(v8::Isolate* isolate);
+  v8::Local<v8::Value> GetLastWebPreferences(v8::Isolate* isolate);
 
   // Returns the owner window.
   v8::Local<v8::Value> GetOwnerBrowserWindow();

atom/browser/atom_browser_client.cc

@@ -23,6 +23,7 @@
 #include "atom/common/options_switches.h"
 #include "base/command_line.h"
 #include "base/files/file_util.h"
+#include "base/path_service.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
@@ -38,6 +39,7 @@
 #include "content/public/browser/resource_dispatcher_host.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/browser/web_contents.h"
+#include "content/public/common/content_paths.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/common/web_preferences.h"
@@ -243,6 +245,11 @@ void AtomBrowserClient::OverrideSiteInstanceForNavigation(
 void AtomBrowserClient::AppendExtraCommandLineSwitches(
     base::CommandLine* command_line,
     int process_id) {
+  // Make sure we're about to launch a known executable
+  base::FilePath child_path;
+  PathService::Get(content::CHILD_PROCESS_EXE, &child_path);
+  CHECK(base::MakeAbsoluteFilePath(command_line->GetProgram()) == child_path);
+
   std::string process_type =
       command_line->GetSwitchValueASCII(::switches::kProcessType);
   if (process_type != ::switches::kRendererProcess)

atom/browser/atom_browser_main_parts.cc

@@ -4,6 +4,7 @@
 
 #include "atom/browser/atom_browser_main_parts.h"
 
+#include "atom/browser/api/atom_api_app.h"
 #include "atom/browser/api/trackable_object.h"
 #include "atom/browser/atom_access_token_store.h"
 #include "atom/browser/atom_browser_client.h"
@@ -183,6 +184,8 @@ void AtomBrowserMainParts::PreMainMessageLoopRun() {
   std::unique_ptr<base::DictionaryValue> empty_info(new base::DictionaryValue);
   Browser::Get()->DidFinishLaunching(*empty_info);
 #endif
+
+  Browser::Get()->PreMainMessageLoopRun();
 }
 
 bool AtomBrowserMainParts::MainMessageLoopRun(int* result_code) {

atom/browser/browser.cc

@@ -171,6 +171,12 @@ void Browser::RequestLogin(
     observer.OnLogin(login_handler, *(request_details.get()));
 }
 
+void Browser::PreMainMessageLoopRun() {
+  for (BrowserObserver& observer : observers_) {
+    observer.OnPreMainMessageLoopRun();
+  }
+}
+
 void Browser::NotifyAndShutdown() {
   if (is_shutdown_)
     return;

atom/browser/browser.h

@@ -202,6 +202,8 @@ class Browser : public WindowListObserver {
   void RequestLogin(LoginHandler* login_handler,
                     std::unique_ptr<base::DictionaryValue> request_details);
 
+  void PreMainMessageLoopRun();
+
   void AddObserver(BrowserObserver* obs) {
     observers_.AddObserver(obs);
   }

atom/browser/browser_observer.h

@@ -55,6 +55,9 @@ class BrowserObserver {
   // The browser's accessibility suppport has changed.
   virtual void OnAccessibilitySupportChanged() {}
 
+  // The app message loop is ready
+  virtual void OnPreMainMessageLoopRun() {}
+
 #if defined(OS_MACOSX)
   // The browser wants to resume a user activity via handoff. (macOS only)
   virtual void OnContinueUserActivity(

atom/browser/mac/atom_application_delegate.mm

@@ -7,9 +7,36 @@
 #import "atom/browser/mac/atom_application.h"
 #include "atom/browser/browser.h"
 #include "atom/browser/mac/dict_util.h"
+#include "base/allocator/allocator_shim.h"
+#include "base/allocator/features.h"
+#include "base/mac/mac_util.h"
+#include "base/mac/scoped_objc_class_swizzler.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/values.h"
 
+#if BUILDFLAG(USE_EXPERIMENTAL_ALLOCATOR_SHIM)
+// On macOS 10.12, the IME system attempts to allocate a 2^64 size buffer,
+// which would typically cause an OOM crash. To avoid this, the problematic
+// method is swizzled out and the make-OOM-fatal bit is disabled for the
+// duration of the original call. https://crbug.com/654695
+static base::mac::ScopedObjCClassSwizzler* g_swizzle_imk_input_session;
+@interface OOMDisabledIMKInputSession : NSObject
+@end
+@implementation OOMDisabledIMKInputSession
+- (void)_coreAttributesFromRange:(NSRange)range
+                 whichAttributes:(long long)attributes
+               completionHandler:(void (^)(void))block {
+  // The allocator flag is per-process, so other threads may temporarily
+  // not have fatal OOM occur while this method executes, but it is better
+  // than crashing when using IME.
+  base::allocator::SetCallNewHandlerOnMallocFailure(false);
+  g_swizzle_imk_input_session->GetOriginalImplementation()(self, _cmd, range,
+                                                           attributes, block);
+  base::allocator::SetCallNewHandlerOnMallocFailure(true);
+}
+@end
+#endif  // BUILDFLAG(USE_EXPERIMENTAL_ALLOCATOR_SHIM)
+
 @implementation AtomApplicationDelegate
 
 - (void)setApplicationDockMenu:(atom::AtomMenuModel*)model {
@@ -35,6 +62,16 @@
     std::unique_ptr<base::DictionaryValue> empty_info(new base::DictionaryValue);
     atom::Browser::Get()->DidFinishLaunching(*empty_info);
   }
+
+#if BUILDFLAG(USE_EXPERIMENTAL_ALLOCATOR_SHIM)
+  // Disable fatal OOM to hack around an OS bug https://crbug.com/654695.
+  if (base::mac::IsOS10_12()) {
+    g_swizzle_imk_input_session = new base::mac::ScopedObjCClassSwizzler(
+        NSClassFromString(@"IMKInputSession"),
+        [OOMDisabledIMKInputSession class],
+        @selector(_coreAttributesFromRange:whichAttributes:completionHandler:));
+  }
+#endif
 }
 
 - (NSMenu*)applicationDockMenu:(NSApplication*)sender {

atom/browser/native_browser_view.cc

@@ -2,6 +2,8 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
+#include <vector>
+
 #include "atom/browser/native_browser_view.h"
 
 #include "atom/browser/api/atom_api_web_contents.h"

atom/browser/native_browser_view.h

@@ -5,6 +5,9 @@
 #ifndef ATOM_BROWSER_NATIVE_BROWSER_VIEW_H_
 #define ATOM_BROWSER_NATIVE_BROWSER_VIEW_H_
 
+#include <vector>
+
+#include "atom/common/draggable_region.h"
 #include "base/macros.h"
 #include "third_party/skia/include/core/SkColor.h"
 
@@ -38,6 +41,10 @@ class NativeBrowserView {
   virtual void SetBounds(const gfx::Rect& bounds) = 0;
   virtual void SetBackgroundColor(SkColor color) = 0;
 
+  // Called when the window needs to update its draggable region.
+  virtual void UpdateDraggableRegions(
+    const std::vector<gfx::Rect>& system_drag_exclude_areas) {}
+
  protected:
   explicit NativeBrowserView(
       brightray::InspectableWebContentsView* web_contents_view);

atom/browser/native_browser_view_mac.h

@@ -6,8 +6,11 @@
 #define ATOM_BROWSER_NATIVE_BROWSER_VIEW_MAC_H_
 
 #import <Cocoa/Cocoa.h>
+#include <vector>
 
 #include "atom/browser/native_browser_view.h"
+#include "atom/common/draggable_region.h"
+#include "base/mac/scoped_nsobject.h"
 
 namespace atom {
 
@@ -20,6 +23,8 @@ class NativeBrowserViewMac : public NativeBrowserView {
   void SetAutoResizeFlags(uint8_t flags) override;
   void SetBounds(const gfx::Rect& bounds) override;
   void SetBackgroundColor(SkColor color) override;
+  void UpdateDraggableRegions(
+      const std::vector<gfx::Rect>& system_drag_exclude_areas) override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(NativeBrowserViewMac);

atom/browser/native_browser_view_mac.mm

@@ -12,6 +12,101 @@
 const NSAutoresizingMaskOptions kDefaultAutoResizingMask =
     NSViewMaxXMargin | NSViewMinYMargin;
 
+@interface DragRegionView : NSView
+
+@property (assign) NSPoint initialLocation;
+
+@end
+
+@interface NSWindow ()
+- (void)performWindowDragWithEvent:(NSEvent *)event;
+@end
+
+@implementation DragRegionView
+
+- (BOOL)mouseDownCanMoveWindow
+{
+  return NO;
+}
+
+- (NSView *)hitTest:(NSPoint)aPoint
+{
+    // Pass-through events that don't hit one of the exclusion zones
+    for (NSView *exlusion_zones in [self subviews]) {
+      if ([exlusion_zones hitTest:aPoint])
+        return nil;
+    }
+
+    return self;
+}
+
+- (void)mouseDown:(NSEvent *)event
+{
+  if ([self.window respondsToSelector:@selector(performWindowDragWithEvent)]) {
+    [self.window performWindowDragWithEvent:event];
+    return;
+  }
+
+  self.initialLocation = [event locationInWindow];
+}
+
+- (void)mouseDragged:(NSEvent *)theEvent
+{
+  if ([self.window respondsToSelector:@selector(performWindowDragWithEvent)]) {
+    return;
+  }
+
+  NSPoint currentLocation = [NSEvent mouseLocation];
+  NSPoint newOrigin;
+
+  NSRect screenFrame = [[NSScreen mainScreen] frame];
+  NSRect windowFrame = [self.window frame];
+
+  newOrigin.x = currentLocation.x - self.initialLocation.x;
+  newOrigin.y = currentLocation.y - self.initialLocation.y;
+
+  // Don't let window get dragged up under the menu bar
+  if ((newOrigin.y + windowFrame.size.height) > (screenFrame.origin.y + screenFrame.size.height)) {
+    newOrigin.y = screenFrame.origin.y + (screenFrame.size.height - windowFrame.size.height);
+  }
+
+  // Move the window to the new location
+  [self.window setFrameOrigin:newOrigin];
+}
+
+// Debugging tips:
+// Uncomment the following four lines to color DragRegionView bright red
+// #ifdef DEBUG_DRAG_REGIONS
+// - (void)drawRect:(NSRect)aRect
+// {
+//     [[NSColor redColor] set];
+//     NSRectFill([self bounds]);
+// }
+// #endif
+
+@end
+
+@interface ExcludeDragRegionView : NSView
+@end
+
+@implementation ExcludeDragRegionView
+
+- (BOOL)mouseDownCanMoveWindow {
+  return NO;
+}
+
+// Debugging tips:
+// Uncomment the following four lines to color ExcludeDragRegionView bright red
+// #ifdef DEBUG_DRAG_REGIONS
+// - (void)drawRect:(NSRect)aRect
+// {
+//     [[NSColor greenColor] set];
+//     NSRectFill([self bounds]);
+// }
+// #endif
+
+@end
+
 namespace atom {
 
 NativeBrowserViewMac::NativeBrowserViewMac(
@@ -51,6 +146,59 @@ void NativeBrowserViewMac::SetBackgroundColor(SkColor color) {
   view.layer.backgroundColor = skia::CGColorCreateFromSkColor(color);
 }
 
+void NativeBrowserViewMac::UpdateDraggableRegions(
+    const std::vector<gfx::Rect>& system_drag_exclude_areas) {
+  NSView* webView = GetInspectableWebContentsView()->GetNativeView();
+
+  NSInteger superViewHeight = NSHeight([webView.superview bounds]);
+  NSInteger webViewHeight = NSHeight([webView bounds]);
+  NSInteger webViewWidth = NSWidth([webView bounds]);
+  NSInteger webViewX = NSMinX([webView frame]);
+  NSInteger webViewY = 0;
+
+  // Apple's NSViews have their coordinate system originate at the bottom left,
+  // meaning that we need to be a bit smarter when it comes to calculating our
+  // current top offset
+  if (webViewHeight > superViewHeight) {
+    webViewY = std::abs(webViewHeight - superViewHeight - (std::abs(NSMinY([webView frame]))));
+  } else {
+    webViewY = superViewHeight - NSMaxY([webView frame]);
+  }
+
+  // Remove all DraggableRegionViews that are added last time.
+  // Note that [webView subviews] returns the view's mutable internal array and
+  // it should be copied to avoid mutating the original array while enumerating
+  // it.
+  base::scoped_nsobject<NSArray> subviews([[webView subviews] copy]);
+  for (NSView* subview in subviews.get())
+    if ([subview isKindOfClass:[DragRegionView class]])
+      [subview removeFromSuperview];
+
+  // Create one giant NSView that is draggable.
+  base::scoped_nsobject<NSView> dragRegion(
+        [[DragRegionView alloc] initWithFrame:NSZeroRect]);
+    [dragRegion setFrame:NSMakeRect(0,
+                                    0,
+                                    webViewWidth,
+                                    webViewHeight)];
+
+  // Then, on top of that, add "exclusion zones"
+  for (auto iter = system_drag_exclude_areas.begin();
+       iter != system_drag_exclude_areas.end();
+       ++iter) {
+    base::scoped_nsobject<NSView> controlRegion(
+        [[ExcludeDragRegionView alloc] initWithFrame:NSZeroRect]);
+    [controlRegion setFrame:NSMakeRect(iter->x() - webViewX,
+                                       webViewHeight - iter->bottom() + webViewY,
+                                       iter->width(),
+                                       iter->height())];
+    [dragRegion addSubview:controlRegion];
+  }
+
+  // Add the DragRegion to the WebView
+  [webView addSubview:dragRegion];
+}
+
 // static
 NativeBrowserView* NativeBrowserView::Create(
     brightray::InspectableWebContentsView* web_contents_view) {

atom/browser/native_window_mac.h

@@ -154,7 +154,7 @@ class NativeWindowMac : public NativeWindow,
   void UninstallView();
 
   // Install the drag view, which will cover the whole window and decides
-  // whehter we can drag.
+  // whether we can drag.
   void UpdateDraggableRegionViews(const std::vector<DraggableRegion>& regions);
 
   void RegisterInputEventObserver(content::RenderViewHost* host);

atom/browser/native_window_mac.mm

@@ -1767,6 +1767,10 @@ void NativeWindowMac::UpdateDraggableRegionViews(
   std::vector<gfx::Rect> system_drag_exclude_areas =
       CalculateNonDraggableRegions(regions, webViewWidth, webViewHeight);
 
+  if (browser_view_) {
+    browser_view_->UpdateDraggableRegions(system_drag_exclude_areas);
+  }
+
   // Create and add a ControlRegionView for each region that needs to be
   // excluded from the dragging.
   for (std::vector<gfx::Rect>::const_iterator iter =

atom/browser/net/asar/url_request_asar_job.cc

@@ -245,10 +245,21 @@ void URLRequestAsarJob::FetchMetaInfo(const base::FilePath& file_path,
     meta_info->file_size = file_info.size;
     meta_info->is_directory = file_info.is_directory;
   }
-  // On Windows GetMimeTypeFromFile() goes to the registry. Thus it should be
-  // done in WorkerPool.
-  meta_info->mime_type_result =
-      net::GetMimeTypeFromFile(file_path, &meta_info->mime_type);
+
+  // We use GetWellKnownMimeTypeFromExtension() to ensure that configurations
+  // that may have been set by other programs on a user's machine don't affect
+  // the mime type returned (in particular, JS should always be
+  // (application/javascript). See https://crbug.com/797712. Using an accurate
+  // mime type is necessary at least for modules and sw, which enforce strict
+  // mime type requirements.
+  // TODO(deepak1556): Revert this when sw support is removed for file scheme.
+  base::FilePath::StringType file_extension = file_path.Extension();
+  if (file_extension.empty()) {
+    meta_info->mime_type_result = false;
+  } else {
+    meta_info->mime_type_result = net::GetWellKnownMimeTypeFromExtension(
+        file_extension.substr(1), &meta_info->mime_type);
+  }
 }
 
 void URLRequestAsarJob::DidFetchMetaInfo(const FileMetaInfo* meta_info) {

atom/browser/net/url_request_fetch_job.cc

@@ -258,7 +258,9 @@ void URLRequestFetchJob::OnURLFetchComplete(const net::URLFetcher* source) {
       HeadersCompleted();
       return;
     }
-    ReadRawDataComplete(0);
+    if (request_->status().is_io_pending()) {
+      ReadRawDataComplete(0);
+    }
   } else {
     NotifyStartError(fetcher_->GetStatus());
   }

atom/browser/osr/osr_output_device.cc

@@ -79,12 +79,12 @@ void OffScreenOutputDevice::EndPaint() {
     OnPaint(damage_rect_);
 }
 
-void OffScreenOutputDevice::SetActive(bool active) {
+void OffScreenOutputDevice::SetActive(bool active, bool paint) {
   if (active == active_)
     return;
   active_ = active;
 
-  if (active_)
+  if (active_ && paint)
     OnPaint(gfx::Rect(viewport_pixel_size_));
 }
 

atom/browser/osr/osr_output_device.h

@@ -24,7 +24,7 @@ class OffScreenOutputDevice : public cc::SoftwareOutputDevice {
   SkCanvas* BeginPaint(const gfx::Rect& damage_rect) override;
   void EndPaint() override;
 
-  void SetActive(bool active);
+  void SetActive(bool active, bool paint);
   void OnPaint(const gfx::Rect& damage_rect);
 
  private:

atom/browser/osr/osr_render_widget_host_view.cc

@@ -181,7 +181,7 @@ class AtomCopyFrameGenerator {
   }
 
   void GenerateCopyFrame(const gfx::Rect& damage_rect) {
-    if (!view_->render_widget_host())
+    if (!view_->render_widget_host() || !view_->IsPainting())
       return;
 
     std::unique_ptr<cc::CopyOutputRequest> request =
@@ -312,6 +312,8 @@ class AtomBeginFrameTimer : public cc::DelayBasedTimeSourceClient {
 
 OffScreenRenderWidgetHostView::OffScreenRenderWidgetHostView(
     bool transparent,
+    bool painting,
+    int frame_rate,
     const OnPaintCallback& callback,
     content::RenderWidgetHost* host,
     OffScreenRenderWidgetHostView* parent_host_view,
@@ -325,17 +327,18 @@ OffScreenRenderWidgetHostView::OffScreenRenderWidgetHostView(
       transparent_(transparent),
       callback_(callback),
       parent_callback_(nullptr),
-      frame_rate_(60),
+      frame_rate_(frame_rate),
       frame_rate_threshold_us_(0),
       last_time_(base::Time::Now()),
       scale_factor_(kDefaultScaleFactor),
       size_(native_window->GetSize()),
-      painting_(true),
+      painting_(painting),
       is_showing_(!render_widget_host_->is_hidden()),
       is_destroyed_(false),
       popup_position_(gfx::Rect()),
       hold_resize_(false),
       pending_resize_(false),
+      paint_callback_running_(false),
       weak_ptr_factory_(this) {
   DCHECK(render_widget_host_);
   bool is_guest_view_hack = parent_host_view_ != nullptr;
@@ -358,7 +361,7 @@ OffScreenRenderWidgetHostView::OffScreenRenderWidgetHostView(
       new ui::Compositor(context_factory_private->AllocateFrameSinkId(),
                          content::GetContextFactory(), context_factory_private,
                          base::ThreadTaskRunnerHandle::Get()));
-  compositor_->SetAcceleratedWidget(native_window_->GetAcceleratedWidget());
+  compositor_->SetAcceleratedWidget(gfx::kNullAcceleratedWidget);
   compositor_->SetRootLayer(root_layer_.get());
 #endif
   GetCompositor()->SetDelegate(this);
@@ -591,7 +594,7 @@ void OffScreenRenderWidgetHostView::OnSwapCompositorFrame(
   if (!frame.render_pass_list.empty()) {
     if (software_output_device_) {
       if (!begin_frame_timer_.get() || IsPopupWidget()) {
-        software_output_device_->SetActive(painting_);
+        software_output_device_->SetActive(painting_, false);
       }
 
       // The compositor will draw directly to the SoftwareOutputDevice which
@@ -774,6 +777,8 @@ content::RenderWidgetHostViewBase*
 
   return new OffScreenRenderWidgetHostView(
       transparent_,
+      true,
+      embedder_host_view->GetFrameRate(),
       callback_,
       render_widget_host,
       embedder_host_view,
@@ -972,12 +977,12 @@ bool OffScreenRenderWidgetHostView::IsAutoResizeEnabled() const {
 
 void OffScreenRenderWidgetHostView::SetNeedsBeginFrames(
     bool needs_begin_frames) {
-  SetupFrameRate(false);
+  SetupFrameRate(true);
 
   begin_frame_timer_->SetActive(needs_begin_frames);
 
   if (software_output_device_) {
-    software_output_device_->SetActive(needs_begin_frames && painting_);
+    software_output_device_->SetActive(needs_begin_frames && painting_, false);
   }
 }
 
@@ -1046,7 +1051,9 @@ void OffScreenRenderWidgetHostView::OnPaint(
     }
 
     damage.Intersect(GetViewBounds());
+    paint_callback_running_ = true;
     callback_.Run(damage, bitmap);
+    paint_callback_running_ = false;
 
     for (size_t i = 0; i < damages.size(); i++) {
       CopyBitmapTo(bitmap, originals[i], damages[i]);
@@ -1190,7 +1197,7 @@ void OffScreenRenderWidgetHostView::SetPainting(bool painting) {
   painting_ = painting;
 
   if (software_output_device_) {
-    software_output_device_->SetActive(painting_);
+    software_output_device_->SetActive(painting_, !paint_callback_running_);
   }
 }
 
@@ -1207,16 +1214,16 @@ void OffScreenRenderWidgetHostView::SetFrameRate(int frame_rate) {
   } else {
     if (frame_rate <= 0)
       frame_rate = 1;
-    if (frame_rate > 60)
-      frame_rate = 60;
+    if (frame_rate > 240)
+      frame_rate = 240;
 
     frame_rate_ = frame_rate;
   }
 
+  SetupFrameRate(true);
+
   for (auto guest_host_view : guest_host_views_)
     guest_host_view->SetFrameRate(frame_rate);
-
-  SetupFrameRate(true);
 }
 
 int OffScreenRenderWidgetHostView::GetFrameRate() const {
@@ -1244,7 +1251,7 @@ void OffScreenRenderWidgetHostView::SetupFrameRate(bool force) {
 
   frame_rate_threshold_us_ = 1000000 / frame_rate_;
 
-  GetCompositor()->vsync_manager()->SetAuthoritativeVSyncInterval(
+  GetCompositor()->SetAuthoritativeVSyncInterval(
       base::TimeDelta::FromMicroseconds(frame_rate_threshold_us_));
 
   if (copy_frame_generator_.get()) {

atom/browser/osr/osr_render_widget_host_view.h

@@ -73,6 +73,8 @@ class OffScreenRenderWidgetHostView
       public OffscreenViewProxyObserver {
  public:
   OffScreenRenderWidgetHostView(bool transparent,
+                                bool painting,
+                                int frame_rate,
                                 const OnPaintCallback& callback,
                                 content::RenderWidgetHost* render_widget_host,
                                 OffScreenRenderWidgetHostView* parent_host_view,
@@ -305,6 +307,8 @@ class OffScreenRenderWidgetHostView
   bool hold_resize_;
   bool pending_resize_;
 
+  bool paint_callback_running_;
+
   std::unique_ptr<ui::Layer> root_layer_;
   std::unique_ptr<ui::Compositor> compositor_;
   std::unique_ptr<content::DelegatedFrameHost> delegated_frame_host_;

atom/browser/osr/osr_web_contents_view.cc

@@ -15,6 +15,8 @@ namespace atom {
 OffScreenWebContentsView::OffScreenWebContentsView(
     bool transparent, const OnPaintCallback& callback)
     : transparent_(transparent),
+      painting_(true),
+      frame_rate_(60),
       callback_(callback),
       web_contents_(nullptr) {
 #if defined(OS_MACOSX)
@@ -103,6 +105,8 @@ content::RenderWidgetHostViewBase*
   auto relay = NativeWindowRelay::FromWebContents(web_contents_);
   return new OffScreenRenderWidgetHostView(
       transparent_,
+      painting_,
+      GetFrameRate(),
       callback_,
       render_widget_host,
       nullptr,
@@ -125,6 +129,8 @@ content::RenderWidgetHostViewBase*
 
   return new OffScreenRenderWidgetHostView(
       transparent_,
+      true,
+      view->GetFrameRate(),
       callback_,
       render_widget_host,
       view,
@@ -202,6 +208,42 @@ void OffScreenWebContentsView::UpdateDragCursor(
     blink::WebDragOperation operation) {
 }
 
+void OffScreenWebContentsView::SetPainting(bool painting) {
+  auto* view = GetView();
+  if (view != nullptr) {
+    view->SetPainting(painting);
+  } else {
+    painting_ = painting;
+  }
+}
+
+bool OffScreenWebContentsView::IsPainting() const {
+  auto* view = GetView();
+  if (view != nullptr) {
+    return view->IsPainting();
+  } else {
+    return painting_;
+  }
+}
+
+void OffScreenWebContentsView::SetFrameRate(int frame_rate) {
+  auto* view = GetView();
+  if (view != nullptr) {
+    view->SetFrameRate(frame_rate);
+  } else {
+    frame_rate_ = frame_rate;
+  }
+}
+
+int OffScreenWebContentsView::GetFrameRate() const {
+  auto* view = GetView();
+  if (view != nullptr) {
+    return view->GetFrameRate();
+  } else {
+    return frame_rate_;
+  }
+}
+
 OffScreenRenderWidgetHostView* OffScreenWebContentsView::GetView() const {
   if (web_contents_) {
     return static_cast<OffScreenRenderWidgetHostView*>(

atom/browser/osr/osr_web_contents_view.h

@@ -69,6 +69,11 @@ class OffScreenWebContentsView : public content::WebContentsView,
                      content::RenderWidgetHostImpl* source_rwh) override;
   void UpdateDragCursor(blink::WebDragOperation operation) override;
 
+  void SetPainting(bool painting);
+  bool IsPainting() const;
+  void SetFrameRate(int frame_rate);
+  int GetFrameRate() const;
+
  private:
 #if defined(OS_MACOSX)
   void PlatformCreate();
@@ -78,6 +83,8 @@ class OffScreenWebContentsView : public content::WebContentsView,
   OffScreenRenderWidgetHostView* GetView() const;
 
   const bool transparent_;
+  bool painting_;
+  int frame_rate_;
   OnPaintCallback callback_;
 
   // Weak refs.

atom/browser/relauncher.cc

@@ -140,11 +140,7 @@ bool RelaunchAppWithHelper(const base::FilePath& helper,
 }
 
 int RelauncherMain(const content::MainFunctionParams& main_parameters) {
-#if defined(OS_WIN)
-  const StringVector& argv = atom::AtomCommandLine::wargv();
-#else
   const StringVector& argv = atom::AtomCommandLine::argv();
-#endif
 
   if (argv.size() < 4 || argv[1] != internal::kRelauncherTypeArg) {
     LOG(ERROR) << "relauncher process invoked with unexpected arguments";

atom/browser/resources/mac/Info.plist

@@ -17,9 +17,9 @@
   <key>CFBundleIconFile</key>
   <string>electron.icns</string>
   <key>CFBundleVersion</key>
-  <string>1.7.6</string>
+  <string>1.7.16</string>
   <key>CFBundleShortVersionString</key>
-  <string>1.7.6</string>
+  <string>1.7.16</string>
   <key>LSApplicationCategoryType</key>
   <string>public.app-category.developer-tools</string>
   <key>LSMinimumSystemVersion</key>

atom/browser/resources/win/atom.rc

@@ -56,8 +56,8 @@ END
 //
 
 VS_VERSION_INFO VERSIONINFO
- FILEVERSION 1,7,6,0
- PRODUCTVERSION 1,7,6,0
+ FILEVERSION 1,7,16,0
+ PRODUCTVERSION 1,7,16,0
  FILEFLAGSMASK 0x3fL
 #ifdef _DEBUG
  FILEFLAGS 0x1L
@@ -74,12 +74,12 @@ BEGIN
         BEGIN
             VALUE "CompanyName", "GitHub, Inc."
             VALUE "FileDescription", "Electron"
-            VALUE "FileVersion", "1.7.6"
+            VALUE "FileVersion", "1.7.16"
             VALUE "InternalName", "electron.exe"
             VALUE "LegalCopyright", "Copyright (C) 2015 GitHub, Inc. All rights reserved."
             VALUE "OriginalFilename", "electron.exe"
             VALUE "ProductName", "Electron"
-            VALUE "ProductVersion", "1.7.6"
+            VALUE "ProductVersion", "1.7.16"
             VALUE "SquirrelAwareVersion", "1"
         END
     END

atom/browser/ui/cocoa/atom_touch_bar.h

@@ -17,7 +17,7 @@
 #include "native_mate/constructor.h"
 #include "native_mate/persistent_dictionary.h"
 
-@interface AtomTouchBar : NSObject<NSScrubberDelegate, NSScrubberDataSource> {
+@interface AtomTouchBar : NSObject<NSScrubberDelegate, NSScrubberDataSource, NSScrubberFlowLayoutDelegate> {
  @protected
   std::vector<mate::PersistentDictionary> ordered_settings_;
   std::map<std::string, mate::PersistentDictionary> settings_;

atom/browser/ui/cocoa/atom_touch_bar.mm

@@ -666,4 +666,40 @@ static NSString* const ImageScrubberItemIdentifier = @"scrubber.image.item";
   return itemView;
 }
 
+- (NSSize)scrubber:(NSScrubber *)scrubber layout:(NSScrubberFlowLayout *)layout sizeForItemAtIndex:(NSInteger)itemIndex
+{
+  NSInteger width = 50;
+  NSInteger height = 30;
+  NSInteger margin = 15;
+  NSSize defaultSize = NSMakeSize(width, height);
+
+  std::string s_id([[scrubber identifier] UTF8String]);
+  if (![self hasItemWithID:s_id]) return defaultSize;
+
+  mate::PersistentDictionary settings = settings_[s_id];
+  std::vector<mate::PersistentDictionary> items;
+  if (!settings.Get("items", &items)) return defaultSize;
+
+  if (itemIndex >= static_cast<NSInteger>(items.size())) return defaultSize;
+
+  mate::PersistentDictionary item = items[itemIndex];
+  std::string title;
+
+  if (item.Get("label", &title)) {
+    NSSize size = NSMakeSize(CGFLOAT_MAX, CGFLOAT_MAX);
+    NSRect textRect = [base::SysUTF8ToNSString(title) boundingRectWithSize:size
+                                          options:NSStringDrawingUsesLineFragmentOrigin |   NSStringDrawingUsesFontLeading
+                                          attributes:@{ NSFontAttributeName: [NSFont systemFontOfSize:0]}];
+
+    width = textRect.size.width + margin;
+  } else {
+    gfx::Image image;
+    if (item.Get("icon", &image)) {
+      width = image.AsNSImage().size.width;
+    }
+  }
+
+  return NSMakeSize(width, height);
+}
+
 @end

atom/browser/ui/cocoa/touch_bar_forward_declarations.h

@@ -15,7 +15,7 @@
 
 @class NSTouchBar, NSTouchBarItem;
 @class NSScrubber, NSScrubberItemView, NSScrubberArrangedView, NSScrubberTextItemView, NSScrubberImageItemView, NSScrubberSelectionStyle;
-@protocol NSTouchBarDelegate, NSScrubberDelegate, NSScrubberDataSource;
+@protocol NSTouchBarDelegate, NSScrubberDelegate, NSScrubberDataSource, NSScrubberFlowLayoutDelegate, NSScrubberFlowLayout;
 
 typedef float NSTouchBarItemPriority;
 static const NSTouchBarItemPriority NSTouchBarItemPriorityHigh = 1000;
@@ -149,6 +149,9 @@ static const NSTouchBarItemIdentifier NSTouchBarItemIdentifierOtherItemsProxy =
 
 @end
 
+@interface NSScrubberFlowLayout: NSObject
+@end
+
 @interface NSScrubberSelectionStyle : NSObject<NSCoding>
 
 @property(class, strong, readonly) NSScrubberSelectionStyle* outlineOverlayStyle;
@@ -229,6 +232,12 @@ static const NSTouchBarItemIdentifier NSTouchBarItemIdentifierOtherItemsProxy =
 
 @end
 
+@protocol NSScrubberFlowLayoutDelegate<NSObject>
+
+- (NSSize)scrubber:(NSScrubber *)scrubber layout:(NSScrubberFlowLayout *)layout sizeForItemAtIndex:(NSInteger)itemIndex;
+
+@end
+
 #pragma clang assume_nonnull end
 
 #elif MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_12_1

atom/browser/ui/file_dialog_mac.mm

@@ -40,7 +40,6 @@ void SetAllowedFileTypes(NSSavePanel* dialog, const Filters& filters) {
   if ([file_type_set count])
     file_types = [file_type_set allObjects];
 
-  [dialog setExtensionHidden:NO];
   [dialog setAllowedFileTypes:file_types];
 }
 
@@ -84,11 +83,14 @@ void SetupDialog(NSSavePanel* dialog,
     SetAllowedFileTypes(dialog, settings.filters);
   }
 
+  // Make sure the extension is always visible. Without this, the extension in
+  // the default filename will not be used in the saved file.
+  [dialog setExtensionHidden:NO];
+
   if (default_dir)
     [dialog setDirectoryURL:[NSURL fileURLWithPath:default_dir]];
   if (default_filename)
     [dialog setNameFieldStringValue:default_filename];
-
 }
 
 void SetupDialogForProperties(NSOpenPanel* dialog, int properties) {

atom/browser/web_contents_preferences.cc

@@ -47,6 +47,28 @@ WebContentsPreferences::WebContentsPreferences(
   web_contents->SetUserData(UserDataKey(), this);
 
   instances_.push_back(this);
+
+  // Set WebPreferences defaults onto the JS object
+  SetDefaultBoolIfUndefined("plugins", false);
+  SetDefaultBoolIfUndefined(options::kExperimentalFeatures, false);
+  SetDefaultBoolIfUndefined(options::kExperimentalCanvasFeatures, false);
+  bool node = SetDefaultBoolIfUndefined(options::kNodeIntegration, true);
+  SetDefaultBoolIfUndefined(options::kNodeIntegrationInWorker, false);
+  SetDefaultBoolIfUndefined(options::kWebviewTag, node);
+  SetDefaultBoolIfUndefined("sandbox", false);
+  SetDefaultBoolIfUndefined("nativeWindowOpen", false);
+  SetDefaultBoolIfUndefined(options::kContextIsolation, false);
+  SetDefaultBoolIfUndefined("javascript", true);
+  SetDefaultBoolIfUndefined("images", true);
+  SetDefaultBoolIfUndefined("textAreasAreResizable", true);
+  SetDefaultBoolIfUndefined("webgl", true);
+  SetDefaultBoolIfUndefined("webSecurity", true);
+  SetDefaultBoolIfUndefined("allowRunningInsecureContent", false);
+  #if defined(OS_MACOSX)
+  SetDefaultBoolIfUndefined(options::kScrollBounce, false);
+  #endif
+  SetDefaultBoolIfUndefined("offscreen", false);
+  last_web_preferences_.MergeDictionary(&web_preferences_);
 }
 
 WebContentsPreferences::~WebContentsPreferences() {
@@ -55,6 +77,16 @@ WebContentsPreferences::~WebContentsPreferences() {
       instances_.end());
 }
 
+bool WebContentsPreferences::SetDefaultBoolIfUndefined(const std::string key,
+                                                       bool val) {
+  bool existing;
+  if (!web_preferences_.GetBoolean(key, &existing)) {
+    web_preferences_.SetBoolean(key, val);
+    return val;
+  }
+  return existing;
+}
+
 void WebContentsPreferences::Merge(const base::DictionaryValue& extend) {
   web_preferences_.MergeDictionary(&extend);
 }
@@ -79,6 +111,12 @@ void WebContentsPreferences::AppendExtraCommandLineSwitches(
 
   base::DictionaryValue& web_preferences = self->web_preferences_;
 
+  // We are appending args to a webContents so let's save the current state
+  // of our preferences object so that during the lifetime of the WebContents
+  // we can fetch the options used to initally configure the WebContents
+  self->last_web_preferences_.Clear();
+  self->last_web_preferences_.MergeDictionary(&web_preferences);
+
   bool b;
   // Check if plugins are enabled.
   if (web_preferences.GetBoolean("plugins", &b) && b)

atom/browser/web_contents_preferences.h

@@ -57,6 +57,9 @@ class WebContentsPreferences
 
   // Returns the web preferences.
   base::DictionaryValue* web_preferences() { return &web_preferences_; }
+  base::DictionaryValue* last_web_preferences() {
+    return &last_web_preferences_;
+  }
 
  private:
   friend class content::WebContentsUserData<WebContentsPreferences>;
@@ -65,6 +68,10 @@ class WebContentsPreferences
 
   content::WebContents* web_contents_;
   base::DictionaryValue web_preferences_;
+  base::DictionaryValue last_web_preferences_;
+
+  // Set preference value to given bool if user did not provide value
+  bool SetDefaultBoolIfUndefined(const std::string key, bool val);
 
   // Get preferences value as integer possibly coercing it from a string
   bool GetInteger(const std::string& attributeName, int* intValue);

atom/common/atom_command_line.cc

@@ -10,31 +10,22 @@
 namespace atom {
 
 // static
-std::vector<std::string> AtomCommandLine::argv_;
-
-#if defined(OS_WIN)
-// static
-std::vector<std::wstring> AtomCommandLine::wargv_;
-#endif
+base::CommandLine::StringVector AtomCommandLine::argv_;
 
 // static
-void AtomCommandLine::Init(int argc, const char* const* argv) {
+void AtomCommandLine::Init(int argc, base::CommandLine::CharType** argv) {
+  DCHECK(argv_.empty());
+
+  // NOTE: uv_setup_args does nothing on Windows, so we don't need to call it.
+  // Otherwise we'd have to convert the arguments from UTF16.
+#if !defined(OS_WIN)
   // Hack around with the argv pointer. Used for process.title = "blah"
-  char** new_argv = uv_setup_args(argc, const_cast<char**>(argv));
-  for (int i = 0; i < argc; ++i) {
-    argv_.push_back(new_argv[i]);
-  }
-}
-
-#if defined(OS_WIN)
-// static
-void AtomCommandLine::InitW(int argc, const wchar_t* const* argv) {
-  for (int i = 0; i < argc; ++i) {
-    wargv_.push_back(argv[i]);
-  }
-}
+  argv = uv_setup_args(argc, argv);
 #endif
 
+  argv_.assign(argv, argv + argc);
+}
+
 #if defined(OS_LINUX)
 // static
 void AtomCommandLine::InitializeFromCommandLine() {

atom/common/atom_command_line.h

@@ -8,6 +8,7 @@
 #include <string>
 #include <vector>
 
+#include "base/command_line.h"
 #include "base/macros.h"
 #include "build/build_config.h"
 
@@ -16,13 +17,9 @@ namespace atom {
 // Singleton to remember the original "argc" and "argv".
 class AtomCommandLine {
  public:
-  static void Init(int argc, const char* const* argv);
-  static std::vector<std::string> argv() { return argv_; }
+  static const base::CommandLine::StringVector& argv() { return argv_; }
 
-#if defined(OS_WIN)
-  static void InitW(int argc, const wchar_t* const* argv);
-  static std::vector<std::wstring> wargv() { return wargv_; }
-#endif
+  static void Init(int argc, base::CommandLine::CharType** argv);
 
 #if defined(OS_LINUX)
   // On Linux the command line has to be read from base::CommandLine since
@@ -31,11 +28,7 @@ class AtomCommandLine {
 #endif
 
  private:
-  static std::vector<std::string> argv_;
-
-#if defined(OS_WIN)
-  static std::vector<std::wstring> wargv_;
-#endif
+  static base::CommandLine::StringVector argv_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(AtomCommandLine);
 };

atom/common/atom_version.h

@@ -7,8 +7,8 @@
 
 #define ATOM_MAJOR_VERSION 1
 #define ATOM_MINOR_VERSION 7
-#define ATOM_PATCH_VERSION 6
-
+#define ATOM_PATCH_VERSION 16
+// #define ATOM_PRE_RELEASE_VERSION
 #define ATOM_VERSION_IS_RELEASE 1
 
 #ifndef ATOM_TAG

atom/common/node_bindings.cc

@@ -4,6 +4,7 @@
 
 #include "atom/common/node_bindings.h"
 
+#include <algorithm>
 #include <string>
 #include <vector>
 
@@ -17,6 +18,7 @@
 #include "base/files/file_path.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
+#include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "content/public/browser/browser_thread.h"
@@ -150,7 +152,14 @@ void NodeBindings::Initialize() {
 
 node::Environment* NodeBindings::CreateEnvironment(
     v8::Handle<v8::Context> context) {
+#if defined(OS_WIN)
+  auto& atom_args = AtomCommandLine::argv();
+  std::vector<std::string> args(atom_args.size());
+  std::transform(atom_args.cbegin(), atom_args.cend(), args.begin(),
+                 [](auto& a) { return base::WideToUTF8(a); });
+#else
   auto args = AtomCommandLine::argv();
+#endif
 
   // Feed node the path to initialization script.
   base::FilePath::StringType process_type;
@@ -170,8 +179,7 @@ node::Environment* NodeBindings::CreateEnvironment(
       resources_path.Append(FILE_PATH_LITERAL("electron.asar"))
                     .Append(process_type)
                     .Append(FILE_PATH_LITERAL("init.js"));
-  std::string script_path_str = script_path.AsUTF8Unsafe();
-  args.insert(args.begin() + 1, script_path_str.c_str());
+  args.insert(args.begin() + 1, script_path.AsUTF8Unsafe());
 
   std::unique_ptr<const char*[]> c_argv = StringVectorToArgArray(args);
   node::Environment* env = node::CreateEnvironment(

brightray/browser/mac/cocoa_notification.mm

@@ -39,6 +39,8 @@ void CocoaNotification::Show(const NotificationOptions& options) {
 
   if (options.silent) {
     [notification_ setSoundName:nil];
+  } else if (options.sound != nil) {
+    [notification_ setSoundName:base::SysUTF16ToNSString(options.sound)];
   } else {
     [notification_ setSoundName:NSUserNotificationDefaultSoundName];
   }

brightray/browser/notification.h

@@ -33,6 +33,7 @@ struct NotificationOptions {
   bool silent;
   bool has_reply;
   base::string16 reply_placeholder;
+  base::string16 sound;
   std::vector<NotificationAction> actions;
 };
 

chromium_src/chrome/browser/process_singleton.h

@@ -74,6 +74,8 @@ class ProcessSingleton : public base::NonThreadSafe {
   // TODO(brettw): Make the implementation of this method non-platform-specific
   // by making Linux re-use the Windows implementation.
   NotifyResult NotifyOtherProcessOrCreate();
+  void StartListeningOnSocket();
+  void OnBrowserReady();
 
   // Sets ourself up as the singleton instance.  Returns true on success.  If
   // false is returned, we are not the singleton instance and the caller must
@@ -173,6 +175,8 @@ class ProcessSingleton : public base::NonThreadSafe {
   // because it posts messages between threads.
   class LinuxWatcher;
   scoped_refptr<LinuxWatcher> watcher_;
+  int sock_;
+  bool listen_on_ready_ = false;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(ProcessSingleton);

chromium_src/chrome/browser/process_singleton_posix.cc

@@ -55,6 +55,7 @@
 
 #include <stddef.h>
 
+#include "atom/browser/browser.h"
 #include "atom/common/atom_command_line.h"
 
 #include "base/base_paths.h"
@@ -719,8 +720,7 @@ ProcessSingleton::ProcessSingleton(
     const base::FilePath& user_data_dir,
     const NotificationCallback& notification_callback)
     : notification_callback_(notification_callback),
-      current_pid_(base::GetCurrentProcId()),
-      watcher_(new LinuxWatcher(this)) {
+      current_pid_(base::GetCurrentProcId()) {
   // The user_data_dir may have not been created yet.
   base::CreateDirectoryAndGetError(user_data_dir, nullptr);
 
@@ -881,6 +881,23 @@ ProcessSingleton::NotifyResult ProcessSingleton::NotifyOtherProcessOrCreate() {
       base::TimeDelta::FromSeconds(kTimeoutInSeconds));
 }
 
+void ProcessSingleton::StartListeningOnSocket() {
+  watcher_ = new LinuxWatcher(this);
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&ProcessSingleton::LinuxWatcher::StartListening,
+                 watcher_,
+                 sock_));
+}
+
+void ProcessSingleton::OnBrowserReady() {
+  if (listen_on_ready_) {
+    StartListeningOnSocket();
+    listen_on_ready_ = false;
+  }
+}
+
 ProcessSingleton::NotifyResult
 ProcessSingleton::NotifyOtherProcessWithTimeoutOrCreate(
     const base::CommandLine& command_line,
@@ -1031,13 +1048,13 @@ bool ProcessSingleton::Create() {
   if (listen(sock, 5) < 0)
     NOTREACHED() << "listen failed: " << base::safe_strerror(errno);
 
-  DCHECK(BrowserThread::IsMessageLoopValid(BrowserThread::IO));
-  BrowserThread::PostTask(
-      BrowserThread::IO,
-      FROM_HERE,
-      base::Bind(&ProcessSingleton::LinuxWatcher::StartListening,
-                 watcher_,
-                 sock));
+  sock_ = sock;
+
+  if (BrowserThread::IsMessageLoopValid(BrowserThread::IO)) {
+    StartListeningOnSocket();
+  } else {
+    listen_on_ready_ = true;
+  }
 
   return true;
 }

chromium_src/chrome/browser/process_singleton_win.cc

@@ -258,6 +258,9 @@ ProcessSingleton::NotifyOtherProcessOrCreate() {
   return result;
 }
 
+void ProcessSingleton::StartListeningOnSocket() {}
+void ProcessSingleton::OnBrowserReady() {}
+
 // Look for a Chrome instance that uses the same profile directory. If there
 // isn't one, create a message window with its title set to the profile
 // directory path.

docs/api/notification.md

@@ -37,6 +37,7 @@ Returns `Boolean` - Whether or not desktop notifications are supported on the cu
   * `icon` [NativeImage](native-image.md) - (optional) An icon to use in the notification
   * `hasReply` Boolean - (optional) Whether or not to add an inline reply option to the notification.  _macOS_
   * `replyPlaceholder` String - (optional) The placeholder to write in the inline reply input field. _macOS_
+  * `sound` String - (optional) The name of the sound file to play when the notification is shown. _macOS_
   * `actions` [NotificationAction[]](structures/notification-action.md) - (optional) Actions to add to the notification.  Please read the available actions and limitations in the `NotificationAction` documentation _macOS_
 
 
@@ -102,3 +103,18 @@ Immediately shows the notification to the user, please note this means unlike th
 HTML5 Notification implementation, simply instantiating a `new Notification` does
 not immediately show it to the user, you need to call this method before the OS
 will display it.
+
+### Playing Sounds
+
+On macOS, you can specify the name of the sound you'd like to play when the
+notification is shown. Any of the default sounds (under System Preferences >
+Sound) can be used, in addition to custom sound files. Be sure that the sound
+file is copied under the app bundle (e.g., `YourApp.app/Contents/Resources`),
+or one of the following locations:
+
+* `~/Library/Sounds`
+* `/Library/Sounds`
+* `/Network/Library/Sounds`
+* `/System/Library/Sounds`
+
+See the [`NSSound`](https://developer.apple.com/documentation/appkit/nssound) docs for more information.

docs/api/touch-bar-button.md

@@ -11,7 +11,7 @@ Process: [Main](../tutorial/quick-start.md#main-process)
   * `backgroundColor` String (optional) - Button background color in hex format,
     i.e `#ABCDEF`.
   * `icon` [NativeImage](native-image.md) (optional) - Button icon.
-  * `iconPosition` String - Can be `left`, `right` or `overlay`.
+  * `iconPosition` String (optional) - Can be `left`, `right` or `overlay`.
   * `click` Function (optional) - Function to call when the button is clicked.
 
 ### Instance Properties

electron.gyp

@@ -4,7 +4,7 @@
     'product_name%': 'Electron',
     'company_name%': 'GitHub, Inc',
     'company_abbr%': 'github',
-    'version%': '1.7.6',
+    'version%': '1.7.16',
     'js2c_input_dir': '<(SHARED_INTERMEDIATE_DIR)/js2c',
   },
   'includes': [
@@ -217,6 +217,11 @@
               ],
             },
           ],
+          'link_settings': {
+            'ldflags': [
+              '-Wl,-z,noexecstack',
+            ],
+          },
         }],  # OS=="linux"
       ],
     },  # target <(project_name)

filenames.gypi

@@ -98,6 +98,8 @@
       'atom/app/atom_main_delegate.cc',
       'atom/app/atom_main_delegate.h',
       'atom/app/atom_main_delegate_mac.mm',
+      'atom/app/command_line_args.cc',
+      'atom/app/command_line_args.h',
       'atom/app/node_main.cc',
       'atom/app/node_main.h',
       'atom/app/uv_task_runner.cc',

lib/browser/api/auto-updater/auto-updater-win.js

@@ -29,7 +29,7 @@ class AutoUpdater extends EventEmitter {
       return this.emitError('Can not find Squirrel')
     }
     this.emit('checking-for-update')
-    squirrelUpdate.download(this.updateURL, (error, update) => {
+    squirrelUpdate.checkForUpdate(this.updateURL, (error, update) => {
       if (error != null) {
         return this.emitError(error)
       }

lib/browser/api/auto-updater/squirrel-update-win.js

@@ -82,8 +82,8 @@ exports.processStart = function () {
 }
 
 // Download the releases specified by the URL and write new results to stdout.
-exports.download = function (updateURL, callback) {
-  return spawnUpdate(['--download', updateURL], false, function (error, stdout) {
+exports.checkForUpdate = function (updateURL, callback) {
+  return spawnUpdate(['--checkForUpdate', updateURL], false, function (error, stdout) {
     var json, ref, ref1, update
     if (error != null) {
       return callback(error)

lib/browser/guest-view-manager.js

@@ -155,7 +155,7 @@ const createGuest = function (embedder, params) {
   // Forward internal web contents event to embedder to handle
   // native window.open setup
   guest.on('-add-new-contents', (...args) => {
-    if (guest.getWebPreferences().nativeWindowOpen === true) {
+    if (guest.getLastWebPreferences().nativeWindowOpen === true) {
       const embedder = getEmbedder(guestInstanceId)
       if (embedder != null) {
         embedder.emit('-add-new-contents', ...args)
@@ -163,7 +163,7 @@ const createGuest = function (embedder, params) {
     }
   })
   guest.on('-web-contents-created', (...args) => {
-    if (guest.getWebPreferences().nativeWindowOpen === true) {
+    if (guest.getLastWebPreferences().nativeWindowOpen === true) {
       const embedder = getEmbedder(guestInstanceId)
       if (embedder != null) {
         embedder.emit('-web-contents-created', ...args)

lib/browser/guest-window-manager.js

@@ -26,11 +26,11 @@ const mergeOptions = function (child, parent, visited) {
   visited.add(parent)
   for (const key in parent) {
     if (!hasProp.call(parent, key)) continue
-    if (key in child) continue
+    if (key in child && key !== 'webPreferences') continue
 
     const value = parent[key]
     if (typeof value === 'object') {
-      child[key] = mergeOptions({}, value, visited)
+      child[key] = mergeOptions(child[key] || {}, value, visited)
     } else {
       child[key] = value
     }
@@ -50,12 +50,12 @@ const mergeBrowserWindowOptions = function (embedder, options) {
     mergeOptions(options, embedder.browserWindowOptions)
   } else {
     // Or only inherit webPreferences if it is a webview.
-    mergeOptions(options.webPreferences, embedder.getWebPreferences())
+    mergeOptions(options.webPreferences, embedder.getLastWebPreferences())
   }
 
   // Inherit certain option values from parent window
   for (const [name, value] of inheritedWebPreferences) {
-    if (embedder.getWebPreferences()[name] === value) {
+    if (embedder.getLastWebPreferences()[name] === value) {
       options.webPreferences[name] = value
     }
   }
@@ -168,8 +168,8 @@ const getGuestWindow = function (guestContents) {
 // The W3C does not have anything on this, but from my understanding of the
 // security model of |window.opener|, this should be fine.
 const canAccessWindow = function (sender, target) {
-  return (target.getWebPreferences().openerId === sender.id) ||
-         (sender.getWebPreferences().nodeIntegration === true) ||
+  return (target.getLastWebPreferences().openerId === sender.id) ||
+         (sender.getLastWebPreferences().nodeIntegration === true) ||
          isSameOrigin(sender.getURL(), target.getURL())
 }
 

package.json

@@ -1,21 +1,27 @@
 {
   "name": "electron",
-  "version": "1.7.6",
+  "version": "1.7.16",
   "repository": "https://github.com/electron/electron",
   "description": "Build cross platform desktop apps with JavaScript, HTML, and CSS",
   "devDependencies": {
     "asar": "^0.11.0",
     "browserify": "^13.1.0",
     "check-for-leaks": "^1.0.2",
+    "colors": "^1.1.2",
     "dotenv-safe": "^4.0.4",
+    "dugite": "^1.45.0",
     "electabul": "~0.0.4",
     "electron-docs-linter": "^2.3.3",
-    "electron-typescript-definitions": "^1.2.7",
+    "electron-typescript-definitions": "~1.2.11",
     "github": "^9.2.0",
+    "heads": "^1.3.0",
     "husky": "^0.14.3",
+    "minimist": "^1.2.0",
+    "nugget": "^2.0.1",
     "request": "^2.68.0",
     "standard": "^8.4.0",
     "standard-markdown": "^4.0.0",
+    "sumchecker": "^2.0.2",
     "temp": "^0.8.3"
   },
   "standard": {
@@ -47,11 +53,15 @@
     "lint-api-docs-js": "standard-markdown docs && standard-markdown docs-translations",
     "create-api-json": "electron-docs-linter docs --outfile=out/electron-api.json --version=$npm_package_version",
     "create-typescript-definitions": "npm run create-api-json && electron-typescript-definitions --in=out/electron-api.json --out=out/electron.d.ts",
+    "merge-release": "node ./script/merge-release.js",
+    "mock-release": "node ./script/ci-release-build.js",
     "preinstall": "node -e 'process.exit(0)'",
     "publish-to-npm": "node ./script/publish-to-npm.js",
     "prepack": "check-for-leaks",
     "prepush": "check-for-leaks",
-    "release": "./script/upload.py -p",
+    "prepare-release": "node ./script/prepare-release.js",
+    "prerelease": "python ./script/bootstrap.py -v --dev && npm run build",
+    "release": "node ./script/release.js",
     "repl": "python ./script/start.py --interactive",
     "start": "python ./script/start.py",
     "test": "python ./script/test.py"

script/bump-version.py

@@ -3,6 +3,7 @@
 import os
 import re
 import sys
+import argparse
 
 from lib.util import execute, get_electron_version, parse_version, scoped_cwd
 
@@ -11,29 +12,85 @@ SOURCE_ROOT = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))
 
 
 def main():
-  if len(sys.argv) != 2 or sys.argv[1] == '-h':
-    print 'Usage: bump-version.py [<version> | major | minor | patch]'
+
+  parser = argparse.ArgumentParser(
+    description='Bump version numbers. Must specify at least one of the three'
+               +' options:\n'
+               +'   --bump=patch to increment patch version, or\n'
+               +'   --stable to promote current beta to stable, or\n'
+               +'   --version={version} to set version number directly\n'
+               +'Note that you can use both --bump and --stable '
+               +'simultaneously.',
+               formatter_class=argparse.RawTextHelpFormatter
+  )
+  parser.add_argument(
+    '--version',
+    default=None,
+    dest='new_version',
+    help='new version number'
+  )
+  parser.add_argument(
+    '--bump',
+    action='store',
+    default=None,
+    dest='bump',
+    help='increment [major | minor | patch | beta]'
+  )
+  parser.add_argument(
+    '--stable',
+    action='store_true',
+    default= False,
+    dest='stable',
+    help='promote to stable (i.e. remove `-beta.x` suffix)'
+  )
+  parser.add_argument(
+    '--dry-run',
+    action='store_true',
+    default= False,
+    dest='dry_run',
+    help='just to check that version number is correct'
+  )
+
+  args = parser.parse_args()
+
+  if args.new_version == None and args.bump == None and args.stable == False:
+    parser.print_help()
     return 1
 
-  option = sys.argv[1]
-  increments = ['major', 'minor', 'patch', 'build']
-  if option in increments:
-    version = get_electron_version()
-    versions = parse_version(version.split('-')[0])
-    versions = increase_version(versions, increments.index(option))
-  else:
-    versions = parse_version(option)
+  increments = ['major', 'minor', 'patch', 'beta']
+
+  curr_version = get_electron_version()
+  versions = parse_version(re.sub('-beta', '', curr_version))
+
+  if args.bump in increments:
+    versions = increase_version(versions, increments.index(args.bump))
+    if versions[3] == '0':
+      # beta starts at 1
+      versions = increase_version(versions, increments.index('beta'))
+
+  if args.stable == True:
+    versions[3] = '0'
+
+  if args.new_version != None:
+    versions = parse_version(re.sub('-beta', '', args.new_version))
 
   version = '.'.join(versions[:3])
+  suffix = '' if versions[3] == '0' else '-beta.' + versions[3]
+
+  if args.dry_run:
+    print 'new version number would be: {0}\n'.format(version + suffix)
+    return 0
+
 
   with scoped_cwd(SOURCE_ROOT):
-    update_electron_gyp(version)
+    update_electron_gyp(version, suffix)
     update_win_rc(version, versions)
-    update_version_h(versions)
+    update_version_h(versions, suffix)
     update_info_plist(version)
-    update_package_json(version)
-    tag_version(version)
+    update_package_json(version, suffix)
+    tag_version(version, suffix)
 
+  print 'Bumped to version: {0}'.format(version + suffix)
 
 def increase_version(versions, index):
   for i in range(index + 1, 4):
@@ -42,14 +99,14 @@ def increase_version(versions, index):
   return versions
 
 
-def update_electron_gyp(version):
-  pattern = re.compile(" *'version%' *: *'[0-9.]+'")
+def update_electron_gyp(version, suffix):
+  pattern = re.compile(" *'version%' *: *'[0-9.]+(-beta[0-9.]*)?'")
   with open('electron.gyp', 'r') as f:
     lines = f.readlines()
 
   for i in range(0, len(lines)):
     if pattern.match(lines[i]):
-      lines[i] = "    'version%': '{0}',\n".format(version)
+      lines[i] = "    'version%': '{0}',\n".format(version + suffix)
       with open('electron.gyp', 'w') as f:
         f.write(''.join(lines))
       return
@@ -81,7 +138,7 @@ def update_win_rc(version, versions):
     f.write(''.join(lines))
 
 
-def update_version_h(versions):
+def update_version_h(versions, suffix):
   version_h = os.path.join('atom', 'common', 'atom_version.h')
   with open(version_h, 'r') as f:
     lines = f.readlines()
@@ -93,6 +150,11 @@ def update_version_h(versions):
       lines[i + 1] = '#define ATOM_MINOR_VERSION {0}\n'.format(versions[1])
       lines[i + 2] = '#define ATOM_PATCH_VERSION {0}\n'.format(versions[2])
 
+      if (suffix):
+        lines[i + 3] = '#define ATOM_PRE_RELEASE_VERSION {0}\n'.format(suffix)
+      else:
+        lines[i + 3] = '// #define ATOM_PRE_RELEASE_VERSION\n'
+
       with open(version_h, 'w') as f:
         f.write(''.join(lines))
       return
@@ -114,7 +176,7 @@ def update_info_plist(version):
     f.write(''.join(lines))
 
 
-def update_package_json(version):
+def update_package_json(version, suffix):
   package_json = 'package.json'
   with open(package_json, 'r') as f:
     lines = f.readlines()
@@ -122,15 +184,15 @@ def update_package_json(version):
   for i in range(0, len(lines)):
     line = lines[i];
     if 'version' in line:
-      lines[i] = '  "version": "{0}",\n'.format(version)
+      lines[i] = '  "version": "{0}",\n'.format(version + suffix)
       break
 
   with open(package_json, 'w') as f:
     f.write(''.join(lines))
 
 
-def tag_version(version):
-  execute(['git', 'commit', '-a', '-m', 'Bump v{0}'.format(version)])
+def tag_version(version, suffix):
+  execute(['git', 'commit', '-a', '-m', 'Bump v{0}'.format(version + suffix)])
 
 
 if __name__ == '__main__':

script/ci-release-build.js

@@ -0,0 +1,136 @@
+const assert = require('assert')
+const request = require('request')
+const buildAppVeyorURL = 'https://windows-ci.electronjs.org/api/builds'
+
+const circleCIJobs = [
+  'electron-linux-arm',
+  'electron-linux-ia32',
+  'electron-linux-x64'
+]
+
+async function makeRequest (requestOptions, parseResponse) {
+  return new Promise((resolve, reject) => {
+    request(requestOptions, (err, res, body) => {
+      if (!err && res.statusCode >= 200 && res.statusCode < 300) {
+        if (parseResponse) {
+          const build = JSON.parse(body)
+          resolve(build)
+        } else {
+          resolve(body)
+        }
+      } else {
+        if (parseResponse) {
+          console.log('Error: ', `(status ${res.statusCode})`, err || JSON.parse(res.body), requestOptions)
+        } else {
+          console.log('Error: ', `(status ${res.statusCode})`, err || res.body, requestOptions)
+        }
+        reject(err)
+      }
+    })
+  })
+}
+
+async function circleCIcall (buildUrl, targetBranch, job, ghRelease) {
+  assert(process.env.CIRCLE_TOKEN, 'CIRCLE_TOKEN not found in environment')
+  console.log(`Triggering CircleCI to run build job: ${job} on branch: ${targetBranch} with release flag.`)
+  let buildRequest = {
+    'build_parameters': {
+      'CIRCLE_JOB': job
+    }
+  }
+
+  if (ghRelease) {
+    buildRequest.build_parameters.ELECTRON_RELEASE = 1
+  } else {
+    buildRequest.build_parameters.RUN_RELEASE_BUILD = 'true'
+  }
+
+  let circleResponse = await makeRequest({
+    method: 'POST',
+    url: buildUrl,
+    headers: {
+      'Content-Type': 'application/json',
+      'Accept': 'application/json'
+    },
+    body: JSON.stringify(buildRequest)
+  }, true).catch(err => {
+    console.log('Error calling CircleCI:', err)
+  })
+  console.log(`Check ${circleResponse.build_url} for status. (${job})`)
+}
+
+async function buildAppVeyor (targetBranch, ghRelease) {
+  console.log(`Triggering AppVeyor to run build on branch: ${targetBranch} with release flag.`)
+  assert(process.env.APPVEYOR_TOKEN, 'APPVEYOR_TOKEN not found in environment')
+  let environmentVariables = {}
+
+  if (ghRelease) {
+    environmentVariables.ELECTRON_RELEASE = 1
+  } else {
+    environmentVariables.RUN_RELEASE_BUILD = 'true'
+  }
+
+  const requestOpts = {
+    url: buildAppVeyorURL,
+    auth: {
+      bearer: process.env.APPVEYOR_TOKEN
+    },
+    headers: {
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify({
+      accountName: 'AppVeyor',
+      projectSlug: 'electron',
+      branch: targetBranch,
+      environmentVariables
+    }),
+    method: 'POST'
+  }
+  let appVeyorResponse = await makeRequest(requestOpts, true).catch(err => {
+    console.log('Error calling AppVeyor:', err)
+  })
+  const buildUrl = `https://windows-ci.electronjs.org/project/AppVeyor/electron/build/${appVeyorResponse.version}`
+  console.log(`AppVeyor release build request successful.  Check build status at ${buildUrl}`)
+}
+
+function buildCircleCI (targetBranch, ghRelease, job) {
+  const circleBuildUrl = `https://circleci.com/api/v1.1/project/github/electron/electron/tree/${targetBranch}?circle-token=${process.env.CIRCLE_TOKEN}`
+  if (job) {
+    assert(circleCIJobs.includes(job), `Unknown CI job name: ${job}.`)
+    circleCIcall(circleBuildUrl, targetBranch, job, ghRelease)
+  } else {
+    circleCIJobs.forEach((job) => circleCIcall(circleBuildUrl, targetBranch, job, ghRelease))
+  }
+}
+
+function runRelease (targetBranch, options) {
+  if (options.ci) {
+    switch (options.ci) {
+      case 'CircleCI': {
+        buildCircleCI(targetBranch, options.ghRelease, options.job)
+        break
+      }
+      case 'AppVeyor': {
+        buildAppVeyor(targetBranch, options.ghRelease)
+        break
+      }
+    }
+  } else {
+    buildCircleCI(targetBranch, options.ghRelease, options.job)
+    buildAppVeyor(targetBranch, options.ghRelease)
+  }
+}
+
+module.exports = runRelease
+
+if (require.main === module) {
+  const args = require('minimist')(process.argv.slice(2))
+  const targetBranch = args._[0]
+  if (args._.length < 1) {
+    console.log(`Trigger CI to build release builds of electron.
+    Usage: ci-release-build.js [--job=CI_JOB_NAME] [--ci=CircleCI|AppVeyor] [--ghRelease] TARGET_BRANCH
+    `)
+    process.exit(0)
+  }
+  runRelease(targetBranch, args)
+}

script/cibuild

@@ -63,10 +63,9 @@ def main():
       deps += LINUX_DEPS_NO_ARM
     execute(['sudo', 'apt-get', 'install'] + deps)
 
-    execute(['sh', '-e', '/etc/init.d/xvfb', 'start'])
-
-  if PLATFORM == 'linux':
+  if PLATFORM == 'linux' and target_arch == 'x64':
     os.environ['DISPLAY'] = ':99.0'
+    execute(['sh', '-e', '/etc/init.d/xvfb', 'start'])
 
   # CI's npm is not reliable.
   npm = 'npm.cmd' if PLATFORM == 'win32' else 'npm'

script/merge-release.js

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+
+require('colors')
+const assert = require('assert')
+const branchToRelease = process.argv[2]
+const fail = '\u2717'.red
+const { GitProcess, GitError } = require('dugite')
+const pass = '\u2713'.green
+const path = require('path')
+const pkg = require('../package.json')
+
+assert(process.env.ELECTRON_GITHUB_TOKEN, 'ELECTRON_GITHUB_TOKEN not found in environment')
+if (!branchToRelease) {
+  console.log(`Usage: merge-release branch`)
+  process.exit(1)
+}
+const gitDir = path.resolve(__dirname, '..')
+
+async function callGit (args, errorMessage, successMessage) {
+  let gitResult = await GitProcess.exec(args, gitDir)
+  if (gitResult.exitCode === 0) {
+    console.log(`${pass} ${successMessage}`)
+    return true
+  } else {
+    console.log(`${fail} ${errorMessage} ${gitResult.stderr}`)
+    process.exit(1)
+  }
+}
+
+async function checkoutBranch (branchName) {
+  console.log(`Checking out ${branchName}.`)
+  let errorMessage = `Error checking out branch ${branchName}:`
+  let successMessage = `Successfully checked out branch ${branchName}.`
+  return callGit(['checkout', branchName], errorMessage, successMessage)
+}
+
+async function commitMerge () {
+  console.log(`Committing the merge for v${pkg.version}`)
+  let errorMessage = `Error committing merge:`
+  let successMessage = `Successfully committed the merge for v${pkg.version}`
+  let gitArgs = ['commit', '-m', `v${pkg.version}`]
+  return callGit(gitArgs, errorMessage, successMessage)
+}
+
+async function mergeReleaseIntoBranch (branchName) {
+  console.log(`Merging release branch into ${branchName}.`)
+  let mergeArgs = ['merge', 'release-1-7-x', '--squash']
+  let mergeDetails = await GitProcess.exec(mergeArgs, gitDir)
+  if (mergeDetails.exitCode === 0) {
+    return true
+  } else {
+    const error = GitProcess.parseError(mergeDetails.stderr)
+    if (error === GitError.MergeConflicts) {
+      console.log(`${fail} Could not merge release branch into ${branchName} ` +
+        `due to merge conflicts.`)
+      return false
+    } else {
+      console.log(`${fail} Could not merge release branch into ${branchName} ` +
+        `due to an error: ${mergeDetails.stderr}.`)
+      process.exit(1)
+    }
+  }
+}
+
+async function pushBranch (branchName) {
+  console.log(`Pushing branch ${branchName}.`)
+  let pushArgs = ['push', 'origin', branchName]
+  let errorMessage = `Could not push branch ${branchName} due to an error:`
+  let successMessage = `Successfully pushed branch ${branchName}.`
+  return callGit(pushArgs, errorMessage, successMessage)
+}
+
+async function pull () {
+  console.log(`Performing a git pull`)
+  let errorMessage = `Could not pull due to an error:`
+  let successMessage = `Successfully performed a git pull`
+  return callGit(['pull'], errorMessage, successMessage)
+}
+
+async function rebase (targetBranch) {
+  console.log(`Rebasing release branch from ${targetBranch}`)
+  let errorMessage = `Could not rebase due to an error:`
+  let successMessage = `Successfully rebased release branch from ` +
+    `${targetBranch}`
+  return callGit(['rebase', targetBranch], errorMessage, successMessage)
+}
+
+async function mergeRelease () {
+  await checkoutBranch(branchToRelease)
+  let mergeSuccess = await mergeReleaseIntoBranch(branchToRelease)
+  if (mergeSuccess) {
+    console.log(`${pass} Successfully merged release branch into ` +
+      `${branchToRelease}.`)
+    await commitMerge()
+    let pushSuccess = await pushBranch(branchToRelease)
+    if (pushSuccess) {
+      console.log(`${pass} Success!!! ${branchToRelease} now has the latest release!`)
+    }
+  } else {
+    console.log(`Trying rebase of ${branchToRelease} into release branch.`)
+    await pull()
+    await checkoutBranch('release-1-7-x')
+    let rebaseResult = await rebase(branchToRelease)
+    if (rebaseResult) {
+      let pushResult = pushBranch('HEAD')
+      if (pushResult) {
+        console.log(`Rebase of ${branchToRelease} into release branch was ` +
+          `successful.  Let release builds run and then try this step again.`)
+      }
+      // Exit as failure so release doesn't continue
+      process.exit(1)
+    }
+  }
+}
+
+mergeRelease()

script/prepare-release.js

@@ -0,0 +1,251 @@
+#!/usr/bin/env node
+
+require('colors')
+const args = require('minimist')(process.argv.slice(2))
+const assert = require('assert')
+const ciReleaseBuild = require('./ci-release-build')
+const { execSync } = require('child_process')
+const fail = '\u2717'.red
+const { GitProcess, GitError } = require('dugite')
+const GitHub = require('github')
+const pass = '\u2713'.green
+const path = require('path')
+const pkg = require('../package.json')
+const readline = require('readline')
+const versionType = args._[0]
+
+// TODO (future) automatically determine version based on conventional commits
+// via conventional-recommended-bump
+
+assert(process.env.ELECTRON_GITHUB_TOKEN, 'ELECTRON_GITHUB_TOKEN not found in environment')
+if (!versionType && !args.notesOnly) {
+  console.log(`Usage: prepare-release versionType [major | minor | patch | beta]` +
+     ` (--stable) (--notesOnly)`)
+  process.exit(1)
+}
+
+const github = new GitHub()
+const gitDir = path.resolve(__dirname, '..')
+github.authenticate({type: 'token', token: process.env.ELECTRON_GITHUB_TOKEN})
+
+async function createReleaseBranch () {
+  console.log(`Creating release branch.`)
+  let checkoutDetails = await GitProcess.exec([ 'checkout', '-b', 'release-1-7-x' ], gitDir)
+  if (checkoutDetails.exitCode === 0) {
+    console.log(`${pass} Successfully created the release branch.`)
+  } else {
+    const error = GitProcess.parseError(checkoutDetails.stderr)
+    if (error === GitError.BranchAlreadyExists) {
+      console.log(`${fail} Release branch already exists, aborting prepare ` +
+        `release process.`)
+    } else {
+      console.log(`${fail} Error creating release branch: ` +
+        `${checkoutDetails.stderr}`)
+    }
+    process.exit(1)
+  }
+}
+
+function getNewVersion (dryRun) {
+  console.log(`Bumping for new "${versionType}" version.`)
+  let bumpScript = path.join(__dirname, 'bump-version.py')
+  let scriptArgs = [bumpScript, `--bump ${versionType}`]
+  if (args.stable) {
+    scriptArgs.push('--stable')
+  }
+  if (dryRun) {
+    scriptArgs.push('--dry-run')
+  }
+  try {
+    let bumpVersion = execSync(scriptArgs.join(' '), {encoding: 'UTF-8'})
+    bumpVersion = bumpVersion.substr(bumpVersion.indexOf(':') + 1).trim()
+    let newVersion = `v${bumpVersion}`
+    if (!dryRun) {
+      console.log(`${pass} Successfully bumped version to ${newVersion}`)
+    }
+    return newVersion
+  } catch (err) {
+    console.log(`${fail} Could not bump version, error was:`, err)
+  }
+}
+
+async function getCurrentBranch (gitDir) {
+  console.log(`Determining current git branch`)
+  let gitArgs = ['rev-parse', '--abbrev-ref', 'HEAD']
+  let branchDetails = await GitProcess.exec(gitArgs, gitDir)
+  if (branchDetails.exitCode === 0) {
+    let currentBranch = branchDetails.stdout.trim()
+    console.log(`${pass} Successfully determined current git branch is ` +
+      `${currentBranch}`)
+    return currentBranch
+  } else {
+    let error = GitProcess.parseError(branchDetails.stderr)
+    console.log(`${fail} Could not get details for the current branch,
+      error was ${branchDetails.stderr}`, error)
+    process.exit(1)
+  }
+}
+
+async function getReleaseNotes (currentBranch) {
+  console.log(`Generating release notes for ${currentBranch}.`)
+  let githubOpts = {
+    owner: 'electron',
+    repo: 'electron',
+    base: `v${pkg.version}`,
+    head: currentBranch
+  }
+  let releaseNotes
+  if (args.automaticRelease) {
+    releaseNotes = '## Bug Fixes/Changes \n\n'
+  } else {
+    releaseNotes = '(placeholder)\n'
+  }
+  console.log(`Checking for commits from ${pkg.version} to ${currentBranch}`)
+  let commitComparison = await github.repos.compareCommits(githubOpts)
+    .catch(err => {
+      console.log(`${fail} Error checking for commits from ${pkg.version} to ` +
+        `${currentBranch}`, err)
+      process.exit(1)
+    })
+
+  if (commitComparison.data.commits.length === 0) {
+    console.log(`${pass} There are no commits from ${pkg.version} to ` +
+      `${currentBranch}, skipping release.`)
+    process.exit(0)
+  }
+
+  let prCount = 0
+  const mergeRE = /Merge pull request #(\d+) from .*\n/
+  const newlineRE = /(.*)\n*.*/
+  const prRE = /(.* )\(#(\d+)\)(?:.*)/
+  commitComparison.data.commits.forEach(commitEntry => {
+    let commitMessage = commitEntry.commit.message
+    if (commitMessage.indexOf('#') > -1) {
+      let prMatch = commitMessage.match(mergeRE)
+      let prNumber
+      if (prMatch) {
+        commitMessage = commitMessage.replace(mergeRE, '').replace('\n', '')
+        let newlineMatch = commitMessage.match(newlineRE)
+        if (newlineMatch) {
+          commitMessage = newlineMatch[1]
+        }
+        prNumber = prMatch[1]
+      } else {
+        prMatch = commitMessage.match(prRE)
+        if (prMatch) {
+          commitMessage = prMatch[1].trim()
+          prNumber = prMatch[2]
+        }
+      }
+      if (prMatch) {
+        if (commitMessage.substr(commitMessage.length - 1, commitMessage.length) !== '.') {
+          commitMessage += '.'
+        }
+        releaseNotes += `* ${commitMessage} #${prNumber} \n\n`
+        prCount++
+      }
+    }
+  })
+  console.log(`${pass} Done generating release notes for ${currentBranch}. Found ${prCount} PRs.`)
+  return releaseNotes
+}
+
+async function createRelease (branchToTarget, isBeta) {
+  let releaseNotes = await getReleaseNotes(branchToTarget)
+  let newVersion = getNewVersion()
+  const githubOpts = {
+    owner: 'electron',
+    repo: 'electron'
+  }
+  console.log(`Checking for existing draft release.`)
+  let releases = await github.repos.getReleases(githubOpts)
+    .catch(err => {
+      console.log('$fail} Could not get releases.  Error was', err)
+    })
+  let drafts = releases.data.filter(release => release.draft &&
+    release.tag_name === newVersion)
+  if (drafts.length > 0) {
+    console.log(`${fail} Aborting because draft release for
+      ${drafts[0].tag_name} already exists.`)
+    process.exit(1)
+  }
+  console.log(`${pass} A draft release does not exist; creating one.`)
+  githubOpts.draft = true
+  githubOpts.name = `electron ${newVersion}`
+  if (isBeta) {
+    githubOpts.body = `Note: This is a beta release.  Please file new issues ` +
+      `for any bugs you find in it.\n \n This release is published to npm ` +
+      `under the beta tag and can be installed via npm install electron@beta, ` +
+      `or npm i electron@${newVersion.substr(1)}.\n \n ${releaseNotes}`
+    githubOpts.name = `${githubOpts.name}`
+    githubOpts.prerelease = true
+  } else {
+    githubOpts.body = releaseNotes
+  }
+  githubOpts.tag_name = newVersion
+  githubOpts.target_commitish = branchToTarget
+  await github.repos.createRelease(githubOpts)
+    .catch(err => {
+      console.log(`${fail} Error creating new release: `, err)
+      process.exit(1)
+    })
+  console.log(`${pass} Draft release for ${newVersion} has been created.`)
+}
+
+async function pushRelease () {
+  let pushDetails = await GitProcess.exec(['push', 'origin', 'HEAD'], gitDir)
+  if (pushDetails.exitCode === 0) {
+    console.log(`${pass} Successfully pushed the release branch.  Wait for ` +
+      `release builds to finish before running "npm run release".`)
+  } else {
+    console.log(`${fail} Error pushing the release branch: ` +
+        `${pushDetails.stderr}`)
+    process.exit(1)
+  }
+}
+
+async function runReleaseBuilds () {
+  await ciReleaseBuild('release-1-7-x', {
+    ghRelease: true
+  })
+}
+
+async function verifyNewVersion () {
+  let newVersion = await getNewVersion(true)
+  let response = await promptForVersion(newVersion)
+  if (response.match(/^y/i)) {
+    console.log(`${pass} Starting release of ${newVersion}`)
+  } else {
+    console.log(`${fail} Aborting release of ${newVersion}`)
+    process.exit()
+  }
+}
+
+async function promptForVersion (version) {
+  return new Promise((resolve, reject) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    })
+    rl.question(`Do you want to create the release ${version.green} (y/N)? `, (answer) => {
+      rl.close()
+      resolve(answer)
+    })
+  })
+}
+
+async function prepareRelease (isBeta, notesOnly) {
+  let currentBranch = await getCurrentBranch(gitDir)
+  if (notesOnly) {
+    let releaseNotes = await getReleaseNotes(currentBranch)
+    console.log(`Draft release notes are: ${releaseNotes}`)
+  } else {
+    await verifyNewVersion()
+    await createReleaseBranch()
+    await createRelease(currentBranch, isBeta)
+    await pushRelease()
+    await runReleaseBuilds()
+  }
+}
+
+prepareRelease(!args.stable, args.notesOnly)

script/prerelease.js

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+
+require('colors')
+const assert = require('assert')
+const GitHub = require('github')
+const heads = require('heads')
+const pkg = require('../package.json')
+const pass = '\u2713'.green
+const fail = '\u2717'.red
+let failureCount = 0
+
+assert(process.env.ELECTRON_GITHUB_TOKEN, 'ELECTRON_GITHUB_TOKEN not found in environment')
+
+const github = new GitHub()
+github.authenticate({type: 'token', token: process.env.ELECTRON_GITHUB_TOKEN})
+github.repos.getReleases({owner: 'electron', repo: 'electron'})
+  .then(res => {
+    const releases = res.data
+    const drafts = releases
+      .filter(release => release.draft) // comment out for testing
+      // .filter(release => release.tag_name === 'v1.7.5') // uncomment for testing
+
+    check(drafts.length === 1, 'one draft exists', true)
+    const draft = drafts[0]
+
+    check(draft.tag_name === `v${pkg.version}`, `draft release version matches local package.json (v${pkg.version})`)
+    check(draft.prerelease, 'draft is a prerelease')
+    check(draft.body.length > 50 && !draft.body.includes('(placeholder)'), 'draft has release notes')
+
+    const requiredAssets = assetsForVersion(draft.tag_name).sort()
+    const extantAssets = draft.assets.map(asset => asset.name).sort()
+
+    requiredAssets.forEach(asset => {
+      check(extantAssets.includes(asset), asset)
+    })
+
+    const s3Urls = s3UrlsForVersion(draft.tag_name)
+    heads(s3Urls)
+      .then(results => {
+        results.forEach((result, i) => {
+          check(result === 200, s3Urls[i])
+        })
+
+        process.exit(failureCount > 0 ? 1 : 0)
+      })
+      .catch(err => {
+        console.error('Error making HEAD requests for S3 assets')
+        console.error(err)
+        process.exit(1)
+      })
+  })
+
+function check (condition, statement, exitIfFail = false) {
+  if (condition) {
+    console.log(`${pass} ${statement}`)
+  } else {
+    failureCount++
+    console.log(`${fail} ${statement}`)
+    if (exitIfFail) process.exit(1)
+  }
+}
+
+function assetsForVersion (version) {
+  const patterns = [
+    'electron-{{VERSION}}-darwin-x64-dsym.zip',
+    'electron-{{VERSION}}-darwin-x64-symbols.zip',
+    'electron-{{VERSION}}-darwin-x64.zip',
+    'electron-{{VERSION}}-linux-arm-symbols.zip',
+    'electron-{{VERSION}}-linux-arm.zip',
+    'electron-{{VERSION}}-linux-armv7l-symbols.zip',
+    'electron-{{VERSION}}-linux-armv7l.zip',
+    'electron-{{VERSION}}-linux-ia32-symbols.zip',
+    'electron-{{VERSION}}-linux-ia32.zip',
+    'electron-{{VERSION}}-linux-x64-symbols.zip',
+    'electron-{{VERSION}}-linux-x64.zip',
+    'electron-{{VERSION}}-mas-x64-dsym.zip',
+    'electron-{{VERSION}}-mas-x64-symbols.zip',
+    'electron-{{VERSION}}-mas-x64.zip',
+    'electron-{{VERSION}}-win32-ia32-pdb.zip',
+    'electron-{{VERSION}}-win32-ia32-symbols.zip',
+    'electron-{{VERSION}}-win32-ia32.zip',
+    'electron-{{VERSION}}-win32-x64-pdb.zip',
+    'electron-{{VERSION}}-win32-x64-symbols.zip',
+    'electron-{{VERSION}}-win32-x64.zip',
+    'electron-api.json',
+    'electron.d.ts',
+    'ffmpeg-{{VERSION}}-darwin-x64.zip',
+    'ffmpeg-{{VERSION}}-linux-arm.zip',
+    'ffmpeg-{{VERSION}}-linux-armv7l.zip',
+    'ffmpeg-{{VERSION}}-linux-ia32.zip',
+    'ffmpeg-{{VERSION}}-linux-x64.zip',
+    'ffmpeg-{{VERSION}}-mas-x64.zip',
+    'ffmpeg-{{VERSION}}-win32-ia32.zip',
+    'ffmpeg-{{VERSION}}-win32-x64.zip'
+  ]
+  return patterns.map(pattern => pattern.replace(/{{VERSION}}/g, version))
+}
+
+function s3UrlsForVersion (version) {
+  const bucket = 'https://gh-contractor-zcbenz.s3.amazonaws.com/'
+  const patterns = [
+    'atom-shell/dist/{{VERSION}}/iojs-{{VERSION}}-headers.tar.gz',
+    'atom-shell/dist/{{VERSION}}/iojs-{{VERSION}}.tar.gz',
+    'atom-shell/dist/{{VERSION}}/node-{{VERSION}}.tar.gz',
+    'atom-shell/dist/{{VERSION}}/node.lib',
+    'atom-shell/dist/{{VERSION}}/win-x64/iojs.lib',
+    'atom-shell/dist/{{VERSION}}/win-x86/iojs.lib',
+    'atom-shell/dist/{{VERSION}}/x64/node.lib',
+    'atom-shell/dist/index.json'
+  ]
+  return patterns.map(pattern => bucket + pattern.replace(/{{VERSION}}/g, version))
+}

script/release.js

@@ -0,0 +1,456 @@
+#!/usr/bin/env node
+
+require('colors')
+const args = require('minimist')(process.argv.slice(2))
+const assert = require('assert')
+const fs = require('fs')
+const { execSync } = require('child_process')
+const GitHub = require('github')
+const { GitProcess } = require('dugite')
+const nugget = require('nugget')
+const pkg = require('../package.json')
+const pkgVersion = `v${pkg.version}`
+const pass = '\u2713'.green
+const path = require('path')
+const fail = '\u2717'.red
+const sumchecker = require('sumchecker')
+const temp = require('temp').track()
+const { URL } = require('url')
+let failureCount = 0
+
+assert(process.env.ELECTRON_GITHUB_TOKEN, 'ELECTRON_GITHUB_TOKEN not found in environment')
+
+const github = new GitHub({
+  followRedirects: false
+})
+github.authenticate({type: 'token', token: process.env.ELECTRON_GITHUB_TOKEN})
+const gitDir = path.resolve(__dirname, '..')
+
+async function getDraftRelease (version, skipValidation) {
+  let releaseInfo = await github.repos.getReleases({owner: 'electron', repo: 'electron'})
+  let drafts
+  let versionToCheck
+  if (version) {
+    versionToCheck = version
+  } else {
+    versionToCheck = pkgVersion
+  }
+  drafts = releaseInfo.data
+    .filter(release => release.tag_name === versionToCheck &&
+      release.draft === true)
+  const draft = drafts[0]
+  if (!skipValidation) {
+    failureCount = 0
+    check(drafts.length === 1, 'one draft exists', true)
+    if (versionToCheck.indexOf('beta') > -1) {
+      check(draft.prerelease, 'draft is a prerelease')
+    }
+    check(draft.body.length > 50 && !draft.body.includes('(placeholder)'), 'draft has release notes')
+    check((failureCount === 0), `Draft release looks good to go.`, true)
+  }
+  return draft
+}
+
+async function validateReleaseAssets (release) {
+  const requiredAssets = assetsForVersion(release.tag_name).sort()
+  const extantAssets = release.assets.map(asset => asset.name).sort()
+  const downloadUrls = release.assets.map(asset => asset.browser_download_url).sort()
+
+  failureCount = 0
+  requiredAssets.forEach(asset => {
+    check(extantAssets.includes(asset), asset)
+  })
+  check((failureCount === 0), `All required GitHub assets exist for release`, true)
+
+  if (release.draft) {
+    await verifyAssets(release)
+  } else {
+    await verifyShasums(downloadUrls)
+      .catch(err => {
+        console.log(`${fail} error verifyingShasums`, err)
+      })
+  }
+  const s3Urls = s3UrlsForVersion(release.tag_name)
+  await verifyShasums(s3Urls, true)
+}
+
+function check (condition, statement, exitIfFail = false) {
+  if (condition) {
+    console.log(`${pass} ${statement}`)
+  } else {
+    failureCount++
+    console.log(`${fail} ${statement}`)
+    if (exitIfFail) process.exit(1)
+  }
+}
+
+function assetsForVersion (version) {
+  const patterns = [
+    `electron-${version}-darwin-x64-dsym.zip`,
+    `electron-${version}-darwin-x64-symbols.zip`,
+    `electron-${version}-darwin-x64.zip`,
+    `electron-${version}-linux-arm-symbols.zip`,
+    `electron-${version}-linux-arm.zip`,
+    `electron-${version}-linux-armv7l-symbols.zip`,
+    `electron-${version}-linux-armv7l.zip`,
+    `electron-${version}-linux-ia32-symbols.zip`,
+    `electron-${version}-linux-ia32.zip`,
+    `electron-${version}-linux-x64-symbols.zip`,
+    `electron-${version}-linux-x64.zip`,
+    `electron-${version}-mas-x64-dsym.zip`,
+    `electron-${version}-mas-x64-symbols.zip`,
+    `electron-${version}-mas-x64.zip`,
+    `electron-${version}-win32-ia32-pdb.zip`,
+    `electron-${version}-win32-ia32-symbols.zip`,
+    `electron-${version}-win32-ia32.zip`,
+    `electron-${version}-win32-x64-pdb.zip`,
+    `electron-${version}-win32-x64-symbols.zip`,
+    `electron-${version}-win32-x64.zip`,
+    `electron-api.json`,
+    `electron.d.ts`,
+    `ffmpeg-${version}-darwin-x64.zip`,
+    `ffmpeg-${version}-linux-arm.zip`,
+    `ffmpeg-${version}-linux-armv7l.zip`,
+    `ffmpeg-${version}-linux-ia32.zip`,
+    `ffmpeg-${version}-linux-x64.zip`,
+    `ffmpeg-${version}-mas-x64.zip`,
+    `ffmpeg-${version}-win32-ia32.zip`,
+    `ffmpeg-${version}-win32-x64.zip`,
+    `SHASUMS256.txt`
+  ]
+  return patterns
+}
+
+function s3UrlsForVersion (version) {
+  const bucket = `https://gh-contractor-zcbenz.s3.amazonaws.com/`
+  const patterns = [
+    `${bucket}atom-shell/dist/${version}/iojs-${version}-headers.tar.gz`,
+    `${bucket}atom-shell/dist/${version}/iojs-${version}.tar.gz`,
+    `${bucket}atom-shell/dist/${version}/node-${version}.tar.gz`,
+    `${bucket}atom-shell/dist/${version}/node.lib`,
+    `${bucket}atom-shell/dist/${version}/win-x64/iojs.lib`,
+    `${bucket}atom-shell/dist/${version}/win-x86/iojs.lib`,
+    `${bucket}atom-shell/dist/${version}/x64/node.lib`,
+    `${bucket}atom-shell/dist/${version}/SHASUMS.txt`,
+    `${bucket}atom-shell/dist/${version}/SHASUMS256.txt`,
+    `${bucket}atom-shell/dist/index.json`
+  ]
+  return patterns
+}
+
+function checkVersion () {
+  console.log(`Verifying that app version matches package version ${pkgVersion}.`)
+  let startScript = path.join(__dirname, 'start.py')
+  let appVersion = runScript(startScript, ['--version']).trim()
+  check((pkgVersion.indexOf(appVersion) === 0), `App version ${appVersion} matches ` +
+    `package version ${pkgVersion}.`, true)
+}
+
+function runScript (scriptName, scriptArgs, cwd) {
+  let scriptCommand = `${scriptName} ${scriptArgs.join(' ')}`
+  let scriptOptions = {
+    encoding: 'UTF-8'
+  }
+  if (cwd) {
+    scriptOptions.cwd = cwd
+  }
+  try {
+    return execSync(scriptCommand, scriptOptions)
+  } catch (err) {
+    console.log(`${fail} Error running ${scriptName}`, err)
+    process.exit(1)
+  }
+}
+
+function uploadNodeShasums () {
+  console.log('Uploading Node SHASUMS file to S3.')
+  let scriptPath = path.join(__dirname, 'upload-node-checksums.py')
+  runScript(scriptPath, ['-v', pkgVersion])
+  console.log(`${pass} Done uploading Node SHASUMS file to S3.`)
+}
+
+function uploadIndexJson () {
+  console.log('Uploading index.json to S3.')
+  let scriptPath = path.join(__dirname, 'upload-index-json.py')
+  runScript(scriptPath, [])
+  console.log(`${pass} Done uploading index.json to S3.`)
+}
+
+async function createReleaseShasums (release) {
+  let fileName = 'SHASUMS256.txt'
+  let existingAssets = release.assets.filter(asset => asset.name === fileName)
+  if (existingAssets.length > 0) {
+    console.log(`${fileName} already exists on GitHub; deleting before creating new file.`)
+    await github.repos.deleteAsset({
+      owner: 'electron',
+      repo: 'electron',
+      id: existingAssets[0].id
+    }).catch(err => {
+      console.log(`${fail} Error deleting ${fileName} on GitHub:`, err)
+    })
+  }
+  console.log(`Creating and uploading the release ${fileName}.`)
+  let scriptPath = path.join(__dirname, 'merge-electron-checksums.py')
+  let checksums = runScript(scriptPath, ['-v', pkgVersion])
+  console.log(`${pass} Generated release SHASUMS.`)
+  let filePath = await saveShaSumFile(checksums, fileName)
+  console.log(`${pass} Created ${fileName} file.`)
+  await uploadShasumFile(filePath, fileName, release)
+  console.log(`${pass} Successfully uploaded ${fileName} to GitHub.`)
+}
+
+async function uploadShasumFile (filePath, fileName, release) {
+  let githubOpts = {
+    owner: 'electron',
+    repo: 'electron',
+    id: release.id,
+    filePath,
+    name: fileName
+  }
+  return github.repos.uploadAsset(githubOpts)
+    .catch(err => {
+      console.log(`${fail} Error uploading ${filePath} to GitHub:`, err)
+      process.exit(1)
+    })
+}
+
+function saveShaSumFile (checksums, fileName) {
+  return new Promise((resolve, reject) => {
+    temp.open(fileName, (err, info) => {
+      if (err) {
+        console.log(`${fail} Could not create ${fileName} file`)
+        process.exit(1)
+      } else {
+        fs.writeFileSync(info.fd, checksums)
+        fs.close(info.fd, (err) => {
+          if (err) {
+            console.log(`${fail} Could close ${fileName} file`)
+            process.exit(1)
+          }
+          resolve(info.path)
+        })
+      }
+    })
+  })
+}
+
+async function publishRelease (release) {
+  let githubOpts = {
+    owner: 'electron',
+    repo: 'electron',
+    id: release.id,
+    tag_name: release.tag_name,
+    draft: false
+  }
+  return github.repos.editRelease(githubOpts)
+    .catch(err => {
+      console.log(`${fail} Error publishing release:`, err)
+      process.exit(1)
+    })
+}
+
+async function makeRelease (releaseToValidate) {
+  if (releaseToValidate) {
+    console.log(`Validating release ${args.validateRelease}`)
+    let release = await getDraftRelease(args.validateRelease)
+    await validateReleaseAssets(release)
+  } else {
+    checkVersion()
+    let draftRelease = await getDraftRelease()
+    uploadNodeShasums()
+    uploadIndexJson()
+    await createReleaseShasums(draftRelease)
+    // Fetch latest version of release before verifying
+    draftRelease = await getDraftRelease(pkgVersion, true)
+    await validateReleaseAssets(draftRelease)
+    await publishRelease(draftRelease)
+    await cleanupReleaseBranch()
+    console.log(`${pass} SUCCESS!!! Release has been published. Please run ` +
+      `"npm run publish-to-npm" to publish release to npm.`)
+  }
+}
+
+async function makeTempDir () {
+  return new Promise((resolve, reject) => {
+    temp.mkdir('electron-publish', (err, dirPath) => {
+      if (err) {
+        reject(err)
+      } else {
+        resolve(dirPath)
+      }
+    })
+  })
+}
+
+async function verifyAssets (release) {
+  let downloadDir = await makeTempDir()
+  let githubOpts = {
+    owner: 'electron',
+    repo: 'electron',
+    headers: {
+      Accept: 'application/octet-stream'
+    }
+  }
+  console.log(`Downloading files from GitHub to verify shasums`)
+  let shaSumFile = 'SHASUMS256.txt'
+  let filesToCheck = await Promise.all(release.assets.map(async (asset) => {
+    githubOpts.id = asset.id
+    let assetDetails = await github.repos.getAsset(githubOpts)
+    await downloadFiles(assetDetails.meta.location, downloadDir, false, asset.name)
+    return asset.name
+  })).catch(err => {
+    console.log(`${fail} Error downloading files from GitHub`, err)
+    process.exit(1)
+  })
+  filesToCheck = filesToCheck.filter(fileName => fileName !== shaSumFile)
+  let checkerOpts
+  await validateChecksums({
+    algorithm: 'sha256',
+    filesToCheck,
+    fileDirectory: downloadDir,
+    shaSumFile,
+    checkerOpts,
+    fileSource: 'GitHub'
+  })
+}
+
+function downloadFiles (urls, directory, quiet, targetName) {
+  return new Promise((resolve, reject) => {
+    let nuggetOpts = {
+      dir: directory
+    }
+    if (quiet) {
+      nuggetOpts.quiet = quiet
+    }
+    if (targetName) {
+      nuggetOpts.target = targetName
+    }
+    nugget(urls, nuggetOpts, (err) => {
+      if (err) {
+        reject(err)
+      } else {
+        resolve()
+      }
+    })
+  })
+}
+
+async function verifyShasums (urls, isS3) {
+  let fileSource = isS3 ? 'S3' : 'GitHub'
+  console.log(`Downloading files from ${fileSource} to verify shasums`)
+  let downloadDir = await makeTempDir()
+  let filesToCheck = []
+  try {
+    if (!isS3) {
+      await downloadFiles(urls, downloadDir)
+      filesToCheck = urls.map(url => {
+        let currentUrl = new URL(url)
+        return path.basename(currentUrl.pathname)
+      }).filter(file => file.indexOf('SHASUMS') === -1)
+    } else {
+      const s3VersionPath = `/atom-shell/dist/${pkgVersion}/`
+      await Promise.all(urls.map(async (url) => {
+        let currentUrl = new URL(url)
+        let dirname = path.dirname(currentUrl.pathname)
+        let filename = path.basename(currentUrl.pathname)
+        let s3VersionPathIdx = dirname.indexOf(s3VersionPath)
+        if (s3VersionPathIdx === -1 || dirname === s3VersionPath) {
+          if (s3VersionPathIdx !== -1 && filename.indexof('SHASUMS') === -1) {
+            filesToCheck.push(filename)
+          }
+          await downloadFiles(url, downloadDir, true)
+        } else {
+          let subDirectory = dirname.substr(s3VersionPathIdx + s3VersionPath.length)
+          let fileDirectory = path.join(downloadDir, subDirectory)
+          try {
+            fs.statSync(fileDirectory)
+          } catch (err) {
+            fs.mkdirSync(fileDirectory)
+          }
+          filesToCheck.push(path.join(subDirectory, filename))
+          await downloadFiles(url, fileDirectory, true)
+        }
+      }))
+    }
+  } catch (err) {
+    console.log(`${fail} Error downloading files from ${fileSource}`, err)
+    process.exit(1)
+  }
+  console.log(`${pass} Successfully downloaded the files from ${fileSource}.`)
+  let checkerOpts
+  if (isS3) {
+    checkerOpts = { defaultTextEncoding: 'binary' }
+  }
+
+  await validateChecksums({
+    algorithm: 'sha256',
+    filesToCheck,
+    fileDirectory: downloadDir,
+    shaSumFile: 'SHASUMS256.txt',
+    checkerOpts,
+    fileSource
+  })
+
+  if (isS3) {
+    await validateChecksums({
+      algorithm: 'sha1',
+      filesToCheck,
+      fileDirectory: downloadDir,
+      shaSumFile: 'SHASUMS.txt',
+      checkerOpts,
+      fileSource
+    })
+  }
+}
+
+async function validateChecksums (validationArgs) {
+  console.log(`Validating checksums for files from ${validationArgs.fileSource} ` +
+    `against ${validationArgs.shaSumFile}.`)
+  let shaSumFilePath = path.join(validationArgs.fileDirectory, validationArgs.shaSumFile)
+  let checker = new sumchecker.ChecksumValidator(validationArgs.algorithm,
+    shaSumFilePath, validationArgs.checkerOpts)
+  await checker.validate(validationArgs.fileDirectory, validationArgs.filesToCheck)
+    .catch(err => {
+      if (err instanceof sumchecker.ChecksumMismatchError) {
+        console.error(`${fail} The checksum of ${err.filename} from ` +
+          `${validationArgs.fileSource} did not match the shasum in ` +
+          `${validationArgs.shaSumFile}`)
+      } else if (err instanceof sumchecker.ChecksumParseError) {
+        console.error(`${fail} The checksum file ${validationArgs.shaSumFile} ` +
+          `from ${validationArgs.fileSource} could not be parsed.`, err)
+      } else if (err instanceof sumchecker.NoChecksumFoundError) {
+        console.error(`${fail} The file ${err.filename} from ` +
+          `${validationArgs.fileSource} was not in the shasum file ` +
+          `${validationArgs.shaSumFile}.`)
+      } else {
+        console.error(`${fail} Error matching files from ` +
+          `${validationArgs.fileSource} shasums in ${validationArgs.shaSumFile}.`, err)
+      }
+      process.exit(1)
+    })
+  console.log(`${pass} All files from ${validationArgs.fileSource} match ` +
+    `shasums defined in ${validationArgs.shaSumFile}.`)
+}
+
+async function cleanupReleaseBranch () {
+  console.log(`Cleaning up release branch.`)
+  let errorMessage = `Could not delete local release branch.`
+  let successMessage = `Successfully deleted local release branch.`
+  await callGit(['branch', '-D', 'release-1-7-x'], errorMessage, successMessage)
+  errorMessage = `Could not delete remote release branch.`
+  successMessage = `Successfully deleted remote release branch.`
+  return callGit(['push', 'origin', ':release'], errorMessage, successMessage)
+}
+
+async function callGit (args, errorMessage, successMessage) {
+  let gitResult = await GitProcess.exec(args, gitDir)
+  if (gitResult.exitCode === 0) {
+    console.log(`${pass} ${successMessage}`)
+    return true
+  } else {
+    console.log(`${fail} ${errorMessage} ${gitResult.stderr}`)
+    process.exit(1)
+  }
+}
+
+makeRelease(args.validateRelease)

script/update-external-binaries.py

@@ -8,7 +8,7 @@ from lib.config import get_target_arch
 from lib.util import safe_mkdir, rm_rf, extract_zip, tempdir, download
 
 
-VERSION = 'v1.2.1'
+VERSION = 'v1.2.2'
 SOURCE_ROOT = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))
 FRAMEWORKS_URL = 'http://github.com/electron/electron-frameworks/releases' \
                  '/download/' + VERSION

script/upload-to-github.js

@@ -0,0 +1,51 @@
+const GitHub = require('github')
+const github = new GitHub()
+github.authenticate({type: 'token', token: process.env.ELECTRON_GITHUB_TOKEN})
+
+if (process.argv.length < 5) {
+  console.log('Usage: upload-to-github filePath fileName releaseId')
+  process.exit(1)
+}
+let filePath = process.argv[2]
+let fileName = process.argv[3]
+let releaseId = process.argv[4]
+
+let githubOpts = {
+  owner: 'electron',
+  repo: 'electron',
+  id: releaseId,
+  filePath: filePath,
+  name: fileName
+}
+
+let retry = 0
+
+function uploadToGitHub () {
+  github.repos.uploadAsset(githubOpts).then(() => {
+    console.log(`Successfully uploaded ${fileName} to GitHub.`)
+    process.exit()
+  }).catch((err) => {
+    if (retry < 4) {
+      console.log(`Error uploading ${fileName} to GitHub, will retry.  Error was:`, err)
+      retry++
+      github.repos.getRelease(githubOpts).then(release => {
+        let existingAssets = release.data.assets.filter(asset => asset.name === fileName)
+        if (existingAssets.length > 0) {
+          console.log(`${fileName} already exists; will delete before retrying upload.`)
+          github.repos.deleteAsset({
+            owner: 'electron',
+            repo: 'electron',
+            id: existingAssets[0].id
+          }).then(uploadToGitHub).catch(uploadToGitHub)
+        } else {
+          uploadToGitHub()
+        }
+      })
+    } else {
+      console.log(`Error retrying uploading ${fileName} to GitHub:`, err)
+      process.exitCode = 1
+    }
+  })
+}
+
+uploadToGitHub()

script/upload.py

@@ -36,70 +36,65 @@ PDB_NAME = get_zip_name(PROJECT_NAME, ELECTRON_VERSION, 'pdb')
 def main():
   args = parse_args()
 
-  if not args.publish_release:
-    if not dist_newer_than_head():
-      run_python_script('create-dist.py')
+  if not dist_newer_than_head():
+    run_python_script('create-dist.py')
 
-    build_version = get_electron_build_version()
-    if not ELECTRON_VERSION.startswith(build_version):
-      error = 'Tag name ({0}) should match build version ({1})\n'.format(
-          ELECTRON_VERSION, build_version)
-      sys.stderr.write(error)
-      sys.stderr.flush()
-      return 1
+  build_version = get_electron_build_version()
+  if not ELECTRON_VERSION.startswith(build_version):
+    error = 'Tag name ({0}) should match build version ({1})\n'.format(
+        ELECTRON_VERSION, build_version)
+    sys.stderr.write(error)
+    sys.stderr.flush()
+    return 1
 
   github = GitHub(auth_token())
   releases = github.repos(ELECTRON_REPO).releases.get()
   tag_exists = False
-  for release in releases:
-    if not release['draft'] and release['tag_name'] == args.version:
+  for r in releases:
+    if not r['draft'] and r['tag_name'] == args.version:
+      release = r
       tag_exists = True
       break
 
-  release = create_or_get_release_draft(github, releases, args.version,
-                                        tag_exists)
-
-  if args.publish_release:
-    # Upload the Node SHASUMS*.txt.
-    run_python_script('upload-node-checksums.py', '-v', ELECTRON_VERSION)
-
-    # Upload the index.json.
-    run_python_script('upload-index-json.py')
-
-    # Create and upload the Electron SHASUMS*.txt
-    release_electron_checksums(github, release)
-
-    # Press the publish button.
-    publish_release(github, release['id'])
-
-    # TODO: run publish-to-npm script here
-
-    # Do not upload other files when passed "-p".
-    return
+  if not args.upload_to_s3:
+    assert tag_exists == args.overwrite, \
+          'You have to pass --overwrite to overwrite a published release'
+    if not args.overwrite:
+      release = create_or_get_release_draft(github, releases, args.version,
+                                            tag_exists)
 
   # Upload Electron with GitHub Releases API.
-  upload_electron(github, release, os.path.join(DIST_DIR, DIST_NAME))
-  upload_electron(github, release, os.path.join(DIST_DIR, SYMBOLS_NAME))
+  upload_electron(github, release, os.path.join(DIST_DIR, DIST_NAME),
+                  args.upload_to_s3)
+  if get_target_arch() != 'mips64el':
+    upload_electron(github, release, os.path.join(DIST_DIR, SYMBOLS_NAME),
+                    args.upload_to_s3)
   if PLATFORM == 'darwin':
     upload_electron(github, release, os.path.join(DIST_DIR,
-                    'electron-api.json'))
-    upload_electron(github, release, os.path.join(DIST_DIR, 'electron.d.ts'))
-    upload_electron(github, release, os.path.join(DIST_DIR, DSYM_NAME))
+                    'electron-api.json'), args.upload_to_s3)
+    upload_electron(github, release, os.path.join(DIST_DIR, 'electron.d.ts'),
+                    args.upload_to_s3)
+    upload_electron(github, release, os.path.join(DIST_DIR, DSYM_NAME),
+                    args.upload_to_s3)
   elif PLATFORM == 'win32':
-    upload_electron(github, release, os.path.join(DIST_DIR, PDB_NAME))
+    upload_electron(github, release, os.path.join(DIST_DIR, PDB_NAME),
+                    args.upload_to_s3)
 
   # Upload free version of ffmpeg.
   ffmpeg = get_zip_name('ffmpeg', ELECTRON_VERSION)
-  upload_electron(github, release, os.path.join(DIST_DIR, ffmpeg))
+  upload_electron(github, release, os.path.join(DIST_DIR, ffmpeg),
+                  args.upload_to_s3)
 
   # Upload chromedriver and mksnapshot for minor version update.
   if parse_version(args.version)[2] == '0':
     chromedriver = get_zip_name('chromedriver', ELECTRON_VERSION)
-    upload_electron(github, release, os.path.join(DIST_DIR, chromedriver))
+    upload_electron(github, release, os.path.join(DIST_DIR, chromedriver),
+                    args.upload_to_s3)
     mksnapshot = get_zip_name('mksnapshot', ELECTRON_VERSION)
-    upload_electron(github, release, os.path.join(DIST_DIR, mksnapshot))
+    upload_electron(github, release, os.path.join(DIST_DIR, mksnapshot),
+                    args.upload_to_s3)
 
-  if PLATFORM == 'win32' and not tag_exists:
+  if PLATFORM == 'win32' and not tag_exists and not args.upload_to_s3:
     # Upload PDBs to Windows symbol server.
     run_python_script('upload-windows-pdb.py')
 
@@ -112,9 +107,18 @@ def parse_args():
   parser = argparse.ArgumentParser(description='upload distribution file')
   parser.add_argument('-v', '--version', help='Specify the version',
                       default=ELECTRON_VERSION)
+  parser.add_argument('-o', '--overwrite',
+                      help='Overwrite a published release',
+                      action='store_true')
   parser.add_argument('-p', '--publish-release',
                       help='Publish the release',
                       action='store_true')
+  parser.add_argument('-s', '--upload_to_s3',
+                      help='Upload assets to s3 bucket',
+                      dest='upload_to_s3',
+                      action='store_true',
+                      default=False,
+                      required=False)
   return parser.parse_args()
 
 
@@ -124,7 +128,7 @@ def run_python_script(script, *args):
 
 
 def get_electron_build_version():
-  if get_target_arch() == 'arm' or os.environ.has_key('CI'):
+  if get_target_arch().startswith('arm') or os.environ.has_key('CI'):
     # In CI we just build as told.
     return ELECTRON_VERSION
   if PLATFORM == 'darwin':
@@ -175,7 +179,7 @@ def get_text_with_editor(name):
 def create_or_get_release_draft(github, releases, tag, tag_exists):
   # Search for existing draft.
   for release in releases:
-    if release['draft']:
+    if release['draft'] and release['tag_name'] == tag:
       return release
 
   if tag_exists:
@@ -198,14 +202,17 @@ def create_release_draft(github, tag):
   return r
 
 
-def release_electron_checksums(github, release):
-  checksums = run_python_script('merge-electron-checksums.py',
-                                '-v', ELECTRON_VERSION)
-  upload_io_to_github(github, release, 'SHASUMS256.txt',
-                      StringIO(checksums.decode('utf-8')), 'text/plain')
+def upload_electron(github, release, file_path, upload_to_s3):
 
+  # if upload_to_s3 is set, skip github upload.
+  if upload_to_s3:
+    bucket, access_key, secret_key = s3_config()
+    key_prefix = 'electron-artifacts/{0}'.format(release['tag_name'])
+    s3put(bucket, access_key, secret_key, os.path.dirname(file_path),
+          key_prefix, [file_path])
+    upload_sha256_checksum(release['tag_name'], file_path, key_prefix)
+    return
 
-def upload_electron(github, release, file_path):
   # Delete the original file before uploading in CI.
   filename = os.path.basename(file_path)
   if os.environ.has_key('CI'):
@@ -217,8 +224,7 @@ def upload_electron(github, release, file_path):
       pass
 
   # Upload the file.
-  with open(file_path, 'rb') as f:
-    upload_io_to_github(github, release, filename, f, 'application/zip')
+  upload_io_to_github(release, filename, file_path)
 
   # Upload the checksum file.
   upload_sha256_checksum(release['tag_name'], file_path)
@@ -229,19 +235,21 @@ def upload_electron(github, release, file_path):
     arm_filename = filename.replace('armv7l', 'arm')
     arm_file_path = os.path.join(os.path.dirname(file_path), arm_filename)
     shutil.copy2(file_path, arm_file_path)
-    upload_electron(github, release, arm_file_path)
+    upload_electron(github, release, arm_file_path, upload_to_s3)
 
 
-def upload_io_to_github(github, release, name, io, content_type):
-  params = {'name': name}
-  headers = {'Content-Type': content_type}
-  github.repos(ELECTRON_REPO).releases(release['id']).assets.post(
-      params=params, headers=headers, data=io, verify=False)
+def upload_io_to_github(release, filename, filepath):
+  print 'Uploading %s to Github' % \
+      (filename)
+  script_path = os.path.join(SOURCE_ROOT, 'script', 'upload-to-github.js')
+  execute(['node', script_path, filepath, filename, str(release['id'])])
 
 
-def upload_sha256_checksum(version, file_path):
+def upload_sha256_checksum(version, file_path, key_prefix=None):
   bucket, access_key, secret_key = s3_config()
   checksum_path = '{}.sha256sum'.format(file_path)
+  if key_prefix is None:
+    key_prefix = 'atom-shell/tmp/{0}'.format(version)
   sha256 = hashlib.sha256()
   with open(file_path, 'rb') as f:
     sha256.update(f.read())
@@ -250,12 +258,7 @@ def upload_sha256_checksum(version, file_path):
   with open(checksum_path, 'w') as checksum:
     checksum.write('{} *{}'.format(sha256.hexdigest(), filename))
   s3put(bucket, access_key, secret_key, os.path.dirname(checksum_path),
-        'atom-shell/tmp/{0}'.format(version), [checksum_path])
-
-
-def publish_release(github, release_id):
-  data = dict(draft=False)
-  github.repos(ELECTRON_REPO).releases(release_id).patch(data=data)
+        key_prefix, [checksum_path])
 
 
 def auth_token():

spec/api-app-spec.js

@@ -149,6 +149,34 @@ describe('app module', function () {
     })
   })
 
+  describe('app.makeSingleInstance', function () {
+    it('prevents the second launch of app', function (done) {
+      this.timeout(120000)
+      const appPath = path.join(__dirname, 'fixtures', 'api', 'singleton')
+      // First launch should exit with 0.
+      let secondLaunched = false
+      const first = ChildProcess.spawn(remote.process.execPath, [appPath])
+      let launchOnce = true
+      first.stdout.on('data', (data) => {
+        if (data.toString().trim() === 'launched' && launchOnce) {
+          launchOnce = false
+          // Second launch should exit with 1.
+          const second = ChildProcess.spawn(remote.process.execPath, [appPath])
+          second.once('exit', (code) => {
+            assert.ok(!secondLaunched)
+            assert.equal(code, 1)
+            secondLaunched = true
+          })
+        }
+      })
+      first.once('exit', (code) => {
+        assert.ok(secondLaunched)
+        assert.equal(code, 0)
+        done()
+      })
+    })
+  })
+
   describe('app.relaunch', function () {
     let server = null
     const socketPath = process.platform === 'win32' ? '\\\\.\\pipe\\electron-app-relaunch' : '/tmp/electron-app-relaunch'
@@ -208,9 +236,10 @@ describe('app module', function () {
     })
   })
 
-  describe('app.importCertificate', function () {
+  xdescribe('app.importCertificate', function () {
     if (process.platform !== 'linux') return
 
+    this.timeout(120000)
     var w = null
 
     afterEach(function () {
@@ -405,7 +434,7 @@ describe('app module', function () {
     })
   })
 
-  describe('select-client-certificate event', function () {
+  xdescribe('select-client-certificate event', function () {
     let w = null
 
     beforeEach(function () {
@@ -469,6 +498,54 @@ describe('app module', function () {
     })
   })
 
+  describe('app launch through uri', () => {
+    before(function () {
+      if (process.platform !== 'win32') {
+        this.skip()
+      }
+    })
+
+    it('does not launch for blacklisted argument', function (done) {
+      const appPath = path.join(__dirname, 'fixtures', 'api', 'quit-app')
+      // App should exit with non 123 code.
+      const first = ChildProcess.spawn(remote.process.execPath, [appPath, 'electron-test://?', '--no-sandbox', '--gpu-launcher=cmd.exe /c start calc'])
+      first.once('exit', (code) => {
+        assert.notEqual(code, 123)
+        done()
+      })
+    })
+
+    it('launches successfully for multiple uris in cmd args', function (done) {
+      const appPath = path.join(__dirname, 'fixtures', 'api', 'quit-app')
+      // App should exit with code 123.
+      const first = ChildProcess.spawn(remote.process.execPath, [appPath, 'http://electronjs.org', 'electron-test://testdata'])
+      first.once('exit', (code) => {
+        assert.equal(code, 123)
+        done()
+      })
+    })
+
+    it('does not launch for encoded space', function (done) {
+      const appPath = path.join(__dirname, 'fixtures', 'api', 'quit-app')
+      // App should exit with non 123 code.
+      const first = ChildProcess.spawn(remote.process.execPath, [appPath, 'electron-test://?', '--no-sandbox', '--gpu-launcher%20"cmd.exe /c start calc'])
+      first.once('exit', (code) => {
+        assert.notEqual(code, 123)
+        done()
+      })
+    })
+
+    it('launches successfully for argnames similar to blacklisted ones', function (done) {
+      const appPath = path.join(__dirname, 'fixtures', 'api', 'quit-app')
+      // inspect is blacklisted, but inspector should work, and app launch should succeed
+      const first = ChildProcess.spawn(remote.process.execPath, [appPath, 'electron-test://?', '--inspector'])
+      first.once('exit', (code) => {
+        assert.equal(code, 123)
+        done()
+      })
+    })
+  })
+
   describe('getFileIcon() API', function () {
     // FIXME Get these specs running on Linux CI
     if (process.platform === 'linux' && isCI) return

spec/api-browser-window-spec.js

@@ -2691,10 +2691,9 @@ describe('BrowserWindow module', function () {
       })
       w.loadURL('file://' + fixtures + '/api/isolated.html')
     })
-
-    it('enables context isolation on child windows', function (done) {
-      app.once('browser-window-created', function (event, window) {
-        assert.equal(window.webContents.getWebPreferences().contextIsolation, true)
+    it('enables context isolation on child windows', (done) => {
+      app.once('browser-window-created', (event, window) => {
+        assert.equal(window.webContents.getLastWebPreferences().contextIsolation, true)
         done()
       })
       w.loadURL('file://' + fixtures + '/pages/window-open.html')

spec/chromium-spec.js

@@ -241,8 +241,28 @@ describe('chromium feature', function () {
       b = window.open(windowUrl, '', 'nodeIntegration=no,show=no')
     })
 
-    it('disables node integration when it is disabled on the parent window for chrome devtools URLs', function (done) {
-      var b
+    it('disables webviewTag when node integration is disabled on the parent window', (done) => {
+      let b
+      listener = (event) => {
+        assert.equal(event.data.isWebViewUndefined, true)
+        b.close()
+        done()
+      }
+      window.addEventListener('message', listener)
+
+      const windowUrl = require('url').format({
+        pathname: `${fixtures}/pages/window-opener-no-web-view-tag.html`,
+        protocol: 'file',
+        query: {
+          p: `${fixtures}/pages/window-opener-web-view.html`
+        },
+        slashes: true
+      })
+      b = window.open(windowUrl, '', 'nodeIntegration=no,show=no')
+    })
+
+    it('disables node integration when it is disabled on the parent window for chrome devtools URLs', (done) => {
+      let b
       app.once('web-contents-created', (event, contents) => {
         contents.once('did-finish-load', () => {
           contents.executeJavaScript('typeof process').then((typeofProcessGlobal) => {
@@ -260,7 +280,7 @@ describe('chromium feature', function () {
       app.once('web-contents-created', (event, contents) => {
         contents.once('did-finish-load', () => {
           app.once('browser-window-created', (event, window) => {
-            const preferences = window.webContents.getWebPreferences()
+            const preferences = window.webContents.getLastWebPreferences()
             assert.equal(preferences.javascript, false)
             window.destroy()
             b.close()
@@ -486,7 +506,7 @@ describe('chromium feature', function () {
         done()
       }
       window.addEventListener('message', listener)
-      w = window.open(url, '', 'show=no')
+      w = window.open(url, '', 'show=no,nodeIntegration=no')
     })
 
     it('works when origin matches', function (done) {
@@ -495,7 +515,7 @@ describe('chromium feature', function () {
         done()
       }
       window.addEventListener('message', listener)
-      w = window.open(`file://${fixtures}/pages/window-opener-location.html`, '', 'show=no')
+      w = window.open(`file://${fixtures}/pages/window-opener-location.html`, '', 'show=no,nodeIntegration=no')
     })
 
     it('works when origin does not match opener but has node integration', function (done) {

spec/fixtures/api/singleton/main.js

@@ -0,0 +1,15 @@
+const {app} = require('electron')
+
+console.log('launched')
+
+process.on('uncaughtException', () => {
+  app.exit(2)
+})
+
+const shouldExit = app.makeSingleInstance(() => {
+  process.nextTick(() => app.exit(0))
+})
+
+if (shouldExit) {
+  app.exit(1)
+}

spec/fixtures/api/singleton/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "electron-app-singleton",
+  "main": "main.js"
+}
+

spec/fixtures/pages/window-opener-no-web-view-tag.html

@@ -0,0 +1,15 @@
+<html>
+<body>
+<script type="text/javascript" charset="utf-8">
+  var windowUrl = decodeURIComponent(window.location.search.substring(3))
+  var opened = window.open('file://' + windowUrl, '', 'webviewTag=yes,show=no')
+  window.addEventListener('message', function (event) {
+    try {
+      opened.close()
+    } finally {
+      window.opener.postMessage(event.data, '*')
+    }
+  })
+</script>
+</body>
+</html>

spec/fixtures/pages/window-opener-web-view.html

@@ -0,0 +1,9 @@
+<html>
+<body>
+<script type="text/javascript" charset="utf-8">
+  window.onload = () => {
+    window.opener.postMessage({isWebViewUndefined: typeof WebView === 'undefined'}, '*')
+  }
+</script>
+</body>
+</html>

spec/package.json

@@ -9,6 +9,7 @@
     "graceful-fs": "^4.1.9",
     "mkdirp": "^0.5.1",
     "mocha": "^3.1.0",
+    "mocha-junit-reporter": "^1.14.0",
     "multiparty": "^4.1.3",
     "q": "^1.4.1",
     "send": "^0.14.1",

spec/static/index.html

@@ -51,10 +51,15 @@
   var Coverage = require('electabul').Coverage;
 
   var Mocha = require('mocha');
+  var mochaOpts = {};
+  if (process.env.MOCHA_REPORTER) {
+    mochaOpts.reporter = process.env.MOCHA_REPORTER;
+  }
+  var mocha = new Mocha(mochaOpts);
 
-  var mocha = new Mocha();
-
-  mocha.ui('bdd').reporter(isCi ? 'tap' : 'html');
+  if (!process.env.MOCHA_REPORTER) {
+    mocha.ui('bdd').reporter(isCi ? 'tap' : 'html');
+  }
   mocha.timeout(isCi ? 30000 : 10000)
 
   var query = Mocha.utils.parseQuery(window.location.search || '');

vsts.yml

@@ -0,0 +1,84 @@
+resources:
+- repo: self
+steps:
+- bash: |
+    if [ "$ELECTRON_RELEASE" == "1" ]; then
+      echo 'Bootstrapping Electron for release build'
+      script/bootstrap.py --target_arch=$TARGET_ARCH
+    else
+      echo 'Bootstrapping Electron for debug build'
+      script/bootstrap.py --target_arch=$TARGET_ARCH --dev
+    fi
+  name: Bootstrap
+
+- bash: |
+    npm run lint
+  name: Lint
+  condition: and(succeeded(), ne(variables['ELECTRON_RELEASE'], '1'))
+
+- bash: |
+    if [ "$ELECTRON_RELEASE" == "1" ]; then
+      echo 'Building Electron for release'
+      script/build.py -c R
+    else
+      echo 'Building Electron for debug'
+      script/build.py -c D
+    fi
+  name: Build
+
+- bash: |
+    echo 'Creating Electron release distribution'
+    script/create-dist.py
+  name: Create_distribution
+  condition: and(succeeded(), eq(variables['ELECTRON_RELEASE'], '1'))
+
+- bash: |
+    if [ "$UPLOAD_TO_S3" != "1" ]; then
+      echo 'Uploading Electron release distribution to github releases'
+      ELECTRON_S3_BUCKET="$(s3_bucket)" ELECTRON_S3_ACCESS_KEY="$(s3_access_key)" ELECTRON_S3_SECRET_KEY="$(s3_secret_key)" ELECTRON_GITHUB_TOKEN="$(github_token)" script/upload.py
+    else
+      echo 'Uploading Electron release distribution to s3'
+      ELECTRON_S3_BUCKET="$(s3_bucket)" ELECTRON_S3_ACCESS_KEY="$(s3_access_key)" ELECTRON_S3_SECRET_KEY="$(s3_secret_key)" ELECTRON_GITHUB_TOKEN="$(github_token)" script/upload.py --upload_to_s3
+    fi
+  name: Upload_distribution
+  condition: and(succeeded(), eq(variables['ELECTRON_RELEASE'], '1'))
+
+- bash: |
+    echo 'Testing Electron build'
+    mkdir junit
+    export MOCHA_FILE="junit/test-results.xml"
+    export MOCHA_REPORTER="mocha-junit-reporter"
+    if [ "$ELECTRON_RELEASE" == "1" ]; then
+      script/test.py --ci --rebuild_native_modules -c R
+    else
+      script/test.py --ci --rebuild_native_modules
+    fi
+  name: Test
+  condition: or(ne(variables['ELECTRON_RELEASE'], '1'), eq(variables['UPLOAD_TO_S3'], '1'))
+
+- bash: |
+    echo 'Verifying ffmpeg on build'
+    if [ "$ELECTRON_RELEASE" == "1" ]; then
+      script/verify-ffmpeg.py -R
+    else
+      script/verify-ffmpeg.py
+    fi
+  name: Verify_FFmpeg
+  condition: or(ne(variables['ELECTRON_RELEASE'], '1'), eq(variables['UPLOAD_TO_S3'], '1'))
+
+- task: PublishTestResults@2
+  displayName: Publish Test Results
+  inputs:
+    testResultsFiles: 'test-results.xml'
+    searchFolder: junit
+  condition: and(always(), ne(variables['ELECTRON_RELEASE'], '1'))
+
+- task: kasunkodagoda.slack-notification.slack-notification-task.SlackNotification@3
+  displayName: Post Slack Notification
+  inputs:
+    SlackApiToken: '$(slack_token)'
+    Channel: '#bot-nightly-releases'
+    Message: '$(Build.DefinitionName)-$(Build.BuildNumber) finished with a $(Agent.JobStatus) status.'
+  condition: and(always(), eq(variables['Build.Reason'], 'Schedule'))
+
+- task: mspremier.PostBuildCleanup.PostBuildCleanup-task.PostBuildCleanup@3