v1.8.2

Fix PRE_RELEASE_VERSION

.circleci/config.yml

@@ -339,3 +339,6 @@ workflows:
   build-x64:
     jobs:
       - electron-linux-x64
+  build-mips64el:
+    jobs:
+      - electron-linux-mips64el

.gitignore

@@ -28,6 +28,7 @@
 /external_binaries/
 /out/
 /vendor/.gclient
+/vendor/cross-gcc-4.9.3-n64-loongson-rc5.4
 /vendor/debian_jessie_amd64-sysroot/
 /vendor/debian_jessie_arm-sysroot/
 /vendor/debian_jessie_arm64-sysroot/
@@ -36,8 +37,6 @@
 /vendor/debian_wheezy_amd64-sysroot/
 /vendor/debian_wheezy_arm-sysroot/
 /vendor/debian_wheezy_i386-sysroot/
-/vendor/gcc-4.8.3-d197-n64-loongson/
-/vendor/readme-gcc483-loongson.txt
 /vendor/download/
 /vendor/llvm-build/
 /vendor/llvm/

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
@@ -15,9 +16,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"
@@ -52,18 +55,23 @@ 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);
 
-  bool run_as_node = IsEnvSet(kRunAsNode);
+    ~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 < argc; ++i) {
-      if (!_wcsicmp(wargv[i], L"--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;
@@ -81,44 +89,12 @@ int APIENTRY wWinMain(HINSTANCE instance, HINSTANCE, wchar_t* cmd, int) {
   }
 #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
@@ -139,14 +115,23 @@ int APIENTRY wWinMain(HINSTANCE instance, HINSTANCE, wchar_t* cmd, int) {
 #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;
@@ -154,33 +139,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

@@ -861,11 +861,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/atom_browser_client.cc

@@ -38,6 +38,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 +244,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/native_window_views.cc

@@ -298,9 +298,6 @@ NativeWindowViews::NativeWindowViews(
   }
 
   LONG ex_style = ::GetWindowLong(GetAcceleratedWidget(), GWL_EXSTYLE);
-  // Window without thick frame has to have WS_EX_COMPOSITED style.
-  if (!thick_frame_)
-    ex_style |= WS_EX_COMPOSITED;
   if (window_type == "toolbar")
     ex_style |= WS_EX_TOOLWINDOW;
   ::SetWindowLong(GetAcceleratedWidget(), GWL_EXSTYLE, ex_style);
@@ -1363,22 +1360,26 @@ void NativeWindowViews::ShowAutofillPopup(
     const gfx::RectF& bounds,
     const std::vector<base::string16>& values,
     const std::vector<base::string16>& labels) {
-  const auto* web_preferences =
-      WebContentsPreferences::FromWebContents(web_contents)->web_preferences();
-
   bool is_offsceen = false;
-  web_preferences->GetBoolean("offscreen", &is_offsceen);
-  int guest_instance_id = 0;
-  web_preferences->GetInteger(options::kGuestInstanceID, &guest_instance_id);
-
   bool is_embedder_offscreen = false;
-  if (guest_instance_id) {
-    auto manager = WebViewManager::GetWebViewManager(web_contents);
-    if (manager) {
-      auto embedder = manager->GetEmbedder(guest_instance_id);
-      if (embedder) {
-        is_embedder_offscreen = WebContentsPreferences::IsPreferenceEnabled(
-            "offscreen", embedder);
+
+  auto* web_contents_preferences =
+      WebContentsPreferences::FromWebContents(web_contents);
+  if (web_contents_preferences) {
+    const auto* web_preferences = web_contents_preferences->web_preferences();
+
+    web_preferences->GetBoolean("offscreen", &is_offsceen);
+    int guest_instance_id = 0;
+    web_preferences->GetInteger(options::kGuestInstanceID, &guest_instance_id);
+
+    if (guest_instance_id) {
+      auto manager = WebViewManager::GetWebViewManager(web_contents);
+      if (manager) {
+        auto embedder = manager->GetEmbedder(guest_instance_id);
+        if (embedder) {
+          is_embedder_offscreen = WebContentsPreferences::IsPreferenceEnabled(
+              "offscreen", embedder);
+        }
       }
     }
   }

atom/browser/node_debugger.cc

@@ -42,7 +42,7 @@ void NodeDebugger::Start() {
     // the debugger on the first line
     if (options.wait_for_connect()) {
       mate::Dictionary process(env_->isolate(), env_->process_object());
-      process.Set("_debugWaitConnect", true);
+      process.Set("_breakFirstLine", true);
     }
 
     inspector->Start(platform_.get(), nullptr, options);

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/win/atom.rc

@@ -56,8 +56,8 @@ END
 //
 
 VS_VERSION_INFO VERSIONINFO
- FILEVERSION 1,8,2,2
- PRODUCTVERSION 1,8,2,2
+ FILEVERSION 1,8,2,0
+ PRODUCTVERSION 1,8,2,0
  FILEFLAGSMASK 0x3fL
 #ifdef _DEBUG
  FILEFLAGS 0x1L

atom/browser/ui/win/atom_desktop_native_widget_aura.cc

@@ -3,12 +3,16 @@
 // found in the LICENSE file.
 
 #include "atom/browser/ui/win/atom_desktop_native_widget_aura.h"
+#include "ui/views/corewm/tooltip_controller.h"
+#include "ui/wm/public/tooltip_client.h"
 
 namespace atom {
 
 AtomDesktopNativeWidgetAura::AtomDesktopNativeWidgetAura(
     views::internal::NativeWidgetDelegate* delegate)
     : views::DesktopNativeWidgetAura(delegate) {
+  // This is to enable the override of OnWindowActivated
+  aura::client::SetActivationChangeObserver(GetNativeWindow(), this);
 }
 
 void AtomDesktopNativeWidgetAura::Activate() {
@@ -19,4 +23,23 @@ void AtomDesktopNativeWidgetAura::Activate() {
     views::DesktopNativeWidgetAura::Activate();
 }
 
+void AtomDesktopNativeWidgetAura::OnWindowActivated(
+    aura::client::ActivationChangeObserver::ActivationReason reason,
+    aura::Window* gained_active,
+    aura::Window* lost_active) {
+  views::DesktopNativeWidgetAura::OnWindowActivated(
+    reason, gained_active, lost_active);
+  if (lost_active != nullptr) {
+    auto* tooltip_controller = static_cast<views::corewm::TooltipController*>(
+      aura::client::GetTooltipClient(lost_active->GetRootWindow()));
+
+    // This will cause the tooltip to be hidden when a window is deactivated,
+    // as it should be.
+    // TODO(brenca): Remove this fix when the chromium issue is fixed.
+    // crbug.com/724538
+    if (tooltip_controller != nullptr)
+      tooltip_controller->OnCancelMode(nullptr);
+  }
+}
+
 }  // namespace atom

atom/browser/ui/win/atom_desktop_native_widget_aura.h

@@ -19,6 +19,10 @@ class AtomDesktopNativeWidgetAura : public views::DesktopNativeWidgetAura {
   void Activate() override;
 
  private:
+  void OnWindowActivated(
+      aura::client::ActivationChangeObserver::ActivationReason reason,
+      aura::Window* gained_active,
+      aura::Window* lost_active) override;
   DISALLOW_COPY_AND_ASSIGN(AtomDesktopNativeWidgetAura);
 };
 

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

@@ -8,21 +8,23 @@
 #define ATOM_MAJOR_VERSION 1
 #define ATOM_MINOR_VERSION 8
 #define ATOM_PATCH_VERSION 2
-#define ATOM_PRE_RELEASE_VERSION -beta.2
-
-#ifndef ATOM_PRE_RELEASE_VERSION
-# define ATOM_PRE_RELEASE_VERSION ""
-#endif
+// #define ATOM_PRE_RELEASE_VERSION
 
 #ifndef ATOM_STRINGIFY
 #define ATOM_STRINGIFY(n) ATOM_STRINGIFY_HELPER(n)
 #define ATOM_STRINGIFY_HELPER(n) #n
 #endif
 
-# define ATOM_VERSION_STRING  ATOM_STRINGIFY(ATOM_MAJOR_VERSION) "." \
+#ifndef ATOM_PRE_RELEASE_VERSION
+  #define ATOM_VERSION_STRING ATOM_STRINGIFY(ATOM_MAJOR_VERSION) "." \
+                              ATOM_STRINGIFY(ATOM_MINOR_VERSION) "." \
+                              ATOM_STRINGIFY(ATOM_PATCH_VERSION)
+#else
+  #define ATOM_VERSION_STRING ATOM_STRINGIFY(ATOM_MAJOR_VERSION) "." \
                               ATOM_STRINGIFY(ATOM_MINOR_VERSION) "." \
                               ATOM_STRINGIFY(ATOM_PATCH_VERSION)     \
                               ATOM_STRINGIFY(ATOM_PRE_RELEASE_VERSION)
+#endif
 
 #define ATOM_VERSION "v" ATOM_VERSION_STRING
 

atom/common/native_mate_converters/net_converter.cc

@@ -62,6 +62,9 @@ v8::Local<v8::Value> Converter<const net::AuthChallengeInfo*>::ToV8(
 // static
 v8::Local<v8::Value> Converter<scoped_refptr<net::X509Certificate>>::ToV8(
     v8::Isolate* isolate, const scoped_refptr<net::X509Certificate>& val) {
+#if defined(ARCH_CPU_MIPS64EL)
+  return v8::Undefined(isolate);
+#else
   mate::Dictionary dict(isolate, v8::Object::New(isolate));
   std::string encoded_data;
   net::X509Certificate::GetPEMEncoded(
@@ -92,11 +95,15 @@ v8::Local<v8::Value> Converter<scoped_refptr<net::X509Certificate>>::ToV8(
   }
 
   return dict.GetHandle();
+#endif
 }
 
 bool Converter<scoped_refptr<net::X509Certificate>>::FromV8(
     v8::Isolate* isolate, v8::Local<v8::Value> val,
     scoped_refptr<net::X509Certificate>* out) {
+#if defined(ARCH_CPU_MIPS64EL)
+  return false;
+#else
   mate::Dictionary dict;
   if (!ConvertFromV8(isolate, val, &dict))
     return false;
@@ -123,6 +130,7 @@ bool Converter<scoped_refptr<net::X509Certificate>>::FromV8(
   }
 
   return true;
+#endif
 }
 
 // static

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(

atom/renderer/api/atom_api_web_frame.cc

@@ -13,6 +13,7 @@
 #include "atom/renderer/api/atom_api_spell_check_client.h"
 #include "base/memory/memory_pressure_listener.h"
 #include "content/public/renderer/render_frame.h"
+#include "content/public/renderer/render_frame_visitor.h"
 #include "content/public/renderer/render_view.h"
 #include "native_mate/dictionary.h"
 #include "native_mate/object_template_builder.h"
@@ -58,6 +59,30 @@ class ScriptExecutionCallback : public blink::WebScriptExecutionCallback {
   DISALLOW_COPY_AND_ASSIGN(ScriptExecutionCallback);
 };
 
+class FrameSpellChecker : public content::RenderFrameVisitor {
+ public:
+  explicit FrameSpellChecker(SpellCheckClient* spell_check_client,
+                             content::RenderFrame* main_frame)
+      : spell_check_client_(spell_check_client), main_frame_(main_frame) {}
+  ~FrameSpellChecker() override {
+    spell_check_client_ = nullptr;
+    main_frame_ = nullptr;
+  }
+  bool Visit(content::RenderFrame* render_frame) override {
+    auto view = render_frame->GetRenderView();
+    if (view->GetMainRenderFrame() == main_frame_ ||
+        (render_frame->IsMainFrame() && render_frame == main_frame_)) {
+      render_frame->GetWebFrame()->SetTextCheckClient(spell_check_client_);
+    }
+    return true;
+  }
+
+ private:
+  SpellCheckClient* spell_check_client_;
+  content::RenderFrame* main_frame_;
+  DISALLOW_COPY_AND_ASSIGN(FrameSpellChecker);
+};
+
 }  // namespace
 
 WebFrame::WebFrame(v8::Isolate* isolate)
@@ -139,10 +164,15 @@ void WebFrame::SetSpellCheckProvider(mate::Arguments* args,
     return;
   }
 
-  spell_check_client_.reset(new SpellCheckClient(
+  std::unique_ptr<SpellCheckClient> client(new SpellCheckClient(
       language, auto_spell_correct_turned_on, args->isolate(), provider));
+  // Set spellchecker for all live frames in the same process or
+  // in the sandbox mode for all live sub frames to this WebFrame.
+  FrameSpellChecker spell_checker(
+      client.get(), content::RenderFrame::FromWebFrame(web_frame_));
+  content::RenderFrame::ForEach(&spell_checker);
+  spell_check_client_.swap(client);
   web_frame_->View()->SetSpellCheckClient(spell_check_client_.get());
-  web_frame_->SetTextCheckClient(spell_check_client_.get());
 }
 
 void WebFrame::RegisterURLSchemeAsSecure(const std::string& scheme) {

brightray/brightray.gyp

@@ -1,10 +1,12 @@
 {
   'variables': {
     # The libraries brightray will be compiled to.
-    'linux_system_libraries': 'gtk+-2.0 dbus-1 x11 x11-xcb xcb xi xcursor xdamage xrandr xcomposite xext xfixes xrender xtst xscrnsaver gconf-2.0 gmodule-2.0 nss',
+    'linux_system_libraries': 'gtk+-2.0 dbus-1 x11 x11-xcb xcb xi xcursor xdamage xrandr xcomposite xext xfixes xrender xtst xscrnsaver gconf-2.0 gmodule-2.0',
     'conditions': [
       ['target_arch=="mips64el"', {
         'linux_system_libraries': '<(linux_system_libraries) libpulse',
+      }, {
+        'linux_system_libraries': '<(linux_system_libraries) nss',
       }],
     ],
   },

brightray/brightray.gypi

@@ -118,16 +118,10 @@
             'defines': [
               'USE_OPENSSL',
             ],
-          }, {
-            'defines': [
-              'USE_X11',
-              # "use_nss_certs" is set to 1 in libchromiumcontent.
-              'USE_NSS_CERTS',
-              'USE_NSS',  # deprecated after Chrome 45.
-            ],
           }],
           ['OS=="linux"', {
             'defines': [
+              'USE_X11',
               '_LARGEFILE_SOURCE',
               '_LARGEFILE64_SOURCE',
               '_FILE_OFFSET_BITS=64',
@@ -137,6 +131,11 @@
               '-fno-rtti',
             ],
           }],  # OS=="linux"
+          ['OS=="linux" and target_arch!="mips64el"', {
+            'defines': [
+              'USE_NSS_CERTS',
+            ],
+          }],  # OS=="linux" and target_arch!="mips64el"
           ['OS=="mac"', {
             'defines': [
               # The usage of "webrtc/modules/desktop_capture/desktop_capture_options.h"
@@ -241,9 +240,16 @@
             # perform FPO regardless, so we must explicitly disable.
             # We still want the false setting above to avoid having
             # "/Oy /Oy-" and warnings about overriding.
-            'AdditionalOptions': ['/Oy-'],
+            'AdditionalOptions': ['/Oy-', '/d2guard4'],
           },
           'VCLinkerTool': {
+            # Control Flow Guard is a security feature in Windows
+            # 8.1 and higher designed to prevent exploitation of
+            # indirect calls in executables.
+            # Control Flow Guard is enabled using the /d2guard4
+            # compiler setting in combination with the /guard:cf
+            # linker setting.
+            'AdditionalOptions': ['/guard:cf'],
             # Turn off incremental linking to save binary size.
             'LinkIncremental': '1',  # /INCREMENTAL:NO
           },

docs/tutorial/supported-platforms.md

@@ -17,15 +17,27 @@ Please note, the `ARM` version of Windows is not supported for now.
 
 ### Linux
 
-The prebuilt `ia32` (`i686`) and `x64` (`amd64`) binaries of Electron are built on
-Ubuntu 12.04, the `arm` binary is built against ARM v7 with hard-float ABI and
-NEON for Debian Wheezy.
-
-Whether the prebuilt binary can run on a distribution depends on whether the
-distribution includes the libraries that Electron is linked to on the building
-platform, so only Ubuntu 12.04 is guaranteed to work, but following platforms
-are also verified to be able to run the prebuilt binaries of Electron:
+The prebuilt binaries of Electron are built for Debian Jessie, but whether the
+prebuilt binary can run on a distribution depends on whether the distribution
+includes the libraries that Electron is linked to on the building platform, so
+only Debian Jessie is guaranteed to work, but following platforms are also
+verified to be able to run the prebuilt binaries of Electron:
 
 * Ubuntu 12.04 and later
 * Fedora 21
-* Debian 8
+* Debian 8 and later
+
+Electorn provides prebuilt binaries for following CPU architectures:
+
+* `ia32` (`i686`)
+* `x64` (`amd64`)
+* `armv7l`
+* `arm64`
+* `mips64el`
+
+The `arm` binary is built against ARM v7 with hard-float ABI and NEON, and it is
+not guaranteed to run on all ARM platforms.
+
+The `mips64el` binary is built with toolchains provided by Loongson, and it is
+not guaranteed to run on all MIPS64 platforms. And currently all certificate
+related APIs are not working on `mips64el` builds.

electron.gyp

@@ -4,7 +4,7 @@
     'product_name%': 'Electron',
     'company_name%': 'GitHub, Inc',
     'company_abbr%': 'github',
-    'version%': '1.8.2-beta.2',
+    'version%': '1.8.2',
     'js2c_input_dir': '<(SHARED_INTERMEDIATE_DIR)/js2c',
   },
   'includes': [
@@ -343,7 +343,6 @@
         ['OS=="linux"', {
           'sources': [
             '<@(lib_sources_linux)',
-            '<@(lib_sources_nss)',
           ],
           'link_settings': {
             'ldflags': [
@@ -366,6 +365,11 @@
             'vendor/breakpad/breakpad.gyp:breakpad_client',
           ],
         }],  # OS=="linux"
+        ['OS=="linux" and target_arch!="mips64el"', {
+          'sources': [
+            '<@(lib_sources_nss)',
+          ],
+        }],  # OS=="linux" and target_arch!="mips64el"
         ['OS=="linux" and clang==1', {
           # Required settings of using breakpad.
           'cflags_cc': [

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/menu.js

@@ -44,20 +44,23 @@ Menu.prototype._init = function () {
 }
 
 Menu.prototype.popup = function (window, x, y, positioningItem) {
-  let asyncPopup
+  let asyncPopup, opts
   let [newX, newY, newPosition, newWindow] = [x, y, positioningItem, window]
 
   // menu.popup(x, y, positioningItem)
-  if (!window) {
-    // shift over values
-    if (typeof window !== 'object' || window.constructor !== BrowserWindow) {
-      [newPosition, newY, newX, newWindow] = [y, x, window, null]
-    }
+  if (window != null && !(window instanceof BrowserWindow)) {
+    [newPosition, newY, newX, newWindow] = [y, x, window, null]
   }
 
+  // menu.popup({})
+  if (window != null && window.constructor === Object) {
+    opts = window
   // menu.popup(window, {})
-  if (x && typeof x === 'object') {
-    const opts = x
+  } else if (x && typeof x === 'object') {
+    opts = x
+  }
+
+  if (opts) {
     newX = opts.x
     newY = opts.y
     newPosition = opts.positioningItem
@@ -65,13 +68,28 @@ Menu.prototype.popup = function (window, x, y, positioningItem) {
   }
 
   // set defaults
-  if (typeof x !== 'number') newX = -1
-  if (typeof y !== 'number') newY = -1
-  if (typeof positioningItem !== 'number') newPosition = -1
-  if (!window) newWindow = BrowserWindow.getFocusedWindow()
+  if (typeof newX !== 'number') newX = -1
+  if (typeof newY !== 'number') newY = -1
+  if (typeof newPosition !== 'number') newPosition = -1
   if (typeof asyncPopup !== 'boolean') asyncPopup = false
+  if (!newWindow || (newWindow && newWindow.constructor !== BrowserWindow)) {
+    newWindow = BrowserWindow.getFocusedWindow()
+
+    // No window focused?
+    if (!newWindow) {
+      const browserWindows = BrowserWindow.getAllWindows()
+
+      if (browserWindows && browserWindows.length > 0) {
+        newWindow = browserWindows[0]
+      } else {
+        throw new Error(`Cannot open Menu without a BrowserWindow present`)
+      }
+    }
+  }
 
   this.popupAt(newWindow, newX, newY, newPosition, asyncPopup)
+
+  return { browserWindow: newWindow, x: newX, y: newY, position: newPosition, async: asyncPopup }
 }
 
 Menu.prototype.closePopup = function (window) {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "electron",
-  "version": "1.8.2-beta.2",
+  "version": "1.8.2",
   "repository": "https://github.com/electron/electron",
   "description": "Build cross platform desktop apps with JavaScript, HTML, and CSS",
   "devDependencies": {

script/ci-release-build.js

@@ -32,7 +32,7 @@ async function makeRequest (requestOptions, parseResponse) {
         } else {
           console.log('Error: ', `(status ${res.statusCode})`, err || res.body, requestOptions)
         }
-        reject()
+        reject(err)
       }
     })
   })
@@ -199,7 +199,7 @@ function runRelease (targetBranch, options) {
 module.exports = runRelease
 
 if (require.main === module) {
-  const args = require('minimist')(process.argv.slice(2))
+  const args = require('minimist')(process.argv.slice(2), { boolean: 'ghRelease' })
   const targetBranch = args._[0]
   if (args._.length < 1) {
     console.log(`Trigger CI to build release builds of electron.

script/create-dist.py

@@ -215,7 +215,7 @@ def strip_binary(binary_path):
   elif get_target_arch() == 'arm64':
     strip = 'aarch64-linux-gnu-strip'
   elif get_target_arch() == 'mips64el':
-    strip = 'mips64el-redhat-linux-strip'
+    strip = 'mips64el-loongson-linux-strip'
   else:
     strip = 'strip'
   execute([strip, binary_path], env=build_env())

script/lib/config.py

@@ -8,8 +8,8 @@ import sys
 # URL to the mips64el sysroot image.
 MIPS64EL_SYSROOT_URL = 'https://github.com/electron/debian-sysroot-image-creator/releases/download/v0.5.0/debian_jessie_mips64-sysroot.tar.bz2'
 # URL to the mips64el toolchain.
-MIPS64EL_GCC = 'gcc-4.8.3-d197-n64-loongson'
-MIPS64EL_GCC_URL = 'http://ftp.loongnix.org/toolchain/gcc/release/' + MIPS64EL_GCC + '.tar.gz'
+MIPS64EL_GCC = 'cross-gcc-4.9.3-n64-loongson-rc5.4'
+MIPS64EL_GCC_URL = 'https://github.com/electron/debian-sysroot-image-creator/releases/download/v0.5.0/' + MIPS64EL_GCC + '.tar.gz'
 
 BASE_URL = os.getenv('LIBCHROMIUMCONTENT_MIRROR') or \
     'https://s3.amazonaws.com/github-janky-artifacts/libchromiumcontent'
@@ -93,11 +93,11 @@ def build_env():
     VENDOR_DIR = os.path.join(SOURCE_ROOT, 'vendor')
     gcc_dir = os.path.join(VENDOR_DIR, MIPS64EL_GCC)
     ldlib_dirs = [
-      gcc_dir + '/usr/x86_64-unknown-linux-gnu/mips64el-redhat-linux/lib',
+      gcc_dir + '/usr/x86_64-unknown-linux-gnu/mips64el-loongson-linux/lib',
       gcc_dir + '/usr/lib64',
-      gcc_dir + '/usr/mips64el-redhat-linux/lib64',
-      gcc_dir + '/usr/mips64el-redhat-linux/sysroot/lib64',
-      gcc_dir + '/usr/mips64el-redhat-linux/sysroot/usr/lib64',
+      gcc_dir + '/usr/mips64el-loongson-linux/lib64',
+      gcc_dir + '/usr/mips64el-loongson-linux/sysroot/lib64',
+      gcc_dir + '/usr/mips64el-loongson-linux/sysroot/usr/lib64',
     ]
     env['LD_LIBRARY_PATH'] = os.pathsep.join(ldlib_dirs)
     env['PATH'] = os.pathsep.join([gcc_dir + '/usr/bin', env['PATH']])

script/prepare-release.js

@@ -11,6 +11,7 @@ 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
@@ -45,18 +46,23 @@ async function createReleaseBranch () {
   }
 }
 
-function getNewVersion () {
+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}`
-    console.log(`${pass} Successfully bumped version to ${newVersion}`)
+    if (!dryRun) {
+      console.log(`${pass} Successfully bumped version to ${newVersion}`)
+    }
     return newVersion
   } catch (err) {
     console.log(`${fail} Could not bump version, error was:`, err)
@@ -119,23 +125,25 @@ async function createRelease (branchToTarget, isBeta) {
     .catch(err => {
       console.log('$fail} Could not get releases.  Error was', err)
     })
-  let drafts = releases.data.filter(release => release.draft)
+  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.body = releaseNotes
   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)}.`
+      `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
@@ -165,12 +173,37 @@ async function runReleaseBuilds () {
   })
 }
 
+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()

script/publish-to-npm.js

@@ -21,7 +21,8 @@ const files = [
   'index.js',
   'install.js',
   'package.json',
-  'README.md'
+  'README.md',
+  'LICENSE'
 ]
 
 const jsonFields = [
@@ -49,9 +50,10 @@ new Promise((resolve, reject) => {
   tempDir = dirPath
   // copy files from `/npm` to temp directory
   files.forEach((name) => {
+    const noThirdSegment = name === 'README.md' || 'LICENSE'
     fs.writeFileSync(
       path.join(tempDir, name),
-      fs.readFileSync(path.join(__dirname, '..', name === 'README.md' ? '' : 'npm', name))
+      fs.readFileSync(path.join(__dirname, '..', noThirdSegment ? '' : 'npm', name))
     )
   })
   // copy from root package.json to temp/package.json

script/release.js

@@ -31,21 +31,18 @@ async function getDraftRelease (version, skipValidation) {
   let drafts
   let versionToCheck
   if (version) {
-    drafts = releaseInfo.data
-      .filter(release => release.tag_name === version)
     versionToCheck = version
   } else {
-    drafts = releaseInfo.data
-      .filter(release => release.draft)
     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)
-    check(draft.tag_name === versionToCheck, `draft release version matches local package.json (${versionToCheck})`)
-    if (versionToCheck.indexOf('beta')) {
+    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')
@@ -54,8 +51,8 @@ async function getDraftRelease (version, skipValidation) {
   return draft
 }
 
-async function validateReleaseAssets (release) {
-  const requiredAssets = assetsForVersion(release.tag_name).sort()
+async function validateReleaseAssets (release, validatingRelease) {
+  const requiredAssets = assetsForVersion(release.tag_name, validatingRelease).sort()
   const extantAssets = release.assets.map(asset => asset.name).sort()
   const downloadUrls = release.assets.map(asset => asset.browser_download_url).sort()
 
@@ -87,7 +84,7 @@ function check (condition, statement, exitIfFail = false) {
   }
 }
 
-function assetsForVersion (version) {
+function assetsForVersion (version, validatingRelease) {
   const patterns = [
     `electron-${version}-darwin-x64-dsym.zip`,
     `electron-${version}-darwin-x64-symbols.zip`,
@@ -123,9 +120,11 @@ function assetsForVersion (version) {
     `ffmpeg-${version}-linux-x64.zip`,
     `ffmpeg-${version}-mas-x64.zip`,
     `ffmpeg-${version}-win32-ia32.zip`,
-    `ffmpeg-${version}-win32-x64.zip`,
-    `SHASUMS256.txt`
+    `ffmpeg-${version}-win32-x64.zip`
   ]
+  if (!validatingRelease) {
+    patterns.push('SHASUMS256.txt')
+  }
   return patterns
 }
 
@@ -215,7 +214,7 @@ async function uploadShasumFile (filePath, fileName, release) {
     filePath,
     name: fileName
   }
-  return await github.repos.uploadAsset(githubOpts)
+  return github.repos.uploadAsset(githubOpts)
     .catch(err => {
       console.log(`${fail} Error uploading ${filePath} to GitHub:`, err)
       process.exit(1)
@@ -250,7 +249,7 @@ async function publishRelease (release) {
     tag_name: release.tag_name,
     draft: false
   }
-  return await github.repos.editRelease(githubOpts)
+  return github.repos.editRelease(githubOpts)
     .catch(err => {
       console.log(`${fail} Error publishing release:`, err)
       process.exit(1)
@@ -259,9 +258,14 @@ async function publishRelease (release) {
 
 async function makeRelease (releaseToValidate) {
   if (releaseToValidate) {
-    console.log(`Validating release ${args.validateRelease}`)
-    let release = await getDraftRelease(args.validateRelease)
-    await validateReleaseAssets(release)
+    if (releaseToValidate === true) {
+      releaseToValidate = pkgVersion
+    } else {
+      console.log('Release to validate !=== true')
+    }
+    console.log(`Validating release ${releaseToValidate}`)
+    let release = await getDraftRelease(releaseToValidate)
+    await validateReleaseAssets(release, true)
   } else {
     checkVersion()
     let draftRelease = await getDraftRelease()
@@ -447,7 +451,7 @@ async function cleanupReleaseBranch () {
   await callGit(['branch', '-D', 'release'], errorMessage, successMessage)
   errorMessage = `Could not delete remote release branch.`
   successMessage = `Successfully deleted remote release branch.`
-  return await callGit(['push', 'origin', ':release'], errorMessage, successMessage)
+  return callGit(['push', 'origin', ':release'], errorMessage, successMessage)
 }
 
 async function callGit (args, errorMessage, successMessage) {

script/upload.py

@@ -179,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:

spec/api-app-spec.js

@@ -531,6 +531,54 @@ describe('app module', () => {
     })
   })
 
+  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', () => {
     const iconPath = path.join(__dirname, 'fixtures/assets/icon.ico')
     const sizes = {

spec/api-menu-spec.js

@@ -279,14 +279,26 @@ describe('Menu module', () => {
     })
 
     afterEach(() => {
+      menu.closePopup()
+      menu.closePopup(w)
       return closeWindow(w).then(() => { w = null })
     })
 
-    describe('when called with async: true', () => {
-      it('returns immediately', () => {
-        menu.popup(w, {x: 100, y: 100, async: true})
-        menu.closePopup(w)
-      })
+    it('returns immediately', () => {
+      const { browserWindow, x, y, async } = menu.popup(w, {x: 100, y: 101, async: true})
+
+      assert.equal(browserWindow, w)
+      assert.equal(x, 100)
+      assert.equal(y, 101)
+      assert.equal(async, true)
+    })
+
+    it('works without a given BrowserWindow and options', () => {
+      const { browserWindow, x, y } = menu.popup({x: 100, y: 101, async: true})
+
+      assert.equal(browserWindow.constructor.name, 'BrowserWindow')
+      assert.equal(x, 100)
+      assert.equal(y, 101)
     })
   })
 

spec/node-spec.js

@@ -293,6 +293,20 @@ describe('node feature', () => {
       buffer = new Buffer(new Array(4097).join(' '))
       assert.equal(buffer.length, 4096)
     })
+
+    it('does not crash for crypto operations', () => {
+      const crypto = require('crypto')
+      const data = 'lG9E+/g4JmRmedDAnihtBD4Dfaha/GFOjd+xUOQI05UtfVX3DjUXvrS98p7kZQwY3LNhdiFo7MY5rGft8yBuDhKuNNag9vRx/44IuClDhdQ='
+      const key = 'q90K9yBqhWZnAMCMTOJfPQ=='
+      const cipherText = '{"error_code":114,"error_message":"Tham số không hợp lệ","data":null}'
+      for (let i = 0; i < 10000; ++i) {
+        let iv = Buffer.from('0'.repeat(32), 'hex')
+        let input = Buffer.from(data, 'base64')
+        let decipher = crypto.createDecipheriv('aes-128-cbc', Buffer.from(key, 'base64'), iv)
+        let result = Buffer.concat([decipher.update(input), decipher.final()])
+        assert.equal(cipherText, result)
+      }
+    })
   })
 
   describe('process.stdout', () => {

toolchain.gypi

@@ -6,7 +6,7 @@
     'clang%': 1,
 
     # Path to mips64el toolchain.
-    'make_mips64_dir%': 'vendor/gcc-4.8.3-d197-n64-loongson/usr',
+    'make_mips64_dir%': 'vendor/cross-gcc-4.9.3-n64-loongson-rc5.4/usr',
 
     'variables': {
       # The minimum macOS SDK version to use.
@@ -138,8 +138,8 @@
 
     ['target_arch=="mips64el"', {
       'make_global_settings': [
-        ['CC', '<(make_mips64_dir)/bin/mips64el-redhat-linux-gcc'],
-        ['CXX', '<(make_mips64_dir)/bin/mips64el-redhat-linux-g++'],
+        ['CC', '<(make_mips64_dir)/bin/mips64el-loongson-linux-gcc'],
+        ['CXX', '<(make_mips64_dir)/bin/mips64el-loongson-linux-g++'],
         ['CC.host', '$(CC)'],
         ['CXX.host', '$(CXX)'],
       ],