Merge branch 'master' into ahmedmohamedali-master

.circleci/config.yml

@@ -9,16 +9,9 @@ jobs:
     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: |
-            MESSAGE="$(git log --format=%B -n 1 HEAD)"
-            case ${MESSAGE} in
-              Bump* ) echo 'export ELECTRON_RELEASE=1' >> $BASH_ENV
-            esac
             if [ -n "${RUN_RELEASE_BUILD}" ]; then
               echo 'release build triggered from api'
               echo 'export ELECTRON_RELEASE=1 TRIGGERED_BY_API=1' >> $BASH_ENV
@@ -73,16 +66,9 @@ jobs:
     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: |
-            MESSAGE="$(git log --format=%B -n 1 HEAD)"
-            case ${MESSAGE} in
-              Bump* ) echo 'export ELECTRON_RELEASE=1' >> $BASH_ENV
-            esac
             if [ -n "${RUN_RELEASE_BUILD}" ]; then
               echo 'release build triggered from api'
               echo 'export ELECTRON_RELEASE=1 TRIGGERED_BY_API=1' >> $BASH_ENV
@@ -137,16 +123,9 @@ jobs:
     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: |
-            MESSAGE="$(git log --format=%B -n 1 HEAD)"
-            case ${MESSAGE} in
-              Bump* ) echo 'export ELECTRON_RELEASE=1' >> $BASH_ENV
-            esac
             if [ -n "${RUN_RELEASE_BUILD}" ]; then
               echo 'release build triggered from api'
               echo 'export ELECTRON_RELEASE=1 TRIGGERED_BY_API=1' >> $BASH_ENV
@@ -199,6 +178,7 @@ jobs:
       - image: electronbuilds/electron:0.0.3
         environment:
           TARGET_ARCH: x64
+          DISPLAY: ':99.0'
     resource_class: xlarge
     steps:
       - checkout
@@ -208,10 +188,6 @@ jobs:
       - run:
           name: Check for release
           command: |
-            MESSAGE="$(git log --format=%B -n 1 HEAD)"
-            case ${MESSAGE} in
-              Bump* ) echo 'export ELECTRON_RELEASE=1' >> $BASH_ENV
-            esac
             if [ -n "${RUN_RELEASE_BUILD}" ]; then
               echo 'release build triggered from api'
               echo 'export ELECTRON_RELEASE=1 TRIGGERED_BY_API=1' >> $BASH_ENV
@@ -280,10 +256,17 @@ jobs:
              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

CONTRIBUTING.md

@@ -1,7 +1,5 @@
 # Contributing to Electron
 
-:memo: Available Translations: [Korean](https://github.com/electron/electron/tree/master/docs-translations/ko-KR/project/CONTRIBUTING.md) | [Simplified Chinese](https://github.com/electron/electron/tree/master/docs-translations/zh-CN/project/CONTRIBUTING.md) | [Brazilian Portuguese](https://github.com/electron/electron/tree/master/docs-translations/pt-BR/project/CONTRIBUTING.md) | [Dutch](https://github.com/electron/electron/tree/master/docs-translations/nl/project/CONTRIBUTING.md)
-
 :+1::tada: First off, thanks for taking the time to contribute! :tada::+1:
 
 This project adheres to the Contributor Covenant [code of conduct](CODE_OF_CONDUCT.md).

README.md

@@ -5,7 +5,8 @@
 [![devDependency Status](https://david-dm.org/electron/electron/dev-status.svg)](https://david-dm.org/electron/electron?type=dev)
 [![Join the Electron Community on Slack](http://atom-slack.herokuapp.com/badge.svg)](http://atom-slack.herokuapp.com/)
 
-:memo: Available Translations: [Korean](https://github.com/electron/electron/tree/master/docs-translations/ko-KR/project/README.md) | [Simplified Chinese](https://github.com/electron/electron/tree/master/docs-translations/zh-CN/project/README.md) | [Brazilian Portuguese](https://github.com/electron/electron/tree/master/docs-translations/pt-BR/project/README.md) | [Traditional Chinese](https://github.com/electron/electron/tree/master/docs-translations/zh-TW/project/README.md) | [Spanish](https://github.com/electron/electron/tree/master/docs-translations/es/project/README.md) | [Turkish](https://github.com/electron/electron/tree/master/docs-translations/tr-TR/project/README.md) | [German](https://github.com/electron/electron/tree/master/docs-translations/de-DE/project/README.md)
+:memo: Available Translations: 🇨🇳 🇹🇼 🇧🇷 🇪🇸 🇰🇷 🇯🇵 🇷🇺 🇫🇷 🇹🇭 🇳🇱 🇹🇷 🇮🇩 🇺🇦 🇨🇿 🇮🇹.
+View these docs in other languages at [electron/electron-i18n](https://github.com/electron/electron-i18n/tree/master/content/).
 
 The Electron framework lets you write cross-platform desktop applications
 using JavaScript, HTML and CSS. It is based on [Node.js](https://nodejs.org/) and
@@ -82,18 +83,7 @@ const child = proc.spawn(electron)
 
 ## Documentation Translations
 
-- [Brazilian Portuguese](https://github.com/electron/electron/tree/master/docs-translations/pt-BR)
-- [Korean](https://github.com/electron/electron/tree/master/docs-translations/ko-KR)
-- [Japanese](https://github.com/electron/electron/tree/master/docs-translations/jp)
-- [Spanish](https://github.com/electron/electron/tree/master/docs-translations/es)
-- [Simplified Chinese](https://github.com/electron/electron/tree/master/docs-translations/zh-CN)
-- [Traditional Chinese](https://github.com/electron/electron/tree/master/docs-translations/zh-TW)
-- [Turkish](https://github.com/electron/electron/tree/master/docs-translations/tr-TR)
-- [Thai](https://github.com/electron/electron/tree/master/docs-translations/th-TH)
-- [Ukrainian](https://github.com/electron/electron/tree/master/docs-translations/uk-UA)
-- [Russian](https://github.com/electron/electron/tree/master/docs-translations/ru-RU)
-- [French](https://github.com/electron/electron/tree/master/docs-translations/fr-FR)
-- [Indonesian](https://github.com/electron/electron/tree/master/docs-translations/id)
+Find documentation translations in [electron/electron-18n](https://github.com/electron/electron-i18n).
 
 ## Community
 
@@ -105,6 +95,7 @@ forums
 - [`Atom`](http://atom-slack.herokuapp.com/) channel on Slack
 - [`electron-ru`](https://telegram.me/electron_ru) *(Russian)*
 - [`electron-br`](https://electron-br.slack.com) *(Brazilian Portuguese)*
+- [`electron-kr`](https://electron-kr.github.io/electron-kr) *(Korean)*
 - [`electron-jp`](https://electron-jp.slack.com) *(Japanese)*
 - [`electron-tr`](http://electron-tr.herokuapp.com) *(Turkish)*
 - [`electron-id`](https://electron-id.slack.com) *(Indonesia)*

atom/browser/api/atom_api_protocol.cc

@@ -10,6 +10,7 @@
 #include "atom/browser/net/url_request_async_asar_job.h"
 #include "atom/browser/net/url_request_buffer_job.h"
 #include "atom/browser/net/url_request_fetch_job.h"
+#include "atom/browser/net/url_request_stream_job.h"
 #include "atom/browser/net/url_request_string_job.h"
 #include "atom/common/native_mate_converters/callback.h"
 #include "atom/common/native_mate_converters/value_converter.h"
@@ -208,6 +209,8 @@ void Protocol::BuildPrototype(
                  &Protocol::RegisterProtocol<URLRequestAsyncAsarJob>)
       .SetMethod("registerHttpProtocol",
                  &Protocol::RegisterProtocol<URLRequestFetchJob>)
+      .SetMethod("registerStreamProtocol",
+                 &Protocol::RegisterProtocol<URLRequestStreamJob>)
       .SetMethod("unregisterProtocol", &Protocol::UnregisterProtocol)
       .SetMethod("isProtocolHandled", &Protocol::IsProtocolHandled)
       .SetMethod("interceptStringProtocol",
@@ -218,6 +221,8 @@ void Protocol::BuildPrototype(
                  &Protocol::InterceptProtocol<URLRequestAsyncAsarJob>)
       .SetMethod("interceptHttpProtocol",
                  &Protocol::InterceptProtocol<URLRequestFetchJob>)
+      .SetMethod("interceptStreamProtocol",
+                 &Protocol::InterceptProtocol<URLRequestStreamJob>)
       .SetMethod("uninterceptProtocol", &Protocol::UninterceptProtocol);
 }
 

atom/browser/api/atom_api_protocol.h

@@ -78,6 +78,10 @@ class Protocol : public mate::TrackableObject<Protocol> {
     net::URLRequestJob* MaybeCreateJob(
         net::URLRequest* request,
         net::NetworkDelegate* network_delegate) const override {
+      if (!request->initiator().has_value()) {
+        // Don't intercept this request as it was created by `net.request`.
+        return nullptr;
+      }
       RequestJob* request_job = new RequestJob(request, network_delegate);
       request_job->SetHandlerInfo(isolate_, request_context_.get(), handler_);
       return request_job;

atom/browser/api/atom_api_web_contents.cc

@@ -480,7 +480,7 @@ bool WebContents::DidAddMessageToConsole(content::WebContents* source,
                                          const base::string16& message,
                                          int32_t line_no,
                                          const base::string16& source_id) {
-  if (type_ == BROWSER_WINDOW || type_ == OFF_SCREEN) {
+  if (type_ == OFF_SCREEN) {
     return false;
   } else {
     Emit("console-message", level, message, line_no, source_id);
@@ -909,6 +909,17 @@ void WebContents::DevToolsClosed() {
   Emit("devtools-closed");
 }
 
+void WebContents::ShowAutofillPopup(content::RenderFrameHost* frame_host,
+                                    const gfx::RectF& bounds,
+                                    const std::vector<base::string16>& values,
+                                    const std::vector<base::string16>& labels) {
+  auto relay = NativeWindowRelay::FromWebContents(web_contents());
+  if (relay) {
+    relay->window->ShowAutofillPopup(
+        frame_host, web_contents(), bounds, values, labels);
+  }
+}
+
 bool WebContents::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(WebContents, message)
@@ -933,9 +944,10 @@ bool WebContents::OnMessageReceived(const IPC::Message& message,
   auto relay = NativeWindowRelay::FromWebContents(web_contents());
   if (!relay)
     return false;
+  IPC_BEGIN_MESSAGE_MAP_WITH_PARAM(WebContents, message, frame_host)
+    IPC_MESSAGE_HANDLER(AtomAutofillFrameHostMsg_ShowPopup, ShowAutofillPopup)
+  IPC_END_MESSAGE_MAP()
   IPC_BEGIN_MESSAGE_MAP_WITH_PARAM(NativeWindow, message, frame_host)
-    IPC_MESSAGE_FORWARD(AtomAutofillFrameHostMsg_ShowPopup,
-      relay->window.get(), NativeWindow::ShowAutofillPopup)
     IPC_MESSAGE_FORWARD(AtomAutofillFrameHostMsg_HidePopup,
       relay->window.get(), NativeWindow::HideAutofillPopup)
     IPC_MESSAGE_UNHANDLED(handled = false)
@@ -1623,10 +1635,6 @@ bool WebContents::IsOffScreen() const {
 #endif
 }
 
-bool WebContents::IsOffScreenOrEmbedderOffscreen() const {
-  return IsOffScreen() || (embedder_ && embedder_->IsOffScreen());
-}
-
 void WebContents::OnPaint(const gfx::Rect& dirty_rect, const SkBitmap& bitmap) {
   Emit("paint", dirty_rect, gfx::Image::CreateFrom1xBitmap(bitmap));
 }

atom/browser/api/atom_api_web_contents.h

@@ -182,7 +182,6 @@ class WebContents : public mate::TrackableObject<WebContents>,
 
   // Methods for offscreen rendering
   bool IsOffScreen() const;
-  bool IsOffScreenOrEmbedderOffscreen() const;
   void OnPaint(const gfx::Rect& dirty_rect, const SkBitmap& bitmap);
   void StartPainting();
   void StopPainting();
@@ -358,6 +357,11 @@ class WebContents : public mate::TrackableObject<WebContents>,
   void DevToolsOpened() override;
   void DevToolsClosed() override;
 
+  void ShowAutofillPopup(content::RenderFrameHost* frame_host,
+                         const gfx::RectF& bounds,
+                         const std::vector<base::string16>& values,
+                         const std::vector<base::string16>& labels);
+
  private:
   AtomBrowserContext* GetBrowserContext() const;
 

atom/browser/api/atom_api_window.cc

@@ -144,6 +144,7 @@ void Window::Init(v8::Isolate* isolate,
       options,
       parent.IsEmpty() ? nullptr : parent->window_.get()));
   web_contents->SetOwnerWindow(window_.get());
+  window_->set_is_offscreen_dummy(api_web_contents_->IsOffScreen());
 
 #if defined(TOOLKIT_VIEWS)
   // Sets the window icon.

atom/browser/api/event_subscriber.cc

@@ -0,0 +1,121 @@
+// Copyright (c) 2017 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+#include <string>
+
+#include "atom/browser/api/event_subscriber.h"
+#include "atom/common/native_mate_converters/callback.h"
+
+namespace {
+
+// A FunctionTemplate lifetime is bound to the v8 context, so it can be safely
+// stored as a global here since there's only one for the main process.
+v8::Global<v8::FunctionTemplate> g_cached_template;
+
+struct JSHandlerData {
+  JSHandlerData(v8::Isolate* isolate,
+                mate::internal::EventSubscriberBase* subscriber)
+      : handle_(isolate, v8::External::New(isolate, this)),
+        subscriber_(subscriber) {
+    handle_.SetWeak(this, GC, v8::WeakCallbackType::kFinalizer);
+  }
+
+  static void GC(const v8::WeakCallbackInfo<JSHandlerData>& data) {
+    delete data.GetParameter();
+  }
+
+  v8::Global<v8::External> handle_;
+  mate::internal::EventSubscriberBase* subscriber_;
+};
+
+void InvokeCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
+  v8::Locker locker(info.GetIsolate());
+  v8::HandleScope handle_scope(info.GetIsolate());
+  v8::Local<v8::Context> context = info.GetIsolate()->GetCurrentContext();
+  v8::Context::Scope context_scope(context);
+  mate::Arguments args(info);
+  v8::Local<v8::Value> handler, event;
+  args.GetNext(&handler);
+  args.GetNext(&event);
+  DCHECK(handler->IsExternal());
+  DCHECK(event->IsString());
+  JSHandlerData* handler_data = static_cast<JSHandlerData*>(
+      v8::Local<v8::External>::Cast(handler)->Value());
+  handler_data->subscriber_->EventEmitted(mate::V8ToString(event), &args);
+}
+
+}  // namespace
+
+namespace mate {
+
+namespace internal {
+
+EventSubscriberBase::EventSubscriberBase(v8::Isolate* isolate,
+                                         v8::Local<v8::Object> emitter)
+    : isolate_(isolate), emitter_(isolate, emitter) {
+  if (g_cached_template.IsEmpty()) {
+    g_cached_template = v8::Global<v8::FunctionTemplate>(
+        isolate_, v8::FunctionTemplate::New(isolate_, InvokeCallback));
+  }
+}
+
+EventSubscriberBase::~EventSubscriberBase() {
+  if (!isolate_) {
+    return;
+  }
+  RemoveAllListeners();
+  emitter_.Reset();
+  DCHECK_EQ(js_handlers_.size(), 0);
+}
+
+void EventSubscriberBase::On(const std::string& event_name) {
+  DCHECK(js_handlers_.find(event_name) == js_handlers_.end());
+  v8::Locker locker(isolate_);
+  v8::Isolate::Scope isolate_scope(isolate_);
+  v8::HandleScope handle_scope(isolate_);
+  auto fn_template = g_cached_template.Get(isolate_);
+  auto event = mate::StringToV8(isolate_, event_name);
+  auto js_handler_data = new JSHandlerData(isolate_, this);
+  v8::Local<v8::Value> fn = internal::BindFunctionWith(
+      isolate_, isolate_->GetCurrentContext(), fn_template->GetFunction(),
+      js_handler_data->handle_.Get(isolate_), event);
+  js_handlers_.insert(
+      std::make_pair(event_name, v8::Global<v8::Value>(isolate_, fn)));
+  internal::ValueVector converted_args = {event, fn};
+  internal::CallMethodWithArgs(isolate_, emitter_.Get(isolate_), "on",
+                               &converted_args);
+}
+
+void EventSubscriberBase::Off(const std::string& event_name) {
+  v8::Locker locker(isolate_);
+  v8::Isolate::Scope isolate_scope(isolate_);
+  v8::HandleScope handle_scope(isolate_);
+  auto js_handler = js_handlers_.find(event_name);
+  DCHECK(js_handler != js_handlers_.end());
+  RemoveListener(js_handler);
+}
+
+void EventSubscriberBase::RemoveAllListeners() {
+  v8::Locker locker(isolate_);
+  v8::Isolate::Scope isolate_scope(isolate_);
+  v8::HandleScope handle_scope(isolate_);
+  while (!js_handlers_.empty()) {
+    RemoveListener(js_handlers_.begin());
+  }
+}
+
+std::map<std::string, v8::Global<v8::Value>>::iterator
+EventSubscriberBase::RemoveListener(
+    std::map<std::string, v8::Global<v8::Value>>::iterator it) {
+  internal::ValueVector args = {StringToV8(isolate_, it->first),
+                                it->second.Get(isolate_)};
+  internal::CallMethodWithArgs(
+      isolate_, v8::Local<v8::Object>::Cast(emitter_.Get(isolate_)),
+      "removeListener", &args);
+  it->second.Reset();
+  return js_handlers_.erase(it);
+}
+
+}  // namespace internal
+
+}  // namespace mate

atom/browser/api/event_subscriber.h

@@ -0,0 +1,132 @@
+// Copyright (c) 2017 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_API_EVENT_SUBSCRIBER_H_
+#define ATOM_BROWSER_API_EVENT_SUBSCRIBER_H_
+
+#include <map>
+#include <string>
+
+#include "atom/common/api/event_emitter_caller.h"
+#include "base/synchronization/lock.h"
+#include "content/public/browser/browser_thread.h"
+#include "native_mate/native_mate/arguments.h"
+
+namespace mate {
+
+namespace internal {
+
+class EventSubscriberBase {
+ public:
+  EventSubscriberBase(v8::Isolate* isolate, v8::Local<v8::Object> emitter);
+  virtual ~EventSubscriberBase();
+  virtual void EventEmitted(const std::string& event_name,
+                            mate::Arguments* args) = 0;
+
+ protected:
+  void On(const std::string& event_name);
+  void Off(const std::string& event_name);
+  void RemoveAllListeners();
+
+ private:
+  std::map<std::string, v8::Global<v8::Value>>::iterator RemoveListener(
+      std::map<std::string, v8::Global<v8::Value>>::iterator it);
+
+  v8::Isolate* isolate_;
+  v8::Global<v8::Object> emitter_;
+  std::map<std::string, v8::Global<v8::Value>> js_handlers_;
+
+  DISALLOW_COPY_AND_ASSIGN(EventSubscriberBase);
+};
+
+}  // namespace internal
+
+template <typename HandlerType>
+class EventSubscriber : internal::EventSubscriberBase {
+ public:
+  using EventCallback = void (HandlerType::*)(mate::Arguments* args);
+  // Alias to unique_ptr with deleter.
+  using unique_ptr = std::unique_ptr<EventSubscriber<HandlerType>,
+                                     void (*)(EventSubscriber<HandlerType>*)>;
+  // EventSubscriber should only be created/deleted in the main thread since it
+  // communicates with the V8 engine. This smart pointer makes it simpler to
+  // bind the lifetime of EventSubscriber with a class whose lifetime is managed
+  // by a non-UI thread.
+  class SafePtr : public unique_ptr {
+   public:
+    SafePtr() : SafePtr(nullptr) {}
+    explicit SafePtr(EventSubscriber<HandlerType>* ptr)
+        : unique_ptr(ptr, Deleter) {}
+
+   private:
+    // Custom deleter that schedules destructor invocation to the main thread.
+    static void Deleter(EventSubscriber<HandlerType>* ptr) {
+      DCHECK(
+          !::content::BrowserThread::CurrentlyOn(::content::BrowserThread::UI));
+      DCHECK(ptr);
+      // Acquire handler lock and reset handler_ to ensure that any new events
+      // emitted will be ignored after this function returns
+      base::AutoLock auto_lock(ptr->handler_lock_);
+      ptr->handler_ = nullptr;
+      content::BrowserThread::PostTask(
+          content::BrowserThread::UI, FROM_HERE,
+          base::Bind(
+              [](EventSubscriber<HandlerType>* subscriber) {
+                delete subscriber;
+              },
+              ptr));
+    }
+  };
+
+  EventSubscriber(HandlerType* handler,
+                  v8::Isolate* isolate,
+                  v8::Local<v8::Object> emitter)
+      : EventSubscriberBase(isolate, emitter), handler_(handler) {
+    DCHECK_CURRENTLY_ON(::content::BrowserThread::UI);
+  }
+
+  void On(const std::string& event, EventCallback callback) {
+    DCHECK_CURRENTLY_ON(::content::BrowserThread::UI);
+    EventSubscriberBase::On(event);
+    callbacks_.insert(std::make_pair(event, callback));
+  }
+
+  void Off(const std::string& event) {
+    DCHECK_CURRENTLY_ON(::content::BrowserThread::UI);
+    EventSubscriberBase::Off(event);
+    DCHECK(callbacks_.find(event) != callbacks_.end());
+    callbacks_.erase(callbacks_.find(event));
+  }
+
+  void RemoveAllListeners() {
+    DCHECK_CURRENTLY_ON(::content::BrowserThread::UI);
+    EventSubscriberBase::RemoveAllListeners();
+    callbacks_.clear();
+  }
+
+ private:
+  void EventEmitted(const std::string& event_name,
+                    mate::Arguments* args) override {
+    DCHECK_CURRENTLY_ON(::content::BrowserThread::UI);
+    base::AutoLock auto_lock(handler_lock_);
+    if (!handler_) {
+      // handler_ was probably destroyed by another thread and we should not
+      // access it.
+      return;
+    }
+    auto it = callbacks_.find(event_name);
+    if (it != callbacks_.end()) {
+      auto method = it->second;
+      (handler_->*method)(args);
+    }
+  }
+
+  HandlerType* handler_;
+  base::Lock handler_lock_;
+  std::map<std::string, EventCallback> callbacks_;
+};
+
+}  // namespace mate
+
+#endif  // ATOM_BROWSER_API_EVENT_SUBSCRIBER_H_

atom/browser/atom_browser_context.cc

@@ -13,7 +13,6 @@
 #include "atom/browser/net/about_protocol_handler.h"
 #include "atom/browser/net/asar/asar_protocol_handler.h"
 #include "atom/browser/net/atom_cert_verifier.h"
-#include "atom/browser/net/atom_ct_delegate.h"
 #include "atom/browser/net/atom_network_delegate.h"
 #include "atom/browser/net/atom_url_request_job_factory.h"
 #include "atom/browser/net/http_protocol_handler.h"
@@ -72,7 +71,6 @@ AtomBrowserContext::AtomBrowserContext(const std::string& partition,
                                        bool in_memory,
                                        const base::DictionaryValue& options)
     : brightray::BrowserContext(partition, in_memory),
-      ct_delegate_(new AtomCTDelegate),
       network_delegate_(new AtomNetworkDelegate),
       cookie_delegate_(new AtomCookieDelegate) {
   // Construct user agent string.
@@ -192,8 +190,9 @@ content::PermissionManager* AtomBrowserContext::GetPermissionManager() {
   return permission_manager_.get();
 }
 
-std::unique_ptr<net::CertVerifier> AtomBrowserContext::CreateCertVerifier() {
-  return base::WrapUnique(new AtomCertVerifier(ct_delegate_.get()));
+std::unique_ptr<net::CertVerifier> AtomBrowserContext::CreateCertVerifier(
+    brightray::RequireCTDelegate* ct_delegate) {
+  return base::WrapUnique(new AtomCertVerifier(ct_delegate));
 }
 
 std::vector<std::string> AtomBrowserContext::GetCookieableSchemes() {
@@ -204,11 +203,6 @@ std::vector<std::string> AtomBrowserContext::GetCookieableSchemes() {
   return default_schemes;
 }
 
-net::TransportSecurityState::RequireCTDelegate*
-AtomBrowserContext::GetRequireCTDelegate() {
-  return ct_delegate_.get();
-}
-
 void AtomBrowserContext::RegisterPrefs(PrefRegistrySimple* pref_registry) {
   pref_registry->RegisterFilePathPref(prefs::kSelectFileLastDirectory,
                                       base::FilePath());

atom/browser/atom_browser_context.h

@@ -15,7 +15,6 @@
 namespace atom {
 
 class AtomBlobReader;
-class AtomCTDelegate;
 class AtomDownloadManagerDelegate;
 class AtomNetworkDelegate;
 class AtomPermissionManager;
@@ -40,10 +39,9 @@ class AtomBrowserContext : public brightray::BrowserContext {
       content::ProtocolHandlerMap* protocol_handlers) override;
   net::HttpCache::BackendFactory* CreateHttpCacheBackendFactory(
       const base::FilePath& base_path) override;
-  std::unique_ptr<net::CertVerifier> CreateCertVerifier() override;
+  std::unique_ptr<net::CertVerifier> CreateCertVerifier(
+      brightray::RequireCTDelegate* ct_delegate) override;
   std::vector<std::string> GetCookieableSchemes() override;
-  net::TransportSecurityState::RequireCTDelegate* GetRequireCTDelegate()
-      override;
 
   // content::BrowserContext:
   content::DownloadManagerDelegate* GetDownloadManagerDelegate() override;
@@ -69,7 +67,6 @@ class AtomBrowserContext : public brightray::BrowserContext {
   std::unique_ptr<WebViewManager> guest_manager_;
   std::unique_ptr<AtomPermissionManager> permission_manager_;
   std::unique_ptr<AtomBlobReader> blob_reader_;
-  std::unique_ptr<AtomCTDelegate> ct_delegate_;
   std::string user_agent_;
   bool use_cache_;
 

atom/browser/atom_download_manager_delegate.cc

@@ -92,6 +92,7 @@ void AtomDownloadManagerDelegate::OnDownloadPathGenerated(
   // Show save dialog if save path was not set already on item
   file_dialog::DialogSettings settings;
   settings.parent_window = window;
+  settings.force_detached = window->is_offscreen_dummy();
   settings.title = item->GetURL().spec();
   settings.default_path = default_path;
   if (path.empty() && file_dialog::ShowSaveDialog(settings, &path)) {

atom/browser/common_web_contents_delegate.cc

@@ -242,7 +242,8 @@ void CommonWebContentsDelegate::RunFileChooser(
     content::RenderFrameHost* render_frame_host,
     const content::FileChooserParams& params) {
   if (!web_dialog_helper_)
-    web_dialog_helper_.reset(new WebDialogHelper(owner_window()));
+    web_dialog_helper_.reset(new WebDialogHelper(
+        owner_window(), owner_window()->is_offscreen_dummy()));
   web_dialog_helper_->RunFileChooser(render_frame_host, params);
 }
 
@@ -250,7 +251,8 @@ void CommonWebContentsDelegate::EnumerateDirectory(content::WebContents* guest,
                                                    int request_id,
                                                    const base::FilePath& path) {
   if (!web_dialog_helper_)
-    web_dialog_helper_.reset(new WebDialogHelper(owner_window()));
+    web_dialog_helper_.reset(new WebDialogHelper(
+        owner_window(), owner_window()->is_offscreen_dummy()));
   web_dialog_helper_->EnumerateDirectory(guest, request_id, path);
 }
 
@@ -298,6 +300,7 @@ void CommonWebContentsDelegate::DevToolsSaveToFile(
   } else {
     file_dialog::DialogSettings settings;
     settings.parent_window = owner_window();
+    settings.force_detached = owner_window()->is_offscreen_dummy();
     settings.title = url;
     settings.default_path = base::FilePath::FromUTF8Unsafe(url);
     if (!file_dialog::ShowSaveDialog(settings, &path)) {
@@ -364,6 +367,7 @@ void CommonWebContentsDelegate::DevToolsAddFileSystem(
     std::vector<base::FilePath> paths;
     file_dialog::DialogSettings settings;
     settings.parent_window = owner_window();
+    settings.force_detached = owner_window()->is_offscreen_dummy();
     settings.properties = file_dialog::FILE_DIALOG_OPEN_DIRECTORY;
     if (!file_dialog::ShowOpenDialog(settings, &paths))
       return;

atom/browser/native_window.cc

@@ -65,6 +65,7 @@ NativeWindow::NativeWindow(
       aspect_ratio_(0.0),
       parent_(parent),
       is_modal_(false),
+      is_osr_dummy_(false),
       inspectable_web_contents_(inspectable_web_contents),
       weak_factory_(this) {
   options.Get(options::kFrame, &has_frame_);

atom/browser/native_window.h

@@ -231,6 +231,7 @@ class NativeWindow : public base::SupportsUserData,
       const content::NativeWebKeyboardEvent& event) {}
   virtual void ShowAutofillPopup(
     content::RenderFrameHost* frame_host,
+    content::WebContents* web_contents,
     const gfx::RectF& bounds,
     const std::vector<base::string16>& values,
     const std::vector<base::string16>& labels) {}
@@ -288,6 +289,9 @@ class NativeWindow : public base::SupportsUserData,
   SkRegion* draggable_region() const { return draggable_region_.get(); }
   bool enable_larger_than_screen() const { return enable_larger_than_screen_; }
 
+  void set_is_offscreen_dummy(bool is_dummy) { is_osr_dummy_ = is_dummy; }
+  bool is_offscreen_dummy() const { return is_osr_dummy_; }
+
   NativeWindow* parent() const { return parent_; }
   bool is_modal() const { return is_modal_; }
 
@@ -366,6 +370,9 @@ class NativeWindow : public base::SupportsUserData,
   // Is this a modal window.
   bool is_modal_;
 
+  // Is this a dummy window for an offscreen WebContents.
+  bool is_osr_dummy_;
+
   // The page this window is viewing.
   brightray::InspectableWebContents* inspectable_web_contents_;
 

atom/browser/native_window_views.cc

@@ -10,6 +10,8 @@
 #include "atom/browser/api/atom_api_web_contents.h"
 #include "atom/browser/native_browser_view_views.h"
 #include "atom/browser/ui/views/menu_bar.h"
+#include "atom/browser/web_contents_preferences.h"
+#include "atom/browser/web_view_manager.h"
 #include "atom/browser/window_list.h"
 #include "atom/common/color_util.h"
 #include "atom/common/draggable_region.h"
@@ -1357,17 +1359,37 @@ void NativeWindowViews::HandleKeyboardEvent(
 
 void NativeWindowViews::ShowAutofillPopup(
     content::RenderFrameHost* frame_host,
+    content::WebContents* web_contents,
     const gfx::RectF& bounds,
     const std::vector<base::string16>& values,
     const std::vector<base::string16>& labels) {
-  auto wc = atom::api::WebContents::FromWrappedClass(
-    v8::Isolate::GetCurrent(), web_contents());
+  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);
+      }
+    }
+  }
+
   autofill_popup_->CreateView(
-    frame_host,
-    wc->IsOffScreenOrEmbedderOffscreen(),
-    widget(),
-    bounds);
+      frame_host,
+      is_offsceen || is_embedder_offscreen,
+      widget(),
+      bounds);
   autofill_popup_->SetItems(values, labels);
+  autofill_popup_->UpdatePopupBounds(menu_bar_visible_ ? 0 : kMenuBarHeight);
 }
 
 void NativeWindowViews::HideAutofillPopup(
@@ -1389,6 +1411,9 @@ void NativeWindowViews::Layout() {
         gfx::Rect(0, menu_bar_bounds.height(), size.width(),
                   size.height() - menu_bar_bounds.height()));
   }
+
+  if (autofill_popup_.get())
+    autofill_popup_->UpdatePopupBounds(menu_bar_visible_ ? 0 : kMenuBarHeight);
 }
 
 gfx::Size NativeWindowViews::GetMinimumSize() const {

atom/browser/native_window_views.h

@@ -190,6 +190,7 @@ class NativeWindowViews : public NativeWindow,
       const content::NativeWebKeyboardEvent& event) override;
   void ShowAutofillPopup(
     content::RenderFrameHost* frame_host,
+    content::WebContents* web_contents,
     const gfx::RectF& bounds,
     const std::vector<base::string16>& values,
     const std::vector<base::string16>& labels) override;

atom/browser/net/atom_cert_verifier.cc

@@ -5,11 +5,11 @@
 #include "atom/browser/net/atom_cert_verifier.h"
 
 #include "atom/browser/browser.h"
-#include "atom/browser/net/atom_ct_delegate.h"
 #include "atom/common/native_mate_converters/net_converter.h"
 #include "base/containers/linked_list.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
+#include "brightray/browser/net/require_ct_delegate.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/net_errors.h"
 #include "net/cert/cert_verify_result.h"
@@ -147,7 +147,7 @@ class CertVerifierRequest : public AtomCertVerifier::Request {
   base::WeakPtrFactory<CertVerifierRequest> weak_ptr_factory_;
 };
 
-AtomCertVerifier::AtomCertVerifier(AtomCTDelegate* ct_delegate)
+AtomCertVerifier::AtomCertVerifier(brightray::RequireCTDelegate* ct_delegate)
     : default_cert_verifier_(net::CertVerifier::CreateDefault()),
       ct_delegate_(ct_delegate) {}
 

atom/browser/net/atom_cert_verifier.h

@@ -11,9 +11,14 @@
 
 #include "net/cert/cert_verifier.h"
 
+namespace brightray {
+
+class RequireCTDelegate;
+
+}  // namespace brightray
+
 namespace atom {
 
-class AtomCTDelegate;
 class CertVerifierRequest;
 
 struct VerifyRequestParams {
@@ -25,7 +30,7 @@ struct VerifyRequestParams {
 
 class AtomCertVerifier : public net::CertVerifier {
  public:
-  explicit AtomCertVerifier(AtomCTDelegate* ct_delegate);
+  explicit AtomCertVerifier(brightray::RequireCTDelegate* ct_delegate);
   virtual ~AtomCertVerifier();
 
   using VerifyProc = base::Callback<void(const VerifyRequestParams& request,
@@ -34,7 +39,7 @@ class AtomCertVerifier : public net::CertVerifier {
   void SetVerifyProc(const VerifyProc& proc);
 
   const VerifyProc verify_proc() const { return verify_proc_; }
-  AtomCTDelegate* ct_delegate() const { return ct_delegate_; }
+  brightray::RequireCTDelegate* ct_delegate() const { return ct_delegate_; }
   net::CertVerifier* default_verifier() const {
     return default_cert_verifier_.get();
   }
@@ -58,7 +63,7 @@ class AtomCertVerifier : public net::CertVerifier {
   std::map<RequestParams, CertVerifierRequest*> inflight_requests_;
   VerifyProc verify_proc_;
   std::unique_ptr<net::CertVerifier> default_cert_verifier_;
-  AtomCTDelegate* ct_delegate_;
+  brightray::RequireCTDelegate* ct_delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(AtomCertVerifier);
 };

atom/browser/net/js_asker.h

@@ -71,6 +71,7 @@ class JsAsker : public RequestJob {
   void Start() override {
     std::unique_ptr<base::DictionaryValue> request_details(
         new base::DictionaryValue);
+    request_start_time_ = base::TimeTicks::Now();
     FillRequestDetails(request_details.get(), RequestJob::request());
     content::BrowserThread::PostTask(
         content::BrowserThread::UI, FROM_HERE,
@@ -86,6 +87,15 @@ class JsAsker : public RequestJob {
 
   int GetResponseCode() const override { return net::HTTP_OK; }
 
+  // NOTE: We have to implement this method or risk a crash in blink for
+  // redirects!
+  void GetLoadTimingInfo(net::LoadTimingInfo* load_timing_info) const override {
+    load_timing_info->send_start = request_start_time_;
+    load_timing_info->send_end = request_start_time_;
+    load_timing_info->request_start = request_start_time_;
+    load_timing_info->receive_headers_end = response_start_time_;
+  }
+
   void GetResponseInfo(net::HttpResponseInfo* info) override {
     info->headers = new net::HttpResponseHeaders("");
   }
@@ -93,6 +103,7 @@ class JsAsker : public RequestJob {
   // Called when the JS handler has sent the response, we need to decide whether
   // to start, or fail the job.
   void OnResponse(bool success, std::unique_ptr<base::Value> value) {
+    response_start_time_ = base::TimeTicks::Now();
     int error = net::ERR_NOT_IMPLEMENTED;
     if (success && value && !internal::IsErrorOptions(value.get(), &error)) {
       StartAsync(std::move(value));
@@ -105,6 +116,8 @@ class JsAsker : public RequestJob {
   v8::Isolate* isolate_;
   net::URLRequestContextGetter* request_context_getter_;
   JavaScriptHandler handler_;
+  base::TimeTicks request_start_time_;
+  base::TimeTicks response_start_time_;
 
   base::WeakPtrFactory<JsAsker> weak_factory_;
 

atom/browser/net/url_request_stream_job.cc

@@ -0,0 +1,204 @@
+// Copyright (c) 2017 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include <algorithm>
+#include <ostream>
+#include <string>
+
+#include "atom/browser/net/url_request_stream_job.h"
+#include "atom/common/api/event_emitter_caller.h"
+#include "atom/common/atom_constants.h"
+#include "atom/common/native_mate_converters/net_converter.h"
+#include "atom/common/node_includes.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/string_util.h"
+#include "base/time/time.h"
+#include "net/filter/gzip_source_stream.h"
+
+namespace atom {
+
+URLRequestStreamJob::URLRequestStreamJob(net::URLRequest* request,
+                                         net::NetworkDelegate* network_delegate)
+    : JsAsker<net::URLRequestJob>(request, network_delegate),
+      ended_(false),
+      errored_(false),
+      pending_io_buf_(nullptr),
+      pending_io_buf_size_(0),
+      response_headers_(nullptr),
+      weak_factory_(this) {}
+
+void URLRequestStreamJob::BeforeStartInUI(v8::Isolate* isolate,
+                                          v8::Local<v8::Value> value) {
+  if (value->IsNull() || value->IsUndefined() || !value->IsObject()) {
+    // Invalid opts.
+    ended_ = true;
+    errored_ = true;
+    return;
+  }
+
+  mate::Dictionary opts(isolate, v8::Local<v8::Object>::Cast(value));
+  int status_code;
+  if (!opts.Get("statusCode", &status_code)) {
+    // assume HTTP OK if statusCode is not passed.
+    status_code = 200;
+  }
+  std::string status("HTTP/1.1 ");
+  status.append(base::IntToString(status_code));
+  status.append(" ");
+  status.append(
+      net::GetHttpReasonPhrase(static_cast<net::HttpStatusCode>(status_code)));
+  status.append("\0\0", 2);
+  response_headers_ = new net::HttpResponseHeaders(status);
+
+  if (opts.Get("headers", &value)) {
+    mate::Converter<net::HttpResponseHeaders*>::FromV8(isolate, value,
+                                                       response_headers_.get());
+  }
+
+  if (!opts.Get("data", &value)) {
+    // Assume the opts is already a stream
+    value = opts.GetHandle();
+  } else if (value->IsNullOrUndefined()) {
+    // "data" was explicitly passed as null or undefined, assume the user wants
+    // to send an empty body.
+    ended_ = true;
+    return;
+  }
+
+  mate::Dictionary data(isolate, v8::Local<v8::Object>::Cast(value));
+  if (!data.Get("on", &value) || !value->IsFunction() ||
+      !data.Get("removeListener", &value) || !value->IsFunction()) {
+    // If data is passed but it is not a stream, signal an error.
+    ended_ = true;
+    errored_ = true;
+    return;
+  }
+
+  subscriber_.reset(new mate::EventSubscriber<URLRequestStreamJob>(
+      this, isolate, data.GetHandle()));
+  subscriber_->On("data", &URLRequestStreamJob::OnData);
+  subscriber_->On("end", &URLRequestStreamJob::OnEnd);
+  subscriber_->On("error", &URLRequestStreamJob::OnError);
+}
+
+void URLRequestStreamJob::StartAsync(std::unique_ptr<base::Value> options) {
+  NotifyHeadersComplete();
+}
+
+void URLRequestStreamJob::OnData(mate::Arguments* args) {
+  v8::Local<v8::Value> node_data;
+  args->GetNext(&node_data);
+  if (node_data->IsUint8Array()) {
+    const char* data = node::Buffer::Data(node_data);
+    size_t data_size = node::Buffer::Length(node_data);
+    std::copy(data, data + data_size, std::back_inserter(buffer_));
+  } else {
+    NOTREACHED();
+  }
+  if (pending_io_buf_) {
+    CopyMoreData(pending_io_buf_, pending_io_buf_size_);
+  }
+}
+
+void URLRequestStreamJob::OnEnd(mate::Arguments* args) {
+  ended_ = true;
+  if (pending_io_buf_) {
+    CopyMoreData(pending_io_buf_, pending_io_buf_size_);
+  }
+}
+
+void URLRequestStreamJob::OnError(mate::Arguments* args) {
+  errored_ = true;
+  if (pending_io_buf_) {
+    CopyMoreData(pending_io_buf_, pending_io_buf_size_);
+  }
+}
+
+int URLRequestStreamJob::ReadRawData(net::IOBuffer* dest, int dest_size) {
+  content::BrowserThread::PostTask(
+      content::BrowserThread::UI, FROM_HERE,
+      base::Bind(&URLRequestStreamJob::CopyMoreData, weak_factory_.GetWeakPtr(),
+                 make_scoped_refptr(dest), dest_size));
+  return net::ERR_IO_PENDING;
+}
+
+void URLRequestStreamJob::DoneReading() {
+  subscriber_.reset();
+  buffer_.clear();
+  ended_ = true;
+}
+
+void URLRequestStreamJob::DoneReadingRedirectResponse() {
+  DoneReading();
+}
+
+void URLRequestStreamJob::CopyMoreDataDone(scoped_refptr<net::IOBuffer> io_buf,
+                                           int status) {
+  if (status <= 0) {
+    subscriber_.reset();
+  }
+  ReadRawDataComplete(status);
+  io_buf = nullptr;
+}
+
+void URLRequestStreamJob::CopyMoreData(scoped_refptr<net::IOBuffer> io_buf,
+                                       int io_buf_size) {
+  // reset any instance references to io_buf
+  pending_io_buf_ = nullptr;
+  pending_io_buf_size_ = 0;
+
+  int read_count = 0;
+  if (buffer_.size()) {
+    size_t count = std::min((size_t)io_buf_size, buffer_.size());
+    std::copy(buffer_.begin(), buffer_.begin() + count, io_buf->data());
+    buffer_.erase(buffer_.begin(), buffer_.begin() + count);
+    read_count = count;
+  } else if (!ended_ && !errored_) {
+    // No data available yet, save references to the IOBuffer, which will be
+    // passed back to this function when OnData/OnEnd/OnError are called
+    pending_io_buf_ = io_buf;
+    pending_io_buf_size_ = io_buf_size;
+  }
+
+  if (!pending_io_buf_) {
+    // Only call CopyMoreDataDone if we have read something.
+    int status = (errored_ && !read_count) ? net::ERR_FAILED : read_count;
+    content::BrowserThread::PostTask(
+        content::BrowserThread::IO, FROM_HERE,
+        base::Bind(&URLRequestStreamJob::CopyMoreDataDone,
+                   weak_factory_.GetWeakPtr(), io_buf, status));
+  }
+}
+
+std::unique_ptr<net::SourceStream> URLRequestStreamJob::SetUpSourceStream() {
+  std::unique_ptr<net::SourceStream> source =
+      net::URLRequestJob::SetUpSourceStream();
+  size_t i = 0;
+  std::string type;
+  while (response_headers_->EnumerateHeader(&i, "Content-Encoding", &type)) {
+    if (base::LowerCaseEqualsASCII(type, "gzip") ||
+        base::LowerCaseEqualsASCII(type, "x-gzip")) {
+      return net::GzipSourceStream::Create(std::move(source),
+                                           net::SourceStream::TYPE_GZIP);
+    } else if (base::LowerCaseEqualsASCII(type, "deflate")) {
+      return net::GzipSourceStream::Create(std::move(source),
+                                           net::SourceStream::TYPE_DEFLATE);
+    }
+  }
+  return source;
+}
+
+bool URLRequestStreamJob::GetMimeType(std::string* mime_type) const {
+  return response_headers_->GetMimeType(mime_type);
+}
+
+int URLRequestStreamJob::GetResponseCode() const {
+  return response_headers_->response_code();
+}
+
+void URLRequestStreamJob::GetResponseInfo(net::HttpResponseInfo* info) {
+  info->headers = response_headers_;
+}
+
+}  // namespace atom

atom/browser/net/url_request_stream_job.h

@@ -0,0 +1,66 @@
+// Copyright (c) 2017 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_NET_URL_REQUEST_STREAM_JOB_H_
+#define ATOM_BROWSER_NET_URL_REQUEST_STREAM_JOB_H_
+
+#include <deque>
+#include <string>
+
+#include "atom/browser/api/event_subscriber.h"
+#include "atom/browser/net/js_asker.h"
+#include "base/memory/ref_counted_memory.h"
+#include "native_mate/persistent_dictionary.h"
+#include "net/base/io_buffer.h"
+#include "net/http/http_status_code.h"
+#include "net/url_request/url_request_context_getter.h"
+#include "v8/include/v8.h"
+
+namespace atom {
+
+class URLRequestStreamJob : public JsAsker<net::URLRequestJob> {
+ public:
+  URLRequestStreamJob(net::URLRequest* request,
+                      net::NetworkDelegate* network_delegate);
+
+  void OnData(mate::Arguments* args);
+  void OnEnd(mate::Arguments* args);
+  void OnError(mate::Arguments* args);
+
+  // URLRequestJob
+  void GetResponseInfo(net::HttpResponseInfo* info) override;
+
+ protected:
+  // URLRequestJob
+  int ReadRawData(net::IOBuffer* buf, int buf_size) override;
+  void DoneReading() override;
+  void DoneReadingRedirectResponse() override;
+  std::unique_ptr<net::SourceStream> SetUpSourceStream() override;
+  bool GetMimeType(std::string* mime_type) const override;
+  int GetResponseCode() const override;
+
+ private:
+  // JSAsker
+  void BeforeStartInUI(v8::Isolate*, v8::Local<v8::Value>) override;
+  void StartAsync(std::unique_ptr<base::Value> options) override;
+  void OnResponse(bool success, std::unique_ptr<base::Value> value);
+
+  // Callback after data is asynchronously read from the file into |buf|.
+  void CopyMoreData(scoped_refptr<net::IOBuffer> io_buf, int io_buf_size);
+  void CopyMoreDataDone(scoped_refptr<net::IOBuffer> io_buf, int read_count);
+
+  std::deque<char> buffer_;
+  bool ended_;
+  bool errored_;
+  scoped_refptr<net::IOBuffer> pending_io_buf_;
+  int pending_io_buf_size_;
+  scoped_refptr<net::HttpResponseHeaders> response_headers_;
+  mate::EventSubscriber<URLRequestStreamJob>::SafePtr subscriber_;
+  base::WeakPtrFactory<URLRequestStreamJob> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(URLRequestStreamJob);
+};
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_NET_URL_REQUEST_STREAM_JOB_H_

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

@@ -549,7 +549,7 @@ void OffScreenRenderWidgetHostView::SubmitCompositorFrame(
   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
@@ -935,7 +935,7 @@ void OffScreenRenderWidgetHostView::SetNeedsBeginFrames(
   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);
   }
 }
 
@@ -1151,7 +1151,7 @@ void OffScreenRenderWidgetHostView::SetPainting(bool painting) {
   painting_ = painting;
 
   if (software_output_device_) {
-    software_output_device_->SetActive(painting_);
+    software_output_device_->SetActive(painting_, true);
   }
 }
 

atom/browser/ui/autofill_popup.cc

@@ -155,7 +155,6 @@ void AutofillPopup::SetItems(const std::vector<base::string16>& values,
                             const std::vector<base::string16>& labels) {
   values_ = values;
   labels_ = labels;
-  UpdatePopupBounds();
   if (view_) {
     view_->OnSuggestionsChanged();
   }
@@ -166,21 +165,23 @@ void AutofillPopup::AcceptSuggestion(int index) {
     frame_host_->GetRoutingID(), GetValueAt(index)));
 }
 
-void AutofillPopup::UpdatePopupBounds() {
+void AutofillPopup::UpdatePopupBounds(int height_compensation) {
   int desired_width = GetDesiredPopupWidth();
   int desired_height = GetDesiredPopupHeight();
   bool is_rtl = false;
 
+  gfx::Point origin(element_bounds_.origin().x(),
+                    element_bounds_.origin().y() - height_compensation);
+  gfx::Rect bounds(origin, element_bounds_.size());
+
   gfx::Point top_left_corner_of_popup =
-      element_bounds_.origin() +
-      gfx::Vector2d(element_bounds_.width() - desired_width, -desired_height);
+      origin + gfx::Vector2d(bounds.width() - desired_width, -desired_height);
 
   // This is the bottom right point of the popup if the popup is below the
   // element and grows to the right (since the is the lowest and furthest right
   // the popup could go).
   gfx::Point bottom_right_corner_of_popup =
-      element_bounds_.origin() +
-      gfx::Vector2d(desired_width, element_bounds_.height() + desired_height);
+      origin + gfx::Vector2d(desired_width, bounds.height() + desired_height);
 
   display::Display top_left_display =
       GetDisplayNearestPoint(top_left_corner_of_popup, container_view_);
@@ -189,14 +190,19 @@ void AutofillPopup::UpdatePopupBounds() {
 
   std::pair<int, int> popup_x_and_width =
       CalculatePopupXAndWidth(top_left_display, bottom_right_display,
-                              desired_width, element_bounds_, is_rtl);
-  std::pair<int, int> popup_y_and_height = CalculatePopupYAndHeight(
-      top_left_display, bottom_right_display, desired_height, element_bounds_);
+                              desired_width, bounds, is_rtl);
+  std::pair<int, int> popup_y_and_height =
+      CalculatePopupYAndHeight(top_left_display, bottom_right_display,
+                               desired_height, bounds);
 
-  popup_bounds_ = gfx::Rect(popup_x_and_width.first, popup_y_and_height.first,
+  popup_bounds_ = gfx::Rect(
+      popup_x_and_width.first, popup_y_and_height.first,
       popup_x_and_width.second, popup_y_and_height.second);
-  popup_bounds_in_view_ = gfx::Rect(popup_bounds_in_view_.origin(),
+  popup_bounds_in_view_ = gfx::Rect(
+      popup_bounds_in_view_.origin(),
       gfx::Size(popup_x_and_width.second, popup_y_and_height.second));
+  if (view_)
+    view_->DoUpdateBoundsAndRedrawPopup();
 }
 
 int AutofillPopup::GetDesiredPopupHeight() {

atom/browser/ui/autofill_popup.h

@@ -11,6 +11,7 @@
 #include "content/public/browser/render_frame_host.h"
 #include "ui/gfx/font_list.h"
 #include "ui/native_theme/native_theme.h"
+#include "ui/views/view.h"
 #include "ui/views/widget/widget.h"
 
 namespace atom {
@@ -28,13 +29,13 @@ class AutofillPopup {
 
   void SetItems(const std::vector<base::string16>& values,
                 const std::vector<base::string16>& labels);
+  void UpdatePopupBounds(int height_compensation);
 
  private:
   friend class AutofillPopupView;
 
   void AcceptSuggestion(int index);
 
-  void UpdatePopupBounds();
   int GetDesiredPopupHeight();
   int GetDesiredPopupWidth();
   gfx::Rect GetRowBounds(int i);

atom/browser/ui/file_dialog.h

@@ -49,6 +49,7 @@ struct DialogSettings {
   Filters filters;
   int properties = 0;
   bool shows_tag_field = true;
+  bool force_detached = false;
 };
 
 bool ShowOpenDialog(const DialogSettings& settings,

atom/browser/ui/file_dialog_mac.mm

@@ -110,12 +110,13 @@ void SetupDialogForProperties(NSOpenPanel* dialog, int properties) {
 }
 
 // Run modal dialog with parent window and return user's choice.
-int RunModalDialog(NSSavePanel* dialog, atom::NativeWindow* parent_window) {
+int RunModalDialog(NSSavePanel* dialog, const DialogSettings& settings) {
   __block int chosen = NSFileHandlingPanelCancelButton;
-  if (!parent_window || !parent_window->GetNativeWindow()) {
+  if (!settings.parent_window || !settings.parent_window->GetNativeWindow() ||
+      settings.force_detached) {
     chosen = [dialog runModal];
   } else {
-    NSWindow* window = parent_window->GetNativeWindow();
+    NSWindow* window = settings.parent_window->GetNativeWindow();
 
     [dialog beginSheetModalForWindow:window
                    completionHandler:^(NSInteger c) {
@@ -145,7 +146,7 @@ bool ShowOpenDialog(const DialogSettings& settings,
   SetupDialog(dialog, settings);
   SetupDialogForProperties(dialog, settings.properties);
 
-  int chosen = RunModalDialog(dialog, settings.parent_window);
+  int chosen = RunModalDialog(dialog, settings);
   if (chosen == NSFileHandlingPanelCancelButton)
     return false;
 
@@ -164,11 +165,9 @@ void ShowOpenDialog(const DialogSettings& settings,
   // only store the pointer, by duplication we can force gcd to store a copy.
   __block OpenDialogCallback callback = c;
 
-  NSWindow* window = settings.parent_window ?
-      settings.parent_window->GetNativeWindow() :
-      nullptr;
-  [dialog beginSheetModalForWindow:window
-                 completionHandler:^(NSInteger chosen) {
+  if (!settings.parent_window || !settings.parent_window->GetNativeWindow() ||
+      settings.force_detached) {
+    int chosen = [dialog runModal];
     if (chosen == NSFileHandlingPanelCancelButton) {
       callback.Run(false, std::vector<base::FilePath>());
     } else {
@@ -176,7 +175,19 @@ void ShowOpenDialog(const DialogSettings& settings,
       ReadDialogPaths(dialog, &paths);
       callback.Run(true, paths);
     }
-  }];
+  } else {
+    NSWindow* window = settings.parent_window->GetNativeWindow();
+    [dialog beginSheetModalForWindow:window
+                   completionHandler:^(NSInteger chosen) {
+      if (chosen == NSFileHandlingPanelCancelButton) {
+        callback.Run(false, std::vector<base::FilePath>());
+      } else {
+        std::vector<base::FilePath> paths;
+        ReadDialogPaths(dialog, &paths);
+        callback.Run(true, paths);
+      }
+    }];
+  }
 }
 
 bool ShowSaveDialog(const DialogSettings& settings,
@@ -186,7 +197,7 @@ bool ShowSaveDialog(const DialogSettings& settings,
 
   SetupDialog(dialog, settings);
 
-  int chosen = RunModalDialog(dialog, settings.parent_window);
+  int chosen = RunModalDialog(dialog, settings);
   if (chosen == NSFileHandlingPanelCancelButton || ![[dialog URL] isFileURL])
     return false;
 
@@ -203,18 +214,27 @@ void ShowSaveDialog(const DialogSettings& settings,
 
   __block SaveDialogCallback callback = c;
 
-  NSWindow* window = settings.parent_window ?
-    settings.parent_window->GetNativeWindow() :
-    nullptr;
-  [dialog beginSheetModalForWindow:window
-                 completionHandler:^(NSInteger chosen) {
+  if (!settings.parent_window || !settings.parent_window->GetNativeWindow() ||
+      settings.force_detached) {
+    int chosen = [dialog runModal];
     if (chosen == NSFileHandlingPanelCancelButton) {
       callback.Run(false, base::FilePath());
     } else {
       std::string path = base::SysNSStringToUTF8([[dialog URL] path]);
       callback.Run(true, base::FilePath(path));
     }
-  }];
+  } else {
+    NSWindow* window = settings.parent_window->GetNativeWindow();
+    [dialog beginSheetModalForWindow:window
+                   completionHandler:^(NSInteger chosen) {
+      if (chosen == NSFileHandlingPanelCancelButton) {
+        callback.Run(false, base::FilePath());
+      } else {
+        std::string path = base::SysNSStringToUTF8([[dialog URL] path]);
+        callback.Run(true, base::FilePath(path));
+      }
+    }];
+  }
 }
 
 }  // namespace file_dialog

atom/browser/ui/message_box_mac.mm

@@ -146,7 +146,8 @@ int ShowMessageBox(NativeWindow* parent_window,
 
   // Use runModal for synchronous alert without parent, since we don't have a
   // window to wait for.
-  if (!parent_window || !parent_window->GetNativeWindow())
+  if (!parent_window || !parent_window->GetNativeWindow() ||
+      parent_window->is_offscreen_dummy())
     return [[alert autorelease] runModal];
 
   int ret_code = -1;
@@ -181,15 +182,24 @@ void ShowMessageBox(NativeWindow* parent_window,
   NSAlert* alert =
       CreateNSAlert(parent_window, type, buttons, default_id, cancel_id, title,
                     message, detail, checkbox_label, checkbox_checked, icon);
-  ModalDelegate* delegate = [[ModalDelegate alloc] initWithCallback:callback
-                                                           andAlert:alert
-                                                       callEndModal:false];
 
-  NSWindow* window = parent_window ? parent_window->GetNativeWindow() : nil;
-  [alert beginSheetModalForWindow:window
-                    modalDelegate:delegate
-                   didEndSelector:@selector(alertDidEnd:returnCode:contextInfo:)
-                      contextInfo:nil];
+  // Use runModal for synchronous alert without parent, since we don't have a
+  // window to wait for.
+  if (!parent_window || !parent_window->GetNativeWindow() ||
+      parent_window->is_offscreen_dummy()) {
+    int ret = [[alert autorelease] runModal];
+    callback.Run(ret, false);
+  } else {
+    ModalDelegate* delegate = [[ModalDelegate alloc] initWithCallback:callback
+                                                             andAlert:alert
+                                                         callEndModal:false];
+
+    NSWindow* window = parent_window ? parent_window->GetNativeWindow() : nil;
+    [alert beginSheetModalForWindow:window
+                modalDelegate:delegate
+                  didEndSelector:@selector(alertDidEnd:returnCode:contextInfo:)
+                    contextInfo:nil];
+  }
 }
 
 void ShowErrorBox(const base::string16& title, const base::string16& content) {

atom/browser/ui/views/autofill_popup_view.cc

@@ -226,12 +226,13 @@ void AutofillPopupView::OnPaint(gfx::Canvas* canvas) {
   SkBitmap bitmap;
 
 #if defined(ENABLE_OSR)
+  std::unique_ptr<cc::SkiaPaintCanvas> paint_canvas;
   if (view_proxy_.get()) {
     bitmap.allocN32Pixels(popup_->popup_bounds_in_view_.width(),
                           popup_->popup_bounds_in_view_.height(),
                           true);
-    cc::SkiaPaintCanvas paint_canvas(new SkCanvas(bitmap));
-    draw_canvas = new gfx::Canvas(&paint_canvas, 1.0);
+    paint_canvas.reset(new cc::SkiaPaintCanvas(bitmap));
+    draw_canvas = new gfx::Canvas(paint_canvas.get(), 1.0);
   }
 #endif
 

atom/browser/web_dialog_helper.cc

@@ -182,8 +182,9 @@ file_dialog::Filters GetFileTypesFromAcceptType(
 
 namespace atom {
 
-WebDialogHelper::WebDialogHelper(NativeWindow* window)
+WebDialogHelper::WebDialogHelper(NativeWindow* window, bool offscreen)
     : window_(window),
+      offscreen_(offscreen),
       weak_factory_(this) {
 }
 
@@ -197,6 +198,7 @@ void WebDialogHelper::RunFileChooser(
   std::vector<content::FileChooserFileInfo> result;
 
   file_dialog::DialogSettings settings;
+  settings.force_detached = offscreen_;
   settings.filters = GetFileTypesFromAcceptType(params.accept_types);
   settings.parent_window = window_;
   settings.title = base::UTF16ToUTF8(params.title);

atom/browser/web_dialog_helper.h

@@ -23,7 +23,7 @@ class NativeWindow;
 
 class WebDialogHelper {
  public:
-  explicit WebDialogHelper(NativeWindow* window);
+  WebDialogHelper(NativeWindow* window, bool offscreen);
   ~WebDialogHelper();
 
   void RunFileChooser(content::RenderFrameHost* render_frame_host,
@@ -34,6 +34,7 @@ class WebDialogHelper {
 
  private:
   NativeWindow* window_;
+  bool offscreen_;
 
   base::WeakPtrFactory<WebDialogHelper> weak_factory_;
 

atom/common/api/event_emitter_caller.cc

@@ -20,8 +20,18 @@ v8::Local<v8::Value> CallMethodWithArgs(v8::Isolate* isolate,
                                    v8::MicrotasksScope::kRunMicrotasks);
   // Use node::MakeCallback to call the callback, and it will also run pending
   // tasks in Node.js.
-  return node::MakeCallback(isolate, obj, method, args->size(), &args->front(),
-                            {0, 0}).ToLocalChecked();
+  v8::MaybeLocal<v8::Value> ret = node::MakeCallback(isolate, obj, method,
+                                                     args->size(),
+                                                     &args->front(), {0, 0});
+  // If the JS function throws an exception (doesn't return a value) the result
+  // of MakeCallback will be empty and therefore ToLocal will be false, in this
+  // case we need to return "false" as that indicates that the event emitter did
+  // not handle the event
+  v8::Local<v8::Value> localRet;
+  if (ret.ToLocal(&localRet)) {
+    return localRet;
+  }
+  return v8::Boolean::New(isolate, false);
 }
 
 }  // namespace internal

atom/common/atom_version.h

@@ -8,11 +8,10 @@
 #define ATOM_MAJOR_VERSION 1
 #define ATOM_MINOR_VERSION 8
 #define ATOM_PATCH_VERSION 2
+#define ATOM_PRE_RELEASE_VERSION -beta.2
 
-#define ATOM_VERSION_IS_RELEASE 1
-
-#ifndef ATOM_TAG
-# define ATOM_TAG ""
+#ifndef ATOM_PRE_RELEASE_VERSION
+# define ATOM_PRE_RELEASE_VERSION ""
 #endif
 
 #ifndef ATOM_STRINGIFY
@@ -20,17 +19,10 @@
 #define ATOM_STRINGIFY_HELPER(n) #n
 #endif
 
-#if ATOM_VERSION_IS_RELEASE
 # define ATOM_VERSION_STRING  ATOM_STRINGIFY(ATOM_MAJOR_VERSION) "." \
                               ATOM_STRINGIFY(ATOM_MINOR_VERSION) "." \
                               ATOM_STRINGIFY(ATOM_PATCH_VERSION)     \
-                              ATOM_TAG
-#else
-# define ATOM_VERSION_STRING  ATOM_STRINGIFY(ATOM_MAJOR_VERSION) "." \
-                              ATOM_STRINGIFY(ATOM_MINOR_VERSION) "." \
-                              ATOM_STRINGIFY(ATOM_PATCH_VERSION)     \
-                              ATOM_TAG "-pre"
-#endif
+                              ATOM_STRINGIFY(ATOM_PRE_RELEASE_VERSION)
 
 #define ATOM_VERSION "v" ATOM_VERSION_STRING
 

atom/common/native_mate_converters/callback.cc

@@ -38,22 +38,6 @@ void CallTranslater(v8::Local<v8::External> external,
   delete holder;
 }
 
-// func.bind(func, arg1).
-// NB(zcbenz): Using C++11 version crashes VS.
-v8::Local<v8::Value> BindFunctionWith(v8::Isolate* isolate,
-                                      v8::Local<v8::Context> context,
-                                      v8::Local<v8::Function> func,
-                                      v8::Local<v8::Value> arg1,
-                                      v8::Local<v8::Value> arg2) {
-  v8::MaybeLocal<v8::Value> bind = func->Get(mate::StringToV8(isolate, "bind"));
-  CHECK(!bind.IsEmpty());
-  v8::Local<v8::Function> bind_func =
-      v8::Local<v8::Function>::Cast(bind.ToLocalChecked());
-  v8::Local<v8::Value> converted[] = { func, arg1, arg2 };
-  return bind_func->Call(
-      context, func, arraysize(converted), converted).ToLocalChecked();
-}
-
 }  // namespace
 
 // Destroy the class on UI thread when possible.
@@ -130,6 +114,22 @@ v8::Local<v8::Value> CreateFunctionFromTranslater(
                           v8::Object::New(isolate));
 }
 
+// func.bind(func, arg1).
+// NB(zcbenz): Using C++11 version crashes VS.
+v8::Local<v8::Value> BindFunctionWith(v8::Isolate* isolate,
+                                      v8::Local<v8::Context> context,
+                                      v8::Local<v8::Function> func,
+                                      v8::Local<v8::Value> arg1,
+                                      v8::Local<v8::Value> arg2) {
+  v8::MaybeLocal<v8::Value> bind = func->Get(mate::StringToV8(isolate, "bind"));
+  CHECK(!bind.IsEmpty());
+  v8::Local<v8::Function> bind_func =
+      v8::Local<v8::Function>::Cast(bind.ToLocalChecked());
+  v8::Local<v8::Value> converted[] = {func, arg1, arg2};
+  return bind_func->Call(context, func, arraysize(converted), converted)
+      .ToLocalChecked();
+}
+
 }  // namespace internal
 
 }  // namespace mate

atom/common/native_mate_converters/callback.h

@@ -111,6 +111,11 @@ struct V8FunctionInvoker<ReturnType(ArgTypes...)> {
 using Translater = base::Callback<void(Arguments* args)>;
 v8::Local<v8::Value> CreateFunctionFromTranslater(
     v8::Isolate* isolate, const Translater& translater);
+v8::Local<v8::Value> BindFunctionWith(v8::Isolate* isolate,
+                                      v8::Local<v8::Context> context,
+                                      v8::Local<v8::Function> func,
+                                      v8::Local<v8::Value> arg1,
+                                      v8::Local<v8::Value> arg2);
 
 // Calls callback with Arguments.
 template <typename Sig>

atom/common/native_mate_converters/net_converter.cc

@@ -165,6 +165,35 @@ v8::Local<v8::Value> Converter<net::HttpResponseHeaders*>::ToV8(
   return ConvertToV8(isolate, response_headers);
 }
 
+bool Converter<net::HttpResponseHeaders*>::FromV8(
+    v8::Isolate* isolate,
+    v8::Local<v8::Value> val,
+    net::HttpResponseHeaders* out) {
+  if (!val->IsObject()) {
+    return false;
+  }
+  auto context = isolate->GetCurrentContext();
+  auto headers = v8::Local<v8::Object>::Cast(val);
+  auto keys = headers->GetOwnPropertyNames();
+  for (uint32_t i = 0; i < keys->Length(); i++) {
+    v8::Local<v8::String> key, value;
+    if (!keys->Get(i)->ToString(context).ToLocal(&key)) {
+      return false;
+    }
+    if (!headers->Get(key)->ToString(context).ToLocal(&value)) {
+      return false;
+    }
+    v8::String::Utf8Value key_utf8(key);
+    v8::String::Utf8Value value_utf8(value);
+    std::string k(*key_utf8, key_utf8.length());
+    std::string v(*value_utf8, value_utf8.length());
+    std::ostringstream tmp;
+    tmp << k << ": " << v;
+    out->AddHeader(tmp.str());
+  }
+  return true;
+}
+
 }  // namespace mate
 
 namespace atom {
@@ -180,6 +209,13 @@ void FillRequestDetails(base::DictionaryValue* details,
   GetUploadData(list.get(), request);
   if (!list->empty())
     details->Set("uploadData", std::move(list));
+  std::unique_ptr<base::DictionaryValue> headers_value(
+      new base::DictionaryValue);
+  for (net::HttpRequestHeaders::Iterator it(request->extra_request_headers());
+       it.GetNext();) {
+    headers_value->SetString(it.name(), it.value());
+  }
+  details->Set("headers", std::move(headers_value));
 }
 
 void GetUploadData(base::ListValue* upload_data_list,

atom/common/native_mate_converters/net_converter.h

@@ -49,6 +49,9 @@ template <>
 struct Converter<net::HttpResponseHeaders*> {
   static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
                                    net::HttpResponseHeaders* headers);
+  static bool FromV8(v8::Isolate* isolate,
+                     v8::Local<v8::Value> val,
+                     net::HttpResponseHeaders* out);
 };
 
 }  // namespace mate

atom/renderer/atom_autofill_agent.cc

@@ -203,7 +203,7 @@ void AutofillAgent::ShowPopup(
 void AutofillAgent::OnAcceptSuggestion(base::string16 suggestion) {
   auto element = render_frame()->GetWebFrame()->GetDocument().FocusedElement();
   if (element.IsFormControlElement()) {
-    ToWebInputElement(&element)->SetSuggestedValue(
+    ToWebInputElement(&element)->SetAutofillValue(
       blink::WebString::FromUTF16(suggestion));
   }
 }

brightray/browser/mac/bry_inspectable_web_contents_view.mm

@@ -94,7 +94,6 @@
     if (visible) {
       [devtools_window_ makeKeyAndOrderFront:nil];
     } else {
-      [[self window] makeKeyAndOrderFront:nil];
       [devtools_window_ setDelegate:nil];
       [devtools_window_ close];
       devtools_window_.reset();

brightray/browser/net/require_ct_delegate.cc

@@ -1,28 +1,28 @@
-// Copyright (c) 2016 GitHub, Inc.
+// Copyright (c) 2017 GitHub, Inc.
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#include "atom/browser/net/atom_ct_delegate.h"
+#include "brightray/browser/net/require_ct_delegate.h"
 
 #include "content/public/browser/browser_thread.h"
 
-namespace atom {
+namespace brightray {
 
-AtomCTDelegate::AtomCTDelegate() {}
+RequireCTDelegate::RequireCTDelegate() {}
 
-AtomCTDelegate::~AtomCTDelegate() {}
+RequireCTDelegate::~RequireCTDelegate() {}
 
-void AtomCTDelegate::AddCTExcludedHost(const std::string& host) {
+void RequireCTDelegate::AddCTExcludedHost(const std::string& host) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   ct_excluded_hosts_.insert(host);
 }
 
-void AtomCTDelegate::ClearCTExcludedHostsList() {
+void RequireCTDelegate::ClearCTExcludedHostsList() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   ct_excluded_hosts_.clear();
 }
 
-AtomCTDelegate::CTRequirementLevel AtomCTDelegate::IsCTRequiredForHost(
+RequireCTDelegate::CTRequirementLevel RequireCTDelegate::IsCTRequiredForHost(
     const std::string& host) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   if (!ct_excluded_hosts_.empty() &&
@@ -31,4 +31,4 @@ AtomCTDelegate::CTRequirementLevel AtomCTDelegate::IsCTRequiredForHost(
   return CTRequirementLevel::DEFAULT;
 }
 
-}  // namespace atom
+}  // namespace brightray

brightray/browser/net/require_ct_delegate.h

@@ -1,21 +1,22 @@
-// Copyright (c) 2016 GitHub, Inc.
+// Copyright (c) 2017 GitHub, Inc.
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#ifndef ATOM_BROWSER_NET_ATOM_CT_DELEGATE_H_
-#define ATOM_BROWSER_NET_ATOM_CT_DELEGATE_H_
+#ifndef BRIGHTRAY_BROWSER_NET_REQUIRE_CT_DELEGATE_H_
+#define BRIGHTRAY_BROWSER_NET_REQUIRE_CT_DELEGATE_H_
 
 #include <set>
 #include <string>
 
 #include "net/http/transport_security_state.h"
 
-namespace atom {
+namespace brightray {
 
-class AtomCTDelegate : public net::TransportSecurityState::RequireCTDelegate {
+class RequireCTDelegate
+    : public net::TransportSecurityState::RequireCTDelegate {
  public:
-  AtomCTDelegate();
-  ~AtomCTDelegate() override;
+  RequireCTDelegate();
+  ~RequireCTDelegate() override;
 
   void AddCTExcludedHost(const std::string& host);
   void ClearCTExcludedHostsList();
@@ -25,9 +26,9 @@ class AtomCTDelegate : public net::TransportSecurityState::RequireCTDelegate {
 
  private:
   std::set<std::string> ct_excluded_hosts_;
-  DISALLOW_COPY_AND_ASSIGN(AtomCTDelegate);
+  DISALLOW_COPY_AND_ASSIGN(RequireCTDelegate);
 };
 
-}  // namespace atom
+}  // namespace brightray
 
-#endif  // ATOM_BROWSER_NET_ATOM_CT_DELEGATE_H_
+#endif  // BRIGHTRAY_BROWSER_NET_REQUIRE_CT_DELEGATE_H_

brightray/browser/url_request_context_getter.cc

@@ -14,6 +14,7 @@
 #include "base/threading/worker_pool.h"
 #include "brightray/browser/net/devtools_network_controller_handle.h"
 #include "brightray/browser/net/devtools_network_transaction_factory.h"
+#include "brightray/browser/net/require_ct_delegate.h"
 #include "brightray/browser/net_log.h"
 #include "brightray/browser/network_delegate.h"
 #include "brightray/common/switches.h"
@@ -107,7 +108,8 @@ URLRequestContextGetter::Delegate::CreateHttpCacheBackendFactory(
 }
 
 std::unique_ptr<net::CertVerifier>
-URLRequestContextGetter::Delegate::CreateCertVerifier() {
+URLRequestContextGetter::Delegate::CreateCertVerifier(
+    RequireCTDelegate* ct_delegate) {
   return net::CertVerifier::CreateDefault();
 }
 
@@ -170,6 +172,7 @@ net::URLRequestContext* URLRequestContextGetter::GetURLRequestContext() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (!url_request_context_.get()) {
+    ct_delegate_.reset(new RequireCTDelegate);
     auto& command_line = *base::CommandLine::ForCurrentProcess();
     url_request_context_.reset(new net::URLRequestContext);
 
@@ -280,10 +283,10 @@ net::URLRequestContext* URLRequestContextGetter::GetURLRequestContext() {
 
     std::unique_ptr<net::TransportSecurityState> transport_security_state =
         base::WrapUnique(new net::TransportSecurityState);
-    transport_security_state->SetRequireCTDelegate(
-        delegate_->GetRequireCTDelegate());
+    transport_security_state->SetRequireCTDelegate(ct_delegate_.get());
     storage_->set_transport_security_state(std::move(transport_security_state));
-    storage_->set_cert_verifier(delegate_->CreateCertVerifier());
+    storage_->set_cert_verifier(
+        delegate_->CreateCertVerifier(ct_delegate_.get()));
     storage_->set_ssl_config_service(delegate_->CreateSSLConfigService());
     storage_->set_http_auth_handler_factory(std::move(auth_handler_factory));
     std::unique_ptr<net::HttpServerProperties> server_properties(

brightray/browser/url_request_context_getter.h

@@ -33,6 +33,7 @@ class URLRequestJobFactory;
 
 namespace brightray {
 
+class RequireCTDelegate;
 class DevToolsNetworkControllerHandle;
 class MediaDeviceIDSalt;
 class NetLog;
@@ -53,13 +54,10 @@ class URLRequestContextGetter : public net::URLRequestContextGetter {
     CreateURLRequestJobFactory(content::ProtocolHandlerMap* protocol_handlers);
     virtual net::HttpCache::BackendFactory* CreateHttpCacheBackendFactory(
         const base::FilePath& base_path);
-    virtual std::unique_ptr<net::CertVerifier> CreateCertVerifier();
+    virtual std::unique_ptr<net::CertVerifier> CreateCertVerifier(
+        RequireCTDelegate* ct_delegate);
     virtual net::SSLConfigService* CreateSSLConfigService();
     virtual std::vector<std::string> GetCookieableSchemes();
-    virtual net::TransportSecurityState::RequireCTDelegate*
-    GetRequireCTDelegate() {
-      return nullptr;
-    }
     virtual MediaDeviceIDSalt* GetMediaDeviceIDSalt() { return nullptr; }
   };
 
@@ -98,6 +96,7 @@ class URLRequestContextGetter : public net::URLRequestContextGetter {
 
   std::string user_agent_;
 
+  std::unique_ptr<RequireCTDelegate> ct_delegate_;
   std::unique_ptr<net::ProxyConfigService> proxy_config_service_;
   std::unique_ptr<net::NetworkDelegate> network_delegate_;
   std::unique_ptr<net::URLRequestContextStorage> storage_;

brightray/filenames.gypi

@@ -61,6 +61,8 @@
       'browser/net/devtools_network_transaction.h',
       'browser/net/devtools_network_upload_data_stream.cc',
       'browser/net/devtools_network_upload_data_stream.h',
+      'browser/net/require_ct_delegate.cc',
+      'browser/net/require_ct_delegate.h',
       'browser/net_log.cc',
       'browser/net_log.h',
       'browser/network_delegate.cc',

default_app/main.js

@@ -34,6 +34,9 @@ for (let i = 0; i < argv.length; i++) {
   } else if (argv[i] === '--require' || argv[i] === '-r') {
     option.modules.push(argv[++i])
     continue
+  } else if (argv[i] === '--abi' || argv[i] === '-a') {
+    option.abi = true
+    continue
   } else if (argv[i][0] === '-') {
     continue
   } else {
@@ -328,6 +331,9 @@ if (option.file && !option.webdriver) {
 } else if (option.version) {
   console.log('v' + process.versions.electron)
   process.exit(0)
+} else if (option.abi) {
+  console.log(process.versions.modules)
+  process.exit(0)
 } else if (option.default) {
   const indexPath = path.join(__dirname, '/index.html')
   loadApplicationByUrl(`file://${indexPath}`)
@@ -348,8 +354,9 @@ if (option.file && !option.webdriver) {
   Options:
     -d, --default         Run the default bundled Electron app.
     -i, --interactive     Open a REPL to the main process.
-    -r, --require         Module to preload (option can be repeated)
-    -v, --version         Print the version.`
+    -r, --require         Module to preload (option can be repeated).
+    -v, --version         Print the version.
+    -a, --abi             Print the Node ABI version.`
 
   console.log(welcomeMessage)
   const indexPath = path.join(__dirname, '/index.html')

docs-translations/README.md

@@ -0,0 +1,33 @@
+## Docs Translations
+
+This directory once contained unstructured translations of Electron's 
+documentation, but has been deprecated in favor of a new translation process 
+using [Crowdin], a GitHub-friendly platform for collaborative translation.
+
+For more details, visit the [electron/electron-i18n] repo.
+
+## Contributing
+
+If you're interested in helping translate Electron's docs, visit 
+[crowdin.com/projects/electron] and log in with your GitHub account. And thanks!
+
+## Offline Docs
+
+If you miss having access to Electron's raw markdown files in your preferred
+language, don't fret! You can still get raw docs, they're just in a 
+different place now. See [electron/electron-i18n/tree/master/content]
+
+To more easily view and browse offline docs in your language, clone the repo and use [vmd], 
+an Electron-based GitHub-styled markdown viewer:
+
+```sh
+npm i -g vmd
+git clone https://github.com/electron/electron-i18n
+vmd electron-i18n/content/zh-CN
+```
+
+[crowdin.com/project/electron]: https://crowdin.com/project/electron
+[Crowdin]: https://crowdin.com/project/electron
+[electron/electron-i18n]: https://github.com/electron/electron-i18n#readme
+[electron/electron-i18n/tree/master/content]: https://github.com/electron/electron-i18n/tree/master/content
+[vmd]: http://ghub.io/vmd

docs-translations/cz/README.md

@@ -1,99 +0,0 @@
-Ujistěte se, že budete používat dokumenty, které jsou určeny pro verzi Electronu, který používáte. 
-Číslo verze by měla být součástí adresy URL stránky. Pokud tomu tak není, pravděpodobně používáte 
-dokumentaci vývojové větve, která může obsahovat změny v API, a ty nejsou kompatibilní s vaší verzí Electronu. 
-Chcete-li zobrazit starší verze dokumentace, můžete je procházet podle tagů na GitHub, a to otevřením "přepínač větve / tagu", který odpovídá vaší verzi.
-
-## FAQ / Často kladené dotazy
-
-There are questions that are asked quite often. Check this out before creating
-an issue:
-
-* [Electron FAQ](faq.md)
-
-## Návody
-
-* [Supported Platforms](tutorial/supported-platforms.md)
-* [Security](tutorial/security.md)
-* [Electron Versioning](tutorial/electron-versioning.md)
-* [Application Distribution](tutorial/application-distribution.md)
-* [Mac App Store Submission Guide](tutorial/mac-app-store-submission-guide.md)
-* [Windows Store Guide](tutorial/windows-store-guide.md)
-* [Application Packaging](tutorial/application-packaging.md)
-* [Using Native Node Modules](tutorial/using-native-node-modules.md)
-* [Debugging Main Process](tutorial/debugging-main-process.md)
-* [Using Selenium and WebDriver](tutorial/using-selenium-and-webdriver.md)
-* [DevTools Extension](tutorial/devtools-extension.md)
-* [Using Pepper Flash Plugin](tutorial/using-pepper-flash-plugin.md)
-* [Using Widevine CDM Plugin](tutorial/using-widevine-cdm-plugin.md)
-* [Testing on Headless CI Systems (Travis, Jenkins)](tutorial/testing-on-headless-ci.md)
-* [Offscreen Rendering](tutorial/offscreen-rendering.md)
-
-## Tutoriály
-
-* [Quick Start](tutorial/quick-start.md)
-* [Desktop Environment Integration](tutorial/desktop-environment-integration.md)
-* [Online/Offline Event Detection](tutorial/online-offline-events.md)
-* [REPL](tutorial/repl.md)
-
-## API Reference
-
-* [Synopsis](api/synopsis.md)
-* [Process Object](api/process.md)
-* [Supported Chrome Command Line Switches](api/chrome-command-line-switches.md)
-* [Environment Variables](api/environment-variables.md)
-
-### Volitelné DOM Elementy:
-
-* [`File` Object](api/file-object.md)
-* [`<webview>` Tag](api/web-view-tag.md)
-* [`window.open` Function](api/window-open.md)
-
-### Moduly pro Main Process:
-
-* [app](api/app.md)
-* [autoUpdater](api/auto-updater.md)
-* [BrowserWindow](api/browser-window.md)
-* [contentTracing](api/content-tracing.md)
-* [dialog](api/dialog.md)
-* [globalShortcut](api/global-shortcut.md)
-* [ipcMain](api/ipc-main.md)
-* [Menu](api/menu.md)
-* [MenuItem](api/menu-item.md)
-* [net](api/net.md)
-* [powerMonitor](api/power-monitor.md)
-* [powerSaveBlocker](api/power-save-blocker.md)
-* [protocol](api/protocol.md)
-* [session](api/session.md)
-* [systemPreferences](api/system-preferences.md)
-* [Tray](api/tray.md)
-* [webContents](api/web-contents.md)
-
-### Moduly pro Renderer Process (Web Page):
-
-* [desktopCapturer](api/desktop-capturer.md)
-* [ipcRenderer](api/ipc-renderer.md)
-* [remote](api/remote.md)
-* [webFrame](api/web-frame.md)
-
-### Moduly pro Both Processes:
-
-* [clipboard](api/clipboard.md)
-* [crashReporter](api/crash-reporter.md)
-* [nativeImage](api/native-image.md)
-* [screen](api/screen.md)
-* [shell](api/shell.md)
-
-## Vývoj
-
-* [Coding Style](development/coding-style.md)
-* [Using clang-format on C++ Code](development/clang-format.md)
-* [Source Code Directory Structure](development/source-code-directory-structure.md)
-* [Technical Differences to NW.js (formerly node-webkit)](development/atom-shell-vs-node-webkit.md)
-* [Build System Overview](development/build-system-overview.md)
-* [Build Instructions (macOS)](development/build-instructions-osx.md)
-* [Build Instructions (Windows)](development/build-instructions-windows.md)
-* [Build Instructions (Linux)](development/build-instructions-linux.md)
-* [Debug Instructions (macOS)](development/debugging-instructions-macos.md)
-* [Debug Instructions (Windows)](development/debug-instructions-windows.md)
-* [Setting Up Symbol Server in debugger](development/setting-up-symbol-server.md)
-* [Documentation Styleguide](styleguide.md)

docs-translations/de-DE/project/CODE_OF_CONDUCT.md

@@ -1,43 +0,0 @@
-# Vereinbarung über Verhaltenskodex für Mitwirkende
-
-## Unsere Verpflichtung
-
-Im Interesse der Förderung eines offenen und einladenden Umfeldes wollen wir uns als Teilnehmer und Verantwortliche unseres Projektes verpflichten die Teilnahme an dem Projekt und unserer Gemeinschaft zu einer belästigungsfreien Erfahrung zu machen – unabhängig von Alter, Körpergröße, Behinderung, ethnischer Zuordnung, geschlechtlicher Identität und Ausdruck, Erfahrungsstufe, Nationalität, persönlicher Erscheinung, Rasse, Religion oder sexueller Identität oder Orientierung.
-
-## Unsere Standards
-
-Beispiele für Verhaltensweisen, welche dazu beitragen ein positives Umfeld zu erzeugen, beinhalten:
-
-* Die Verwendung von einladenden und einbindenden Formulierungen
-* Abweichenden Ansichten und Erfahrungen wird Respekt entgegengebracht
-* Konstruktive Kritik wird höflich entgegengenommen
-* Fokussierung auf das, was das Beste ist für die Gemeinschaft
-* Verständnis zeigen gegenüber anderen Mitgliedern der Gemeinschaft
-
-Beispiele für nicht akzeptables Verhalten beinhalten:
-
-* Die Verwendung sexualisierter Sprache, Bilder oder Symbolik sowie unerwünschte Versuche sexueller Anbahnung
-* Beleidigende / abwertende Kommentare, persönliche oder politische Angriffe, Nutzung des Internets für unbilliges Verhalten
-* Öffentliche oder private Belästigungen
-* Das Veröffentlichen von privaten Informationen Anderer, wie zum Beispiel physische oder elektronische Adressen, ohne deren ausdrückliche Erlaubnis
-* Anderes Verhalten, welches in einem professionellen Umfeld begründet als unangemessen betrachtet werden kann 
-
-## Unsere Verantwortlichkeiten
-
-Die Projektverantwortlichen sind verantwortlich dafür, die Standards für ein akzeptables Benehmen klarzustellen und es wird von ihnen erwartet, dass sie als Reaktion auf jegliches inakzeptables Verhalten passende und faire berichtigende Maßnahmen ergreifen.
-
-Die Projektverantwortlichen haben das Recht und die Verantwortung, Kommentare, Commits, Code, Wiki-Bearbeitungen, Support-Tickets und andere Beiträge, die nicht mit diesem Verhaltenskodex vereinbar sind, zu entfernen, zu bearbeiten oder abzulehnen, und jene Mitwirkende für Verhaltensweisen, die sie für unangemessen, bedrohend, beleidigend oder verletzend halten, zeitweilig oder dauerhaft zu sperren.
-
-## Geltungsbereich
-
-Dieser Verhaltenskodex gilt sowohl innerhalb des Projektbereichs als auch in öffentlichen Bereichen, wenn eine Person das Projekt oder seine Gemeinschaft repräsentiert. Beispiele für die Repräsentation eines Projektes oder der Gemeinschaft beinhalten die Verwendung einer offiziellen Projekt-E-Mail-Adresse, das Versenden von Nachrichten über einen öffentlichen Social-Media-Account oder das Handeln als Repräsentant während einer Online- oder Offline-Veranstaltung. Der Begriff "Repräsentation des Projektes" kann durch die Projektenverantwortlichen weiter ausformuliert und klargestellt werden.
-
-## Umsetzung
-
-Fälle von missbräuchlichem, belästigendem oder anderweitig nicht akzeptablem Verhalten können dem Projektteam unter [EMAIL ADRESSE EINFÜGEN] gemeldet werden. Alle Beschwerden werden geprüft und untersucht und werden zu einer Antwort führen, die angesichts der Umstände für notwendig und angemessen gehalten wird. Das Projektteam ist verpflichtet, über diejenigen, die Vorfälle gemeldet haben, Verschwiegenheit zu wahren. Weitere Einzelheiten zu speziellen Umsetzungsgrundsätzen können gesondert mitgeteilt werden.
-
-Projektverantwortliche, welche den Verhaltenskodex nicht befolgen, oder nicht nach bestem Wissen und Glauben für dessen Einhaltung sorgen, können sich vorübergehenden oder dauerhaften Auswirkungen gegenübersehen, die durch andere Mitglieder der Projektleitung bestimmt wurden.
-
-## Bezug
-
-Dieser Verhaltenskodex basiert auf dem Contributor Covenant, Version 1.4, verfügbar unter http://contributor-covenant.org/version/1/4/de/

docs-translations/de-DE/project/README.md

@@ -1,83 +0,0 @@
-[![Electron Logo](https://electron.atom.io/images/electron-logo.svg)](https://electron.atom.io/)
-
-[![Travis Build Status](https://travis-ci.org/electron/electron.svg?branch=master)](https://travis-ci.org/electron/electron)
-[![AppVeyor Build Status](https://ci.appveyor.com/api/projects/status/bc56v83355fi3369/branch/master?svg=true)](https://ci.appveyor.com/project/electron-bot/electron/branch/master)
-[![devDependency Status](https://david-dm.org/electron/electron/dev-status.svg)](https://david-dm.org/electron/electron?type=dev)
-[![Join the Electron Community on Slack](http://atom-slack.herokuapp.com/badge.svg)](http://atom-slack.herokuapp.com/)
-
-:memo: Verfügbare Sprachen: [Korean](https://github.com/electron/electron/tree/master/docs-translations/ko-KR/project/README.md) | [Simplified Chinese](https://github.com/electron/electron/tree/master/docs-translations/zh-CN/project/README.md) | [Brazilian Portuguese](https://github.com/electron/electron/tree/master/docs-translations/pt-BR/project/README.md) | [Traditional Chinese](https://github.com/electron/electron/tree/master/docs-translations/zh-TW/project/README.md) | [Spanish](https://github.com/electron/electron/tree/master/docs-translations/es/project/README.md) | [Turkish](https://github.com/electron/electron/tree/master/docs-translations/tr-TR/project/README.md) | [German](https://github.com/electron/electron/tree/master/docs-translations/de-DE/project/README.md)
-
-Electron ermöglicht die Entwicklung plattformunabhängiger Desktopanwendungen mit JavaScript, HTML und CSS. Electron basiert auf [Node.js](https://nodejs.org/) und 
-[Chromium](http://www.chromium.org) und wird vom [Editor Atom](https://github.com/atom/atom) und vielen anderen [Apps](https://electron.atom.io/apps) verwendet.
-
-Folge [@ElectronJS](https://twitter.com/electronjs) auf Twitter, um stets auf dem neuesten Stand zu sein und Informationen zu Electron sofort zu erhalten.
-
-Dieses Projekt hält sich an den *Contributor Covenant*, einem [Verhaltenskodex](https://github.com/electron/electron/tree/master/docs-translations/de-DE/project/CODE_OF_CONDUCT.md) für Open Source Projekte.
-Beim Mitwirken an Electron wird vorausgesetzt, dass sich an diesen Kodex gehalten wird. Unangebrachtes Verhalten kann bei electron@github.com gemeldet werden.
-
-## Downloads
-
-Binaries von Electron können mit
-[`npm`](https://docs.npmjs.com/)
-installiert werden:
-
-```sh
-# Als Dependency für die Entwicklung installieren
-npm install electron --save-dev
-
-# `electron` Befehl global im $PATH installieren
-npm install electron -g
-```
-
-Auf der [Release Page](https://github.com/electron/electron/releases) können Binaries, Debugging Symbole und mehr gefunden werden.
-
-### Mirrors
-
-- [China](https://npm.taobao.org/mirrors/electron)
-
-## Dokumentation
-
-Guides und API Dokumentation befinden sich in der [Docs](https://github.com/electron/electron/tree/master/docs) Directory. Sie enthält auch Dokumente, die beschreiben, wie Electron kompiliert wird und wie mitgearbeitet werden kann.
-
-## Übersetzungen der Dokumentation
-
-- [Brazilian Portuguese](https://github.com/electron/electron/tree/master/docs-translations/pt-BR)
-- [Korean](https://github.com/electron/electron/tree/master/docs-translations/ko-KR)
-- [Japanese](https://github.com/electron/electron/tree/master/docs-translations/jp)
-- [Spanish](https://github.com/electron/electron/tree/master/docs-translations/es)
-- [Simplified Chinese](https://github.com/electron/electron/tree/master/docs-translations/zh-CN)
-- [Traditional Chinese](https://github.com/electron/electron/tree/master/docs-translations/zh-TW)
-- [Turkish](https://github.com/electron/electron/tree/master/docs-translations/tr-TR)
-- [Thai](https://github.com/electron/electron/tree/master/docs-translations/th-TH)
-- [Ukrainian](https://github.com/electron/electron/tree/master/docs-translations/uk-UA)
-- [Russian](https://github.com/electron/electron/tree/master/docs-translations/ru-RU)
-- [French](https://github.com/electron/electron/tree/master/docs-translations/fr-FR)
-- [Indonesian](https://github.com/electron/electron/tree/master/docs-translations/id)
-
-## Quick Start
-
-Um eine minimale Version einer Electron App in Aktion zu sehen, kann 
-[`electron/electron-quick-start`](https://github.com/electron/electron-quick-start) geklont und ausgeführt werden.
-
-## Community
-
-Für Fragen und Interaktion mit der Community stehen folgende Optionen zur Verfügung:
-- [`electron`](http://discuss.atom.io/c/electron) Kategorie im Atom Forum
-- `#atom-shell` Channel auf Freenode
-- [`Atom`](http://atom-slack.herokuapp.com/) Channel bei Slack
-- [`electron-ru`](https://telegram.me/electron_ru) *(Russisch)*
-- [`electron-br`](https://electron-br.slack.com) *(Brasilianisch Portugiesisch)*
-- [`electron-kr`](http://www.meetup.com/electron-kr/) *(Koreanisch)*
-- [`electron-jp`](https://electron-jp.slack.com) *(Japanisch)*
-- [`electron-tr`](http://electron-tr.herokuapp.com) *(Türkisch)*
-- [`electron-id`](https://electron-id.slack.com) *(Indonesisch)*
-
-Auf [awesome-electron](https://github.com/sindresorhus/awesome-electron)
-findest du eine Sammlung an nützlichen Beispielanwendungen, Tools und Ressourcen.
-
-## Lizenz
-
-[MIT](https://github.com/electron/electron/blob/master/LICENSE)
-
-Bei der Benutzung von Electron oder anderen GitHub Logos ist sich an die [GitHub Logo Guidelines](https://github.com/logos) zu halten.
-

docs-translations/es/README.md

@@ -1,71 +0,0 @@
-## Guías
-
-* [Plataformas Soportadas](tutorial/supported-platforms.md)
-* [Distribución de la Aplicación](tutorial/application-distribution.md)
-* [Empaquetamiento de la Aplicación](tutorial/application-packaging.md)
-* [Utilizando Módulos Node Nativos](tutorial/using-native-node-modules.md)
-* [Depurando el Proceso Principal](tutorial/debugging-main-process.md)
-* [Utilizando Selenium y WebDriver](tutorial/using-selenium-and-webdriver.md)
-* [Extensión DevTools](tutorial/devtools-extension.md)
-* [Utilizando el plugin Pepper Flash](tutorial/using-pepper-flash-plugin.md)
-
-## Tutoriales
-
-* [Introducción](tutorial/quick-start.md)
-* [Integración con el entorno de escritorio](tutorial/desktop-environment-integration.md)
-* [Detección del evento en línea/fuera de línea](tutorial/online-offline-events.md)
-
-## Referencias a la API
-
-* [Sinopsis](api/synopsis.md)
-* [Proceso](api/process.md)
-* [Parámetros CLI soportados (Chrome)](api/chrome-command-line-switches.md)
-
-### Elementos DOM personalizados:
-
-* [Objeto `File`](../../docs/api/file-object.md)
-* [Etiqueta `<webview>`](../../docs/api/webview-tag.md)
-* [Función `window.open`](../../docs/api/window-open.md)
-
-### Módulos del Proceso Principal:
-
-* [app](../../docs/api/app.md)
-* [auto-updater](../../docs/api/auto-updater.md)
-* [browser-window](../../docs/api/browser-window.md)
-* [content-tracing](../../docs/api/content-tracing.md)
-* [dialog](../../docs/api/dialog.md)
-* [global-shortcut](../../docs/api/global-shortcut.md)
-* [ipc (proceso principal)](../../docs/api/ipc-main.md)
-* [menu](../../docs/api/menu.md)
-* [menu-item](../../docs/api/menu-item.md)
-* [power-monitor](../../docs/api/power-monitor.md)
-* [power-save-blocker](../../docs/api/power-save-blocker.md)
-* [protocol](../../docs/api/protocol.md)
-* [session](../../docs/api/session.md)
-* [web-contents](../../docs/api/web-contents.md)
-* [tray](../../docs/api/tray.md)
-
-### Módulos del proceso de renderizado (Página Web):
-
-* [ipc (renderizador)](../../docs/api/ipc-renderer.md)
-* [remote](../../docs/api/remote.md)
-* [web-frame](../../docs/api/web-frame.md)
-
-### Módulos de Ambos Procesos:
-
-* [clipboard](../../docs/api/clipboard.md)
-* [crash-reporter](../../docs/api/crash-reporter.md)
-* [native-image](../../docs/api/native-image.md)
-* [screen](../../docs/api/screen.md)
-* [shell](../../docs/api/shell.md)
-
-## Desarrollo
-
-* [Guía de Estilo](development/coding-style.md)
-* [Estructura de los directorios del Código Fuente](development/source-code-directory-structure.md)
-* [Diferencias Técnicas con NW.js (anteriormente conocido como node-webkit)](development/atom-shell-vs-node-webkit.md)
-* [Repaso del Sistema de Compilación](development/build-system-overview.md)
-* [Instrucciones de Compilación (macOS)](development/build-instructions-osx.md)
-* [Instrucciones de Compilación (Windows)](development/build-instructions-windows.md)
-* [Instrucciones de Compilación (Linux)](development/build-instructions-linux.md)
-* [Configurando un Servidor de Símbolos en el depurador](development/setting-up-symbol-server.md)

docs-translations/es/api/chrome-command-line-switches.md

@@ -1,114 +0,0 @@
-# Parámetros CLI soportados (Chrome)
-
-Esta página lista las líneas de comandos usadas por el navegador Chrome que también son
-soportadas por Electron. Puedes usar [app.commandLine.appendSwitch][append-switch] para
-anexarlas en el script principal de tu aplicación antes de que el evento [ready][ready] del
-módulo [app][app] sea emitido:
-
-```javascript
-var app = require('app')
-app.commandLine.appendSwitch('remote-debugging-port', '8315')
-app.commandLine.appendSwitch('host-rules', 'MAP * 127.0.0.1')
-
-app.on('ready', function () {
-  // Your code here
-})
-```
-
-## --client-certificate=`path`
-
-Establece el `path` del archivo de certificado del cliente.
-
-## --ignore-connections-limit=`domains`
-
-Ignora el límite de conexiones para la lista de `domains` separados por `,`.
-
-## --disable-http-cache
-
-Deshabilita la caché del disco para las peticiones HTTP.
-
-## --remote-debugging-port=`port`
-
-Habilita la depuración remota a través de HTTP en el puerto especificado.
-
-## --proxy-server=`address:port`
-
-Usa un servidor proxy especificado, que sobreescribe la configuración del sistema.
-Este cambio solo afecta peticiones HTTP y HTTPS.
-
-## --proxy-pac-url=`url`
-
-Utiliza el script PAC en la `url` especificada.
-
-## --no-proxy-server
-
-No usa un servidor proxy y siempre establece conexiones directas. Anula cualquier
-otra bandera de servidor proxy bandera que se pase.
-
-## --host-rules=`rules`
-
-Una lista separada por comas de `rules` (reglas) que controlan cómo se asignan los
-nombres de host.
-
-Por ejemplo:
-
-* `MAP * 127.0.0.1` Obliga a todos los nombres de host a ser asignados a 127.0.0.1
-* `MAP *.google.com proxy` Obliga todos los subdominios google.com a resolverse con
-  "proxy".
-* `MAP test.com [::1]:77` Obliga a  resolver "test.com" con un bucle invertido de IPv6.
-  También obligará a que el puerto de la dirección respuesta sea 77.
-* `MAP * baz, EXCLUDE www.google.com` Reasigna todo a "baz", excepto a "www.google.com".
-
-Estas asignaciones especifican el host final en una petición de red (Anfitrión de la conexión TCP
-y de resolución de conexión directa, y el `CONNECT` en una conexión proxy HTTP, y el host final de
-la conexión proxy `SOCKS`).
-
-## --host-resolver-rules=`rules`
-
-Como `--host-rules` pero estas `rules` solo se aplican al solucionador.
-
-[app]: app.md
-[append-switch]: app.md#appcommandlineappendswitchswitch-value
-[ready]: app.md#event-ready
-
-## --ignore-certificate-errors
-
-Ignora errores de certificado relacionados.
-
-## --ppapi-flash-path=`path`
-
-Asigna la ruta `path` del pepper flash plugin.
-
-## --ppapi-flash-version=`version`
-
-Asigna la versión `version` del pepper flash plugin.
-
-## --log-net-log=`path`
-
-Permite guardar y escribir eventos de registros de red en `path`.
-
-## --enable-logging
-
-Imprime el registro de Chromium en consola.
-
-Este cambio no puede ser usado en `app.commandLine.appendSwitch` ya que se analiza antes de que la
-aplicación del usuario esté cargada.
-
-## --v=`log_level`
-
-Da el máximo nivel activo de V-logging por defecto; 0 es el predeterminado. Valores positivos
-son normalmente usados para los niveles de V-logging.
-
-Este modificador sólo funciona cuando también se pasa `--enable-logging`.
-
-## --vmodule=`pattern`
-
-Da los niveles máximos de V-logging por módulo para sobreescribir el valor dado por
-`--v`. Ej. `my_module=2,foo*=3` cambiaría el nivel de registro para todo el código,
-los archivos de origen `my_module.*` y `foo*.*`.
-
-Cualquier patrón que contiene un slash o un slash invertido será probado contra toda la ruta
-y no sólo con el módulo. Ej. `*/foo/bar/*=2` cambiaría el nivel de registro para todo el código
-en los archivos origen bajo un directorio `foo/bar`.
-
-Este modificador sólo funciona cuando también se pasa `--enable-logging`.

docs-translations/es/api/process.md

@@ -1,47 +0,0 @@
-# process
-
-El objeto `process` en Electron tiene las siguientes diferencias con respecto
-al node convencional:
-
-* `process.type` String - El tipo del proceso puede ser `browser` (ej. proceso
-   principal) o `renderer`.
-* `process.versions.electron` String - Versión de Electron.
-* `process.versions.chrome` String - Versión de Chromium.
-* `process.resourcesPath` String - Ruta al código fuente JavaScript.
-
-## Events
-
-### Event: 'loaded'
-
-Se emite cuando Electron ha cargado su script de inicialización interna y
-está comenzando a cargar la página web o el script principal.
-
-Puede ser usado por el script precargado para añadir de nuevo los símbolos globales
-de Node eliminados, al alcance global cuando la integración de Node está apagada:
-
-```javascript
-// preload.js
-var _setImmediate = setImmediate
-var _clearImmediate = clearImmediate
-process.once('loaded', function () {
-  global.setImmediate = _setImmediate
-  global.clearImmediate = _clearImmediate
-})
-```
-
-## Methods
-
-El objeto `process` tiene los siguientes métodos:
-
-### `process.hang`
-
-Interrumpe el hilo principal del proceso actual.
-
-
-### process.setFdLimit(maxDescriptors) _macOS_ _Linux_
-
-* `maxDescriptors` Integer
-
-Establece el límite dinámico del descriptor del archivo en `maxDescriptors`
-o en el límite estricto del Sistema Operativo, el que sea menor para el
-proceso actual.

docs-translations/es/api/synopsis.md

@@ -1,47 +0,0 @@
-# Sinopsis
-
-Todos los [Módulos integrados de Node.js](http://nodejs.org/api/) se encuentran
-disponibles en Electron y módulos de terceros son támbien totalmente compatibles
-(incluyendo los [módulos nativos](../tutorial/using-native-node-modules.md)).
-
-Electron también provee algunos módulos integrados adicionales para desarrollar
-aplicaciones nativas de escritorio. Algunos módulos sólo se encuentran disponibles
-en el proceso principal, algunos sólo en el proceso renderer (página web), y
-algunos pueden ser usados en ambos procesos.
-
-La regla básica es: Si un módulo es
-[GUI](https://es.wikipedia.org/wiki/Interfaz_gráfica_de_usuario) o de bajo nivel,
-entonces solo estará disponible en el proceso principal. Necesitas familiarizarte
-con el concepto de [scripts para proceso principal vs scripts para proceso renderer]
-(../tutorial/quick-start.md#the-main-process) para ser capaz de usar esos módulos.
-
-El script del proceso principal es como un script normal de Node.js:
-
-```javascript
-var app = require('app')
-var BrowserWindow = require('browser-window')
-
-var window = null
-
-app.on('ready', function () {
-  window = new BrowserWindow({width: 800, height: 600})
-  window.loadURL('https://github.com')
-})
-```
-
-El proceso renderer no es diferente de una página web normal, excepto por la
-capacidad extra de utilizar módulos de node:
-
-```html
-<!DOCTYPE html>
-<html>
-  <body>
-    <script>
-      var remote = require('remote');
-      console.log(remote.require('app').getVersion());
-    </script>
-  </body>
-</html>
-```
-
-Para ejecutar tu aplicación, lee [Ejecutar la aplicación](../tutorial/quick-start.md#run-your-app).

docs-translations/es/development/atom-shell-vs-node-webkit.md

@@ -1,34 +0,0 @@
-#Diferencias Técnicas entre Electron y  NW.js (anteriormente conocido como node-webkit)
-
-**Nota:Electron se llamaba antes Atom Shell.**
-
-Como NW.js, Electron proporciona una plataforma para escribir aplicaciones de escritorio con JavaScript y HTML y tiene la integración de nodo para permitir el acceso al sistema de bajo nivel de las páginas web.
-
-Pero también hay diferencias fundamentales entre los dos proyectos que hacen a Electron un producto totalmente independiente de NW.js:
-
-**1. Ingreso a la aplicación**
-
-En NW.js el principal punto de ingreso de una aplicación es una página web. Usted especifica una página principal de URL en el `package.json` y se abre en una ventana del navegador como ventana principal de la aplicación.
-
-En Electron, el punto de ingreso es un script de JavaScript. En lugar de proporcionar una dirección URL directamente, usted crea manualmente una ventana del navegador y carga un archivo HTML utilizando la API. También es necesario escuchar a los eventos de la ventana para decidir cuándo salir de la aplicación.
-
-Electron funciona más como el tiempo de ejecución(Runtime) de Node.js. Las Api's de Electron son de bajo nivel asi que  puede usarlo para las pruebas del navegador en lugar de  usar [PhantomJS.](http://phantomjs.org/)
-
-**2.Construir un sistema**
-
-Con el fin de evitar la complejidad de la construcción de todo Chromium, Electron utiliza `libchromiumcontent` para acceder a al contenido  Chromium's API. `libchromiumcontent` es solo una liberia compartida que incluye el módulo de contenido de Chromium y todas sus dependencias. Los usuarios no necesitan una máquina potente para construir con Electron.
-
-**3.Integración de Node**
-
-In NW.js, the Node integration in web pages requires patching Chromium to work, while in Electron we chose a different way to integrate the libuv loop with each platform's message loop to avoid hacking Chromium. See the node_bindings code for how that was done.
-
-En NW.js, la integración de Node en las páginas web requiere parchear Chromium para que funcione, mientras que en Electron elegimos una manera diferente para integrar el cilco libuv con cada ciclo de mensaje de las plataformas para evitar el hacking en Chromium. Ver el código [`node_bindings`][node-bindings] de cómo se hizo.
-
-
-**4. Multi-contexto**
-
-Si usted es un usuario experimentado NW.js, usted debe estar familiarizado con el concepto de contexto Node y el contexto web. Estos conceptos fueron inventados debido a la forma cómo se implementó NW.js.
-
-Mediante el uso de la característica [multi-contexto](http://strongloop.com/strongblog/whats-new-node-js-v0-12-multiple-context-execution/) de Node, Electron no introduce un nuevo contexto JavaScript en páginas web.Resultados de búsqueda
-
-[node-bindings]: https://github.com/electron/electron/tree/master/atom/common

docs-translations/es/development/build-instructions-linux.md

@@ -1,104 +0,0 @@
-#Instrucciones de Compilación (Linux)
-
-Siga las siguientes pautas para la construcción de Electron en Linux.
-#Requisitos previos
-
-   *  Python 2.7.x. Algunas distribuciones como CentOS 6.x siguen utilizando Python 2.6.x por lo que puede que tenga que comprobar su versión de Python con  `Python -V`.
-   *  Node.js v0.12.x. Hay varias formas de instalar Node. Puede descargar el código fuente de Node.js y compilar desde las fuentes. Si lo hace, permite la instalación de Node en el directorio personal como usuario estándar. O intentar de  repositorios como NodeSource.
-   *  Clang 3.4 o mayor.
-   *  Cabeceras de desarrollo de GTK + y libnotify.
-
-En Ubuntu, instalar las siguientes bibliotecas:
-
-`$ sudo apt-get install build-essential clang libdbus-1-dev libgtk2.0-dev \
-                       libnotify-dev libgnome-keyring-dev libgconf2-dev \
-                       libasound2-dev libcap-dev libcups2-dev libxtst-dev \
-                       libxss1 libnss3-dev gcc-multilib g++-multilib`
-
-En RHEL / CentOS, instale las siguientes bibliotecas:
-
-`$ sudo yum install clang dbus-devel gtk2-devel libnotify-devel \
-                    libgnome-keyring-devel xorg-x11-server-utils libcap-devel \
-                    cups-devel libXtst-devel alsa-lib-devel libXrandr-devel \
-                    GConf2-devel nss-devel`
-
-En Fedora, instale las siguientes bibliotecas:
-
-`$ sudo dnf install clang dbus-devel gtk2-devel libnotify-devel \
-                    libgnome-keyring-devel xorg-x11-server-utils libcap-devel \
-                    cups-devel libXtst-devel alsa-lib-devel libXrandr-devel \
-                    GConf2-devel nss-devel`
-
-Otras distribuciones pueden ofrecer paquetes similares para la instalación, a través de gestores de paquetes como el pacman. O  puede compilarlo a partir del código fuente.
-
-#Si utiliza máquinas virtuales para la construcción
-
-Si usted planea construir Electron en una máquina virtual, necesitará un  dispositivo de al menos 25 gigabytes de tamaño.
-
-#Obteniendo el codigo
-
-`$ git clone https://github.com/electron/electron.git`
-
-#Bootstrapping (Arranque)
-
-The bootstrap script will download all necessary build dependencies and create the build project files. You must have Python 2.7.x for the script to succeed. Downloading certain files can take a long time. Notice that we are using ninja to build Electron so there is no Makefile generated.
-
-El script de bootstrap descargará todas las dependencias necesarias para construcción  y creara los archivos del proyecto de construcción. Debe tener Python 2.7.x para que la secuencia de comandos tenga éxito. La descarga de determinados archivos puede llevar mucho tiempo. Nótese que estamos usando`ninja` para construir Electron por lo que no hay `Makefile` generado.
-
-    $ cd electron
-    $ ./script/bootstrap.py -v
-
-#compilación cruzada
-
-Si usted quiere construir para un `arm` objetivo también debe instalar las siguientes dependencias:
-
-`$ sudo apt-get install libc6-dev-armhf-cross linux-libc-dev-armhf-cross \ g++-arm-linux-gnueabihf`
-
-And to cross compile for arm or ia32 targets, you should pass the --target_arch parameter to the bootstrap.py script:
-cruzar y  compilar para `arm` o `ia32` objetivos, debe pasar el parámetro `--target_arch` al script `bootstrap.py`:
-`$ ./script/bootstrap.py -v --target_arch=arm`
-
-#Construcción
-
-Si a usted le gustaría construir dos objetivos de `Release` y `Debug`:
-
-    `$ ./script/build.py`
-
-
-Este script causará que el ejecutable de Electron se muy grande para ser colocado en el directorio `out / R`. El tamaño del archivo es de más de 1,3 gigabytes. Esto sucede porque el binario de destino lanzamiento contiene los símbolos de depuración. Para reducir el tamaño de archivo, ejecute el script `create-dist.py`:
-
-`$ ./script/create-dist.py`
-
-This will put a working distribution with much smaller file sizes in the dist directory. After running the create-dist.py script, you may want to remove the 1.3+ gigabyte binary which is still in out/R.
-
-Esto pondrá una distribución a trabajar con tamaños de archivo mucho más pequeños en el directorio `dist`. Después de ejecutar el script create-dist.py, es posible que desee quitar el binario 1.3+ gigabyte que todavía está en  `out/R`.
-
-También se puede construir sólo el objetivo  `Debug`:
-`$ ./script/build.py -c D`
-
-Después de la construcción está hecho, usted puede encontrar el `Electron` de depuración binario bajo `out / D`.
-
-#Limpieza
-
-Para limpiar los archivos de creación:
-
-`$ ./script/clean.py`
-
-#Solución de problemas
-Asegúrese de que ha instalado todas las dependencias de construcción.
-
-#Error al cargar bibliotecas compartidas: libtinfo.so.5
-
-Prebulit clang will try to link to libtinfo.so.5. Depending on the host architecture, symlink to appropriate libncurses:
-preconstruir `clang`  intentará enlazar a `libtinfo.so.5`. Dependiendo de la arquitectura anfitrión, enlace simbólico apropiado a `libncurses` :
-
-`$ sudo ln -s /usr/lib/libncurses.so.5 /usr/lib/libtinfo.so.5`
-
-#Pruebas
-Pon a prueba tus cambios que ajustan al estilo de codificación proyecto mediante:
-
-`$ ./script/cpplint.py`
-
-prueba de funcionalidad utilizando:
-
-`$ ./script/test.py`

docs-translations/es/development/build-instructions-osx.md

@@ -1,48 +0,0 @@
-#Instrucciones de Compilación (Mac)
-Siga las siguientes pautas para la construcción de Electron en macOS.
-
-#Requisitos previos 
-
-      `macOS >= 10.8`
-      `Xcode >= 5.1`
-      `node.js (external)`
-
-
-Si está utilizando  Python descargado de Homebrew, también es necesario instalar los siguientes módulos de python:
-    `pyobjc`
-
-#Obtener el Código
-
-`$ git clone https://github.com/electron/electron.git`
-
-#Bootstrapping (arranque)
-
-The bootstrap script will download all necessary build dependencies and create the build project files. Notice that we're using ninja to build Electron so there is no Xcode project generated.
-
-El script de bootstrap  descargará todas las dependencias  de construcción necesarias y creara los archivos del proyecto de compilación. notemos que estamos usando `ninja` para construir Electron por lo que no hay un proyecto de Xcode generado.
-
-`$ cd electron`
-`$ ./script/bootstrap.py -v`
-
-#Construcción
-Construir ambos objetivos de `Release` y  `Debug`:
-
-`$ ./script/build.py`
-
-También sólo se puede construir el objetivo de `Debug`:
-`$ ./script/build.py -c D`
-
-Después de la construcción está hecho, usted puede encontrar `Electron.app` bajo `out / D.`
-
-#Soporte de 32bit
-
-Electron sólo puede construirse para un objetivo de 64 bits en macOS y no hay un plan para apoyar a 32 bit macOS en el futuro.
-
-#Pruebas
-
-Pon a prueba tus cambios ajustandose al estilo de codificación del proyecto mediante:
-`$ ./script/cpplint.py`
-
-Prueba la funcionalidad usando:
-
-`$ ./script/test.py`

docs-translations/es/development/build-system-overview.md

@@ -1,35 +0,0 @@
-#Repaso del Sistema de construcción
-Electron utiliza `gyp` para la generación de proyectos y` ninja` para la contrucción. Las Configuraciones del proyecto se pueden encontrar en los archivos `.gypi` y `.gyp `.
-
-#Archivos Gyp 
-los siguientes archivos `gyp` contienen las principales reglas para la contrucción en electron:
-
-  * `atom.gyp` define en si como se compila en Electron.
-  * `common.gypi` ajusta las configuraciones de generación de Node para  construir junto con Chromium.
-  * `brightray/brightray.gyp` define cómo se construye `brightray` e incluye las configuraciones predeterminadas para linkear con Chromium.
-  * `brightray/brightray.gypi` incluye configuraciones de generación generales sobre la construcción.
-
-#Construir un componente
-Desde Chromium es un proyecto bastante largo, la etapa de enlace final puede tomar pocos minutos, lo que hace que sea difícil para el desarrollo. Con el fin de resolver esto, Chromium introdujo el "componente de construcción", que se basa en construir cada componente como una libreria  compartida por separado, haciendo que se enlace muy rápido, pero sacrificando el tamaño del archivo y el rendimiento.
-
-En Electron tomamos un enfoque muy similar: para versiones de `Debug` (depuración), el binario será linkeado a una versión de la libreria compartida de los componentes de Chromium para lograr un tiempo de enlace rápido; para versiones de `Release` (lanzamiento), el binario será linkeado a las versiones de las librerias estáticas, por lo que puede tener es posible tener un mejor tamaño binario  y rendimiento.
-
-#Bootstrapping minimo (minimo arranque)
-Todos los binarios pre-compilados de Chromium (`libchromiumcontent`) son descargados al ejecutar el script de arranque. Por defecto ambas librerias estáticas y librerias compartidas se descargarán y el tamaño final debe estar entre 800 MB y 2 GB dependiendo de la plataforma.
-
-Por defecto, `libchromiumcontent` se descarga de Amazon Web Services. Si se establece la variable de entorno `LIBCHROMIUMCONTENT_MIRROR`, el bootstrap script se descargará de ella. `libchromiumcontent-qiniu-mirror` es un espejo para el` libchromiumcontent`. Si tiene problemas para acceder a AWS, puede cambiar la dirección de descarga a la misma a través de `exportación LIBCHROMIUMCONTENT_MIRROR = http: // 7xk3d2.dl1.z0.glb.clouddn.com /`
-
-Si sólo desea construir en Electron rápidamente para pruebas o desarrollo, puede descargar sólo las versiones de librerias compartidas pasando el parámetro `--dev`:
-
-`$ ./script/bootstrap.py --dev`
-`$ ./script/build.py -c D`
-
-#generación de proyecto de dos frases
-Los enlaces de Electron con diferentes conjuntos de librerias en versiones `Release` y `Debug`. `gyp`, sin embargo, no es compatible con la configuración de los diferentes ajustes de enlace para diferentes configuraciones.
-
-Para evitar que Electron utilice una variable de `gyp` `libchromiumcontent_component` para controlar qué configuraciones de enlace usar y sólo generar un objetivo cuando se ejecute `gyp`.
-
-#Nombres de destino
-A diferencia de la mayoría de los proyectos que utilizan `Release` y `Debug` como nombres de destino, Electron utiliza `R` y `D` en su lugar. Esto se debe a `gyp` bloquea aleatoriamente si sólo hay una configuración de `Release` o `Debug` definidas, y Electron sólo tiene  que  generar un objetivo a la vez como se ha indicado anteriormente.
-
-Esto sólo afecta a los desarrolladores, si usted está construyendo Electron para rebranding no se ven afectados.

docs-translations/es/development/coding-style.md

@@ -1,37 +0,0 @@
-# Guía de estilo de código
-
-Esta es la guía de estilo de código para Electron.
-
-## C++ y Python
-
-Para C++ y Python, nosotros seguimos la [guía de estilo](http://www.chromium.org/developers/coding-style) de Chromium.
-Además hay un script `script/cpplint.py` para verificar si todos los archivos
-siguen el estilo.
-
-La versión de Python que estamos usando ahora es Python 2.7.
-
-El código C++ usa muchas abstracciones y tipos de Chromium, por eso
-se recomienda familiarizarse con ellos. Un buen lugar para iniciar es
-el documento de Chromium sobre [Abstracciones importantes y estructras de datos](https://www.chromium.org/developers/coding-style/important-abstractions-and-data-structures). El documento menciona algunos tipos especiales, tipos por alcance (que
-automaticamente liberan su memoria cuando salen de su alcance), mecanismos de
-registro de eventos, etcétera.
-
-## CoffeeScript
-
-Para CoffeeScript, nosotros seguimos la [guía de estilo](https://github.com/styleguide/javascript) de Github y también las
-siguientes reglas:
-
-* Los archivos **NO** deberían terminar con una nueva línea, por que se busca
-  seguir los estilos que usa Google.
-* Los nombres de los archivos debén estar concatenados con `-` en vez de `_`,
-  por ejemplo `nombre-de-archivo.coffee` en vez de `nombre_de_archivo.coffee`,
-  esto es por que en [github/atom](https://github.com/github/atom)
-  los nombres de los módulos usualmente estan en la forma `nombre-de-modulo`.
-  Esta regla aplica únicamente a los archivos `.coffee`.
-
-## Nombres de las API
-
-Al crear una nueva API, nosotros deberíamos preferir usar metodos `get` y `set`
-en vez de usar el estilo de jQuery que utiliza una sola función. Por ejemplo,
-se prefiere `.getText()` y `.setText()` por sobre `.text([text])`. Hay una
-[discusión](https://github.com/electron/electron/issues/46) sobre esto.

docs-translations/es/development/source-code-directory-structure.md

@@ -1,62 +0,0 @@
-# Estructura de los directorios del código fuente
-
-El código fuente de electron es separado en pocas partes, en su mayoría
-siguiendo las especificaciones para separar archivos que usa Chromium.
-
-Quizá necesites familiarizarte con la [arquitectura multiprocesos](http://dev.chromium.org/developers/design-documents/multi-process-architecture) de Chromium para comprender mejor el código fuente.
-
-## Estructura del código fuente
-
-```
-Electron
-├──atom - Código fuente de Electron.
-|  ├── app - Código de arranque.
-|  ├── browser - La interfaz incluyendo la ventana principal, UI,
-|  |   y todas las cosas del proceso principal. Este le habla al renderizador
-|  |   para manejar las páginas web.
-|  |   ├── lib - Código Javascript para inicializar el proceso principal.
-|  |   ├── ui - Implementaciones de UI para distintas plataformas.
-|  |   |   ├── cocoa - Código fuente específico para Cocoa.
-|  |   |   ├── gtk - Código fuente específico para GTK+.
-|  |   |   └── win - Código fuente específico para Windows GUI.
-|  |   ├── default_app - La página por defecto para mostrar cuando Electron
-|  |   |   es iniciado sin proveer una app.
-|  |   ├── api - La implementación de las APIs para el proceso principal.
-|  |   |   └── lib - Código Javascript parte de la implementación de la API.
-|  |   ├── net - Código relacionado a la red.
-|  |   ├── mac - Código fuente de Objective-C específico para Mac.
-|  |   └── resources - Iconos, archivos específicos de plataforma, etc.
-|  ├── renderer - Código que se ejecuta en el proceso de renderizado.
-|  |   ├── lib - Código Javascript del proceso de inicio del renderizador.
-|  |   └── api - La implementación de las APIs para el proceso de renderizado.
-|  |       └── lib - Código Javascript parte de la implementación de la API.
-|  └── common - Código que se utiliza en ambos procesos, el principal y el de
-|      renderizado. Incluye algunas funciones de utilidad y código para integrar
-|      el ciclo de mensajes de Node en el ciclo de mensajes de Chromium.
-|      ├── lib - Código Javascript común para la inicialización.
-|      └── api - La implementación de APIs comunes, y los fundamentos de
-|          los módulos integrados de Electron.
-|          └── lib - Código Javascript parte de la implementación de la API.
-├── chromium_src - Código fuente copiado de Chromium.
-├── docs - Documentación.
-├── spec - Pruebas automaticas.
-├── atom.gyp - Reglas de compilado de Electron.
-└── common.gypi - Configuración específica para compilar y reglas
-    de empaquetado para otros componentes como `node` y `breakpad`.
-```
-
-## Estructura de otros directorios
-
-* **script** - Scripts usados para propositos de desarrollo
-  como compilar, empaquetar, realizar pruebas, etc.
-* **tools** - Scripts de ayuda usados por los archivos gyp, contrario a la
-  carpeta `scripts`, estos scripts nunca deberían ser llamados por los usuarios.
-* **vendor** - Código fuente de dependencias externas, no usamos `third_party`
-  como nombre por que se podría confundir con el mismo directorio
-  en las carpetas del código fuente de Chromium.
-* **node_modules** - Módulos de node usados para la compilación.
-* **out** - Directorio temporal de salida usado por `ninja`.
-* **dist** - Directorio temporal creado por `script/create-dist.py` cuando
-  se esta creando una distribución.
-* **external_binaries** - Binarios descargados de frameworks externos que no
-  soportan la compilación con `gyp`.

docs-translations/es/project/CODE_OF_CONDUCT.md

@@ -1,46 +0,0 @@
-# Código de Conducta convenido para Contribuyentes
-
-## Nuestro compromiso
-
-En el interés de fomentar una comunidad abierta y acogedora, nosotros como contribuyentes y administradores nos comprometemos a hacer de la participación en nuestro proyecto y nuestra comunidad una experiencia libre de acoso para todos, independientemente de la edad, dimensión corporal, discapacidad, etnia, identidad y expresión de género, nivel de experiencia, nacionalidad, apariencia física, raza, religión, identidad u orientación sexual. 
-
-## Nuestros estándares
-
-Ejemplos de comportamiento que contribuyen a crear un ambiente positivo:
-
-* Uso de lenguaje amable e inclusivo
-* Respeto a diferentes puntos de vista y experiencias
-* Aceptación de críticas constructivas
-* Enfocarse en lo que es mejor para la comunidad
-* Mostrar empatía a otros miembros de la comunidad
-
-Ejemplos de comportamiento inaceptable por participantes:
-
-* Uso de lenguaje o imágenes sexuales y atención sexual no deseada
-* Comentarios insultantes o despectivos (*trolling*) y ataques personales o políticos
-* Acoso público o privado
-* Publicación de información privada de terceros sin su consentimiento, como direcciones físicas o electrónicas
-* Otros tipos de conducta que pudieran considerarse inapropiadas en un entorno profesional.
-
-## Nuestras responsabilidades
-
-Los administradores del proyecto son responsables de clarificar los estándares de comportamiento aceptable y se espera que tomen medidas correctivas y apropiadas en respuesta a situaciones de conducta inaceptable. 
-
-Los administradores del proyecto tienen el derecho y la responsabilidad de eliminar, editar o rechazar comentarios, *commits*, código, ediciones de documentación, *issues*, y otras contribuciones que no estén alineadas con este Código de Conducta, o de prohibir temporal o permanentemente a cualquier colaborador cuyo comportamiento sea inapropiado, amenazante, ofensivo o perjudicial.
-
-## Alcance
-
-Este código de conducta aplica tanto a espacios del proyecto como a espacios públicos donde un individuo esté en representación del proyecto o comunidad. Ejemplos de esto incluye el uso de la cuenta oficial de correo electrónico, publicaciones a través de las redes sociales oficiales, o presentaciones con personas designadas en eventos *online* u *offline*. La representación del proyecto puede ser clarificada explicitamente por los administradores del proyecto.
- 
-## Aplicación
-
-Ejemplos de abuso, acoso u otro tipo de comportamiento inaceptable puede ser reportado al equipo del proyecto en [INSERTE CORREO AQUÍ]. Todas las quejas serán revisadas e investigadas, generando un resultado apropiado a las circunstancias. El equipo del proyecto está obligado a mantener confidencialidad de la persona que reportó el incidente. Detalles específicos acerca de las políticas de aplicación pueden ser publicadas por separado.
-
-Administradores que no sigan o que no hagan cumplir este Código de Conducta pueden ser eliminados de forma temporal o permanente del equipo administrador. 
-
-## Atribución
-
-Este Código de Conducta es una adaptación del [Contributor Covenant][homepage], versión 1.4, disponible en [http://contributor-covenant.org/version/1/4/es/][version]
-
-[homepage]: http://contributor-covenant.org
-[version]: http://contributor-covenant.org/version/1/4/es/

docs-translations/es/project/README.md

@@ -1,87 +0,0 @@
-[![Electron Logo](https://electron.atom.io/images/electron-logo.svg)](https://electron.atom.io/)
-
-[![Travis Build Status](https://travis-ci.org/electron/electron.svg?branch=master)](https://travis-ci.org/electron/electron)
-[![AppVeyor Build Status](https://ci.appveyor.com/api/projects/status/kvxe4byi7jcxbe26/branch/master?svg=true)](https://ci.appveyor.com/project/Atom/electron)
-[![devDependency Status](https://david-dm.org/electron/electron/dev-status.svg)](https://david-dm.org/electron/electron?type=dev)
-[![Join the Electron Community on Slack](http://atom-slack.herokuapp.com/badge.svg)](http://atom-slack.herokuapp.com/)
-
-:memo: Traducciones disponibles: [Koreano](https://github.com/electron/electron/tree/master/docs-translations/ko-KR/project/README.md) | [Chino Simplificado](https://github.com/electron/electron/tree/master/docs-translations/zh-CN/project/README.md) | [Portugués Brasileño](https://github.com/electron/electron/tree/master/docs-translations/pt-BR/project/README.md) | [Chino Tradicional](https://github.com/electron/electron/tree/master/docs-translations/zh-TW/project/README.md)
-
-Electron es un framework que permite escribir aplicaciones de escritorio multiplataforma
-usando JavaScript, HTML y CSS. Está basado en [Node.js](https://nodejs.org/) con
-[Chromium](http://www.chromium.org). Es usado por [Atom
-editor](https://github.com/atom/atom) y muchas otras [aplicaciones](https://electron.atom.io/apps).
-
-Sigue a [@ElectronJS](https://twitter.com/electronjs) en Twitter para estar informado de anuncios
-importantes.
-
-Este proyecto se adhiere al [Código de Conducta convenido para Colaboradores](CODE_OF_CONDUCT.md).
-Si desea participar, debes seguir este código de conducta. Por favor reporta un comportamiento
-no aceptado a electron@github.com.
-
-## Downloads
-
-Para instalar binarios precompilados, usa
-[`npm`](https://docs.npmjs.com/):
-
-```sh
-# Instalación de las dependencias de desarrollo
-npm install electron --save-dev
-
-# Instalación de `electron` de manera global a tu $PATH
-npm install electron -g
-```
-
-Mira la [página de lanzamientos](https://github.com/electron/electron/releases) para
-los prebuilt binaries, debug symbols, y más.
-
-### Mirrors
-
-- [China](https://npm.taobao.org/mirrors/electron)
-
-## Documentación
-
-Las guías y API de referencia están disponibles en el directorio
-[docs](https://github.com/electron/electron/tree/master/docs). Ahí también
-puedes encontrar documentos que describen cómo construir y contribuir en Electron.
-
-## Traducciones de la Documentación
-
-- [Portugués Brasileño](https://github.com/electron/electron/tree/master/docs-translations/pt-BR)
-- [Koreano](https://github.com/electron/electron/tree/master/docs-translations/ko-KR)
-- [Japonés](https://github.com/electron/electron/tree/master/docs-translations/jp)
-- [Español](https://github.com/electron/electron/tree/master/docs-translations/es)
-- [Chino Simplificado](https://github.com/electron/electron/tree/master/docs-translations/zh-CN)
-- [Chino Tradicional](https://github.com/electron/electron/tree/master/docs-translations/zh-TW)
-- [Turco](https://github.com/electron/electron/tree/master/docs-translations/tr-TR)
-- [Thai](https://github.com/electron/electron/tree/master/docs-Translations/th-TH)
-- [Ucraniano](https://github.com/electron/electron/tree/master/docs-translations/uk-UA)
-- [Ruso](https://github.com/electron/electron/tree/master/docs-translations/ru-RU)
-- [Francés](https://github.com/electron/electron/tree/master/docs-translations/fr-FR)
-
-## Inicio rápido
-
-Clona y ejecuta el repositorio [`electron/electron-quick-start`](https://github.com/electron/electron-quick-start)
-para ver una aplicación mínima en acción.
-
-## Comunidad
-
-Puedes preguntar y interactuar con la comunidad en los siguientes lugares:
-- [`electron`](http://discuss.atom.io/c/electron) Categoría en los Foros de
-Atom.
-- `#atom-shell` canal de IRC en Freenode
-- [`Atom`](http://atom-slack.herokuapp.com/) canales en Slack
-- [`electron-br`](https://electron-br.slack.com) *(Portugués Brasileño)*
-- [`electron-kr`](http://www.meetup.com/electron-kr/) *(Koreano)*
-- [`electron-jp`](https://electron-jp.slack.com) *(Japonés)*
-- [`electron-tr`](http://electron-tr.herokuapp.com) *(Turco)*
-- [`electron-id`](https://electron-id.slack.com) *(Indonés*
-
-Mira [awesome-electron](https://github.com/sindresorhus/awesome-electron)
-donde la comunidad mantiene una lista útil de ejemplos de aplicaciones, herramientas y recursos.
-
-## Licencia
-
-[MIT](https://github.com/electron/electron/blob/master/LICENSE)
-
-Si usas los logos de Electron ó GitHub, asegúrate de seguir las [GitHub logo guidelines](https://github.com/logos).

docs-translations/es/styleguide.md

@@ -1,100 +0,0 @@
-# Gúia de estilo de Electron
-
-Encuentra el apartado correcto para cada tarea: [leer la documentación de Electron](#reading-electron-documentation)
-o [escribir documentación para Electron](#writing-electron-documentation).
-
-## Escribir Documentación para Electron
-
-Estas son las maneras en las que construimos la documentación de Electron.
-
-- Máximo un título `h1` por página.
-- Utilizar `bash` en lugar de `cmd` en los bloques de código (por el resaltado
-  de sintaxis).
-- Los títulos `h1` en el documento deben corresponder al nombre del objeto
-  (ej. `browser-window` → `BrowserWindow`).
-  - Archivos separados por guiones, mas sin embargo, es correcto.
-- No subtítulos seguidos por otros subtítulos, añadir por lo menos un enunciado
-  de descripción.
-- Métodos de cabecera son delimitados con apóstrofes: `código`.
-- Cabeceras de Eventos son delimitados con 'comillas' simples.
-- No generar listas de mas de dos niveles (debido al renderizador de Markdown
-  desafortunadamente).
-- Agregar títulos de sección: Eventos, Métodos de Clases y Métodos de Instancia.
-- Utilizar 'deberá' en lugar de 'debería' al describir resultados.
-- Eventos y Métodos son cabeceras `h3`.
-- Argumentos opcionales escritos como `function (required[, optional])`.
-- Argumentos opcionales son denotados cuando se llaman en listas.
-- Delimitador de línea de 80-columnas.
-- Métodos específicos de Plataformas son denotados en itálicas seguidas por la cabecera del método.
-  - ```### `method(foo, bar)` _macOS_```
-- Preferir 'en el ___ proceso' en lugar de 'sobre el'
-
-### Traducciones de la Documentación
-
-Traducciones de documentos de Electron se encuentran dentro del folder
-`docs-translations`.
-
-Para agregar otro set (o un set parcial):
-
-- Crear un subdirectorio nombrado igual a la abreviación del lenguaje.
-- Dentro de ese subdirectorio, duplicar el directorio de `docs`, manteniendo los
-  mismos nombres de directorios y archivos.
-- Traducir los archivos.
-- Actualizar el `README.md` dentro del subdirectorio del lenguaje apuntando a
-  los archivos que has traducido.
-- Agregar un enlace al folder de tu traducción en la sección principal Electron
-[README](https://github.com/electron/electron#documentation-translations).
-
-## Leyendo la Documentación de Electron
-
-Estos son algunos consejos para entender la sintaxis de la documentación de
-Electron.
-
-### Métodos
-
-Un ejemplo de la documentación del [método](https://developer.mozilla.org/en-US/docs/Glossary/Method):
-
----
-
-`methodName(required[, optional]))`
-
-* `require` String, **required**
-* `optional` Integer
-
----
-
-El nombre del método es seguido por los argumentos que recibe. Argumentos
-opcionales son denotados por corchetes rodeados por el argumento opcional y la
-coma requerida si el argumento opcional fuera seguido por otro argumento.
-
-Debajo del método se encuentra más información detallada de cada uno de los
-argumentos. El tipo de argumento es denotado por los tipos comúnes:
-[`String`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String),
-[`Number`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number),
-[`Object`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object),
-[`Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)
-o un tipo personalizado como el [`webContent`](api/web-content.md) de Electron.
-
-### Eventos
-
-Un ejemplo de documentación del [evento](https://developer.mozilla.org/en-US/docs/Web/API/Event):
-
----
-
-Event: 'wake-up'
-
-Returns:
-
-* `time` String
-
----
-
-El evento es una cadena que es utilizada luego de un método observador `.on`. Si
-regresa un valor, él y su tipo son denotados abajo. Si se estaba a la escucha y
-respondió a este evento se debería ver así:
-
-```javascript
-Alarm.on('wake-up', function (time) {
-  console.log(time)
-})
-```

docs-translations/es/tutorial/application-distribution.md

@@ -1,120 +0,0 @@
-# Distribución de la Aplicación
-
-Para distribuir tu aplicación con Electron, el directorio que contiene la
-aplicación deberá llamarse `app`, y ser colocado debajo del directorio de
-recursos de Electron (en macOS es `Electron.app/Contents/Resources/`, en Linux y
-Windows es `resources/`), de esta forma:
-
-En macOS:
-
-```text
-electron/Electron.app/Contents/Resources/app/
-├── package.json
-├── main.js
-└── index.html
-```
-
-En Windows y Linux:
-
-```text
-electron/resources/app
-├── package.json
-├── main.js
-└── index.html
-```
-
-Luego ejecutar `Electron.app` (o `electron` en Linux, `electron.exe` en Windows),
-y Electron será iniciado como tu aplicación. El directorio `electron` será
-entonces tu distribución que recibirán los usuarios finales.
-
-## Empaquetando tu aplicación en un archivo
-
-Además de distribuir tu aplicación al copiar todos los archivos de código fuente,
-también puedes empaquetar tu aplicación como un archivo [asar](https://github.com/atom/asar)
-y de esta forma evitar exponer del código fuente de tu aplicación a los usuarios.
-
-Para utilizar un archivo `asar` en reemplazo del directorio `app`, debes de
-renombrar el archivo a `app.asar`, y colocarlo por debajo el directorio de recursos
-de Electron (ver en seguida), Electron intentará leer el archivo y arrancar desde el.
-
-En macOS:
-
-```text
-electron/Electron.app/Contents/Resources/
-└── app.asar
-```
-
-En Windows y Linux:
-
-```text
-electron/resources/
-└── app.asar
-```
-
-Más detalles en [Empaquetado de Aplicaciones](application-packaging.md).
-
-## Redefinición con Binarios Descargados
-
-Luego de empaquetar tu aplicación en Electron, querrás redefinir Electron antes
-de distribuirlo a los usuarios.
-
-### Windows
-
-Puedes renombrar `electron.exe` a cualquier nombre que desees, y editar su ícono
-y otra información con herramientas como [rcedit](https://github.com/atom/rcedit).
-
-### macOS
-
-Puedes renombrar `Electron.app` a cualquier nombre que desees, y tendrás que
-renombrar los campos `CFBundleDisplayName`, `CFBundleIdentifier` y `CFBundleName`
-en los siguientes archivos:
-
-* `Electron.app/Contents/Info.plist`
-* `Electron.app/Contents/Frameworks/Electron Helper.app/Contents/Info.plist`
-
-También puedes renombrar el helper de la aplicación para evitar que aparezca
-como `Electron Helper` en el Monitor de Actividades. Pero asegurate de renombrar
-el nombre de archivo del ejecutable.
-
-La estructura de una aplicación renombrada será:
-
-```
-MyApp.app/Contents
-├── Info.plist
-├── MacOS/
-│   └── MyApp
-└── Frameworks/
-    ├── MyApp Helper EH.app
-    |   ├── Info.plist
-    |   └── MacOS/
-    |       └── MyApp Helper EH
-    ├── MyApp Helper NP.app
-    |   ├── Info.plist
-    |   └── MacOS/
-    |       └── MyApp Helper NP
-    └── MyApp Helper.app
-        ├── Info.plist
-        └── MacOS/
-            └── MyApp Helper
-```
-
-### Linux
-
-Puedes renombrar el ejectuable `electron` a cualquier nombre que desees.
-
-## Redefinición mediante la recompilación de Electron desde el código fuente
-
-También es posible redefinir Electron cambiando el nombre del producto y
-compilandolo desde sus fuentes. Para realizar esto necesitas modificar el
-archivo `atom.gyp` y realizar una compilación desde cero.
-
-### grunt-build-atom-shell
-
-La modificación a mano del código de Electron y su compilación puede resultar
-complicada, por lo cual se ha generado una tarea Grunt para manejar esto de
-forma automaticamente:
-[grunt-build-atom-shell](https://github.com/paulcbetts/grunt-build-atom-shell).
-
-Esta tarea se encargará de modificar el archivo `.gyp`, compilar el código desde
-las fuentes, y luego reconstruir los módulos nativos de la aplicación para que
-coincidan con el nuevo nombre del ejecutable.

docs-translations/es/tutorial/application-packaging.md

@@ -1,157 +0,0 @@
-# Empaquetamiento de aplicaciones
-
-Para proteger los recursos y el código fuente de tu aplicación, puedes optar por empaquetar
-tu aplicación en un paquete [asar][asar].
-
-## Generando un archivo `asar`
-
-Un paquete [asar][asar] es un formato sencillo similar a tar, este formato concatena todos los archivos en uno,
-Electron puede leer el contenido sin desempaquetar todos los archivos.
-
-A continuación, los pasos para empaquetar tu aplicación con `asar`:
-
-### 1. Instalar asar
-
-```bash
-$ npm install -g asar
-```
-
-### 2. Empaquetar utilizando `asar pack`
-
-```bash
-$ asar pack your-app app.asar
-```
-
-## Utilizando los paquetes `asar`
-
-En Electron existen dos tipos de APIs: las APIs de Node, provistas por Node.js,
-y las APIs Web, provistas por Chromium. Ambas APIs soportan la lectura de paquetes `asar`.
-
-### API Node
-
-Con parches especiales en Electron, las APIs de Node como `fs.readFile` and `require`
-tratan los paquetes `asar` como directorios virtuales, y el contenido es accesible como si se tratara
-de archivos normales en el sistema de archivos.
-
-Por ejemplo, supongamos que tenemos un paquete `example.asar` bajo `/path/to`:
-
-```bash
-$ asar list /path/to/example.asar
-/app.js
-/file.txt
-/dir/module.js
-/static/index.html
-/static/main.css
-/static/jquery.min.js
-```
-
-Leer un archivo de nuestro paquete `asar`:
-
-```javascript
-var fs = require('fs')
-fs.readFileSync('/path/to/example.asar/file.txt')
-```
-
-Listar todos los archivos de la raíz:
-
-```javascript
-var fs = require('fs')
-fs.readdirSync('/path/to/example.asar')
-```
-
-Utilizar un módulo que se encuentra dentro del archivo:
-
-```javascript
-require('/path/to/example.asar/dir/module.js')
-```
-
-También puedes mostrar una página web contenida en un `asar` utilizando `BrowserWindow`.
-
-```javascript
-var BrowserWindow = require('browser-window')
-var win = new BrowserWindow({width: 800, height: 600})
-win.loadURL('file:///path/to/example.asar/static/index.html')
-```
-
-### API Web
-
-En una págin web, los archivos que se encuentran en el paquete son accesibles a través del protocolo `file:`.
-Al igual que la API Node, los paquetes `asar` son tratados como directorios.
-
-Por ejemplo, para obtener un archivo con `$.get`:
-
-```html
-<script>
-var $ = require('./jquery.min.js');
-$.get('file:///path/to/example.asar/file.txt', function(data) {
-  console.log(data);
-});
-</script>
-```
-
-### Utilizando un paquete `asar` como un archivo normal
-
-En algunas situaciones necesitaremos acceder al paquete `asar` como archivo, por ejemplo,
-si necesitáramos verificar la integridad del archivo con un checksum.
-Para casos así es posible utilizar el módulo  `original-fs`, que provee la API `fs` original:
-
-```javascript
-var originalFs = require('original-fs')
-originalFs.readFileSync('/path/to/example.asar')
-```
-
-## Limitaciones de la API Node:
-
-A pesar de que hemos intentado que los paquetes  `asar` funcionen como directorios de la mejor forma posible,
-aún existen limitaciones debido a la naturaleza de bajo nivel de la API Node.
-
-### Los paquetes son de sólo lectura
-
-Los paquetes `asar` no pueden ser modificados, por lo cual todas las funciones que modifiquen archivos
-no funcionarán.
-
-## Los directorios del paquete no pueden establecerse como working directories
-
-A pesar de que los paquetes `asar` son manejados virtualmente como directorios,
-estos directorios no existen en el sistema de archivos, por lo cual no es posible establecerlos
-como working directory, el uso de la opción `cwd` en algunas APIs podría causar errores.
-
-### Desempaquetamiento adicional en algunas APIs
-
-La mayoría de las APIs `fs` pueden leer u obtener información sobre un archivo en un paquete `asar` sin
-la necesidad de desempaquetarlo, pero algunas APIs requieren la ruta real. En estos casos Electron extraerá
-el archivo a una ruta temporal. Esto agrega un overhead a algunas APIs.
-
-Las APIs que requieren el desempaquetamiento adicional son:
-
-* `child_process.execFile`
-* `fs.open`
-* `fs.openSync`
-* `process.dlopen` - Utilizado por `require` en los módulos nativos
-
-### Información falsa en `fs.stat`
-
-El objeto `Stats` retornado por `fs.stat` y otras funciones relacionadas,
-no es preciso, ya que los archivos del paquete `asar` no existen en el sistema de archivos.
-La utilización del objeto `Stats` sólo es recomendable para obtener el tamaño del archivo y/o
-comprobar el tipo de archivo.
-
-
-## Agregando archivos al paquete `asar`
-
-Como se menciona arriba, algunas APIs de Node desempaquetarán archivos cuando exista una llamada
-que los referencie, además de los problemas de rendimiento que esto podría ocasionar, también
-podría accionar alertas falsas en software antivirus.
-
-Para lidiar con esto, puedes desempaquetar algunos archivos utilizando la opción `--unpack`.
-A continuación, un ejemplo que excluye las librerías compartidas de los módulos nativos:
-
-```bash
-$ asar pack app app.asar --unpack *.node
-```
-
-Después de ejecutar este comando, además del archivo `app.asar`, también se creará
-un directorio `app.asar.unpacked`, que contendrá los archivos desempaquetados.
-Este directorio deberá copiarse junto con el archivo `app.asar` a la hora de distribuir la aplicación.
-
-[asar]: https://github.com/atom/asar

docs-translations/es/tutorial/debugging-main-process.md

@@ -1,45 +0,0 @@
-# Depurando el proceso principal
-
-Los devtools sólo pueden depurar las páginas web (el código del proceso renderer).
-Para depurar el código del proceso principal, Electron provee dos opciones para la línea de comandos: `--debug` y `--debug-brk`.
-
-## Opciones para la línea de comandos
-
-### `--debug=[port]`
-
-Esta opción escuchará mensajes del protocolo de depuración V8 en `port`, por defecto `port` es `5858`.
-
-### `--debug-brk=[port]`
-
-Similar a `--debug` pero realiza una pausa en la primera línea del script.
-
-## Utilizando node-inspector para depuración
-
-__Nota:__ Electron utiliza node v0.11.13, esta versión aún no funciona bien con node-inspector,
-el proceso principal podría fallar al inspeccionar el objeto `process`.
-
-### 1. Iniciar [node-inspector][node-inspector]
-
-```bash
-$ node-inspector
-```
-
-### 2. Activar el modo de depuración en Electron
-
-Es posible iniciar Electron con la opción de depuración:
-
-```bash
-$ electron --debug=5858 your/app
-```
-
-o, pausar el script en la primera línea:
-
-```bash
-$ electron --debug-brk=5858 your/app
-```
-
-### 3. Cargar la interfaz del depurador
-
-Abre http://127.0.0.1:8080/debug?ws=127.0.0.1:8080&port=5858 en Chrome.
-
-[node-inspector]: https://github.com/node-inspector/node-inspector

docs-translations/es/tutorial/desktop-environment-integration.md

@@ -1,173 +0,0 @@
-# Integración con el entorno de escritorio
-
-Los sistemas operativos proveen diferentes características para integrar aplicaciones
-en sus entornos de escritorio. Por ejemplo, en Windows, las aplicaciones pueden agregar accesos directos
-en la JumpList de la barra de tareas, y en Mac, las aplicaciones pueden agregar un menú personalizado en el dock.
-
-Esta guía explica cómo integrar tu aplicación en esos entornos de escritorio a través de las APIs de Electron.
-
-## Documentos recientes (Windows y macOS)
-
-Windows y macOS proveen un acceso sencillo a la lista de documentos recientes.
-
-__JumpList:__
-
-![JumpList, Archivos recientes](http://i.msdn.microsoft.com/dynimg/IC420538.png)
-
-__Menú Dock:__
-
-<img src="https://cloud.githubusercontent.com/assets/639601/5069610/2aa80758-6e97-11e4-8cfb-c1a414a10774.png" height="353" width="428" >
-
-Para agregar un archivo a la lista de documentos recientes, puedes utilizar:
-[app.addRecentDocument][addrecentdocument] API:
-
-```javascript
-var app = require('app')
-app.addRecentDocument('/Users/USERNAME/Desktop/work.type')
-```
-
-También puedes utilizar [app.clearRecentDocuments](clearrecentdocuments) para vaciar la lista de documentos recientes:
-
-```javascript
-app.clearRecentDocuments()
-```
-
-### Notas sobre Windows
-
-Para activar esta característica en Windows, tu aplicación debe registrar un handler
-para el tipo de archivo que quieres utilizar, de lo contrario el archivo no aparecerá
-en la JumpList, aún después de agregarlo. Puedes encontrar más información sobre el proceso de
-registrar tu aplicación en [Application Registration][app-registration].
-
-Cuando un usuario haga click en un archivo de la JumpList, una nueva instancia de tu aplicación
-se iniciará, la ruta del archivo se agregará como un argumento de la línea de comandos.
-
-### Notas sobre macOS
-
-Cuando un archivo es solicitado desde el menú de documentos recientes, el evento `open-file`
-del módulo `app` será emitido.
-
-## Menú dock personalizado (macOS)
-
-macOS permite a los desarrolladores definir un menú personalizado para el dock,
-el cual usualmente contiene algunos accesos directos a las características más comunes
-de tu aplicación:
-
-__Menú dock de Terminal.app:__
-
-<img src="https://cloud.githubusercontent.com/assets/639601/5069962/6032658a-6e9c-11e4-9953-aa84006bdfff.png" height="354" width="341" >
-
-Para establecer tu menú dock, puedes utilizar la API `app.dock.setMenu`, la cual sólo está disponible para macOS:
-
-```javascript
-var app = require('app')
-var Menu = require('menu')
-var dockMenu = Menu.buildFromTemplate([
-  {label: 'New Window', click: function () { console.log('New Window') }},
-  {label: 'New Window with Settings',
-    submenu: [
-      {label: 'Basic'},
-      {label: 'Pro'}
-    ]
-  },
-  {label: 'New Command...'}
-])
-app.dock.setMenu(dockMenu)
-```
-
-## Tareas de usuario (Windows)
-
-En Windows puedes especificar acciones personalizadas en la categoría `Tasks` del JumpList,
-tal como menciona MSDN:
-
-
-> Las aplicaciones definen tareas basadas en las características del programa
-> y las acciones clave que se esperan de un usuario. Las tareas deben ser
-> libres de contexto, es decir, la aplicación no debe encontrarse en ejecución
-> para que estas acciones funcionen. También deberían ser las acciones estadísticamente
-> más comunes que un usuario normal realizaría en tu aplicación, como por ejemplo,
-> redactar un mensaje de correo electrónico, crear un documento en el procesador de textos,
-> ejecutar una aplicación en cierto modo, o ejecutar alguno de sus subcomandos. Una aplicación
-> no debería popular el menú con características avanzadas que el usuario estándar no necesita
-> ni con acciones que sólo se realizan una vez, como por ejemplo, el registro. No utilices
-> las tareas para mostrar elementos promocionales como actualizaciones u ofertas especiales.
->
-> Es recomendable que la lista de tareas sea estática. Debe mantenerse a pesar
-> de los cambios de estado de la aplicación. Aunque exista la posibilidad de variar
-> el contenido de la lista dinámicamente, debes considerar que podría ser confuso
-> para un usuario que no espera que el destino de la lista cambie.
-
-__Tareas de Internet Explorer:__
-
-![IE](http://i.msdn.microsoft.com/dynimg/IC420539.png)
-
-A diferencia del menú dock en macOS, el cual es un menú real, las tareas de usuario en Windows
-funcionan como accesos directos de aplicación, que al ser clickeados, lanzan el programa
-con argumentos específicos.
-
-Para establecer las tareas de usuario en tu aplicación, puedes utilizar:
-[app.setUserTasks][setusertaskstasks] API:
-
-```javascript
-var app = require('app')
-app.setUserTasks([
-  {
-    program: process.execPath,
-    arguments: '--new-window',
-    iconPath: process.execPath,
-    iconIndex: 0,
-    title: 'New Window',
-    description: 'Create a new window'
-  }
-])
-```
-
-Para purgar la lista de tareas, puedes llamar a `app.setUserTasks` con un array vacío:
-
-```javascript
-app.setUserTasks([])
-```
-
-Las tareas de usuario aún serán visibles después de cerrar tu aplicación, por lo cual
-el ícono y la ruta del programa deben existir hasta que la aplicación sea desinstalada.
-
-## Accesos directos en el lanzador Unity (Linux)
-
-En Unity, es posible agregar algunas entradas personalizadas, modificando el archivo `.desktop`,
-ver  [Adding shortcuts to a launcher][unity-launcher].
-
-__Accesos directos de Audacious:__
-
-![audacious](https://help.ubuntu.com/community/UnityLaunchersAndDesktopFiles?action=AttachFile&do=get&target=shortcuts.png)
-
-## Barra de progreso en la barra de tareas (Windows y Unity)
-
-En Windows, un botón en la barra de tareas puede utilizarse para mostrar una barra de progreso. Esto permite
-que una ventana muestre la información de progreso al usuario, sin que el usuario tenga la ventana de la aplicación activa.
-
-El entorno de escritorio Unity también posee una característica similar que permite mostrar una barra de progreso en el lanzador.
-
-__Barra de progreso en un botón de la barra de herramientas:__
-
-![Taskbar Progress Bar](https://cloud.githubusercontent.com/assets/639601/5081682/16691fda-6f0e-11e4-9676-49b6418f1264.png)
-
-__Barra de progreso en el lanzador Unity:__
-
-![Unity Launcher](https://cloud.githubusercontent.com/assets/639601/5081747/4a0a589e-6f0f-11e4-803f-91594716a546.png)
-
-Para establecer la barra de progreso de una ventana, puedes utilizar
-[BrowserWindow.setProgressBar][setprogressbar] API:
-
-```javascript
-var window = new BrowserWindow()
-window.setProgressBar(0.5)
-```
-
-[addrecentdocument]: ../api/app.md#appaddrecentdocumentpath
-[clearrecentdocuments]: ../api/app.md#appclearrecentdocuments
-[setusertaskstasks]: ../api/app.md#appsetusertaskstasks
-[setprogressbar]: ../api/browser-window.md#browserwindowsetprogressbarprogress
-[setrepresentedfilename]: ../api/browser-window.md#browserwindowsetrepresentedfilenamefilename
-[setdocumentedited]: ../api/browser-window.md#browserwindowsetdocumenteditededited
-[app-registration]: http://msdn.microsoft.com/en-us/library/windows/desktop/ee872121(v=vs.85).aspx
-[unity-launcher]: https://help.ubuntu.com/community/UnityLaunchersAndDesktopFiles#Adding_shortcuts_to_a_launcher

docs-translations/es/tutorial/devtools-extension.md

@@ -1,49 +0,0 @@
-# Extensión DevTools
-
-Para facilitar la depuración, Electron provee un soporte básico para la extensión
-[Chrome DevTools][devtools-extension].
-
-Para la mayoría de las extensiones devtools, simplemente puedes descargar el código fuente
-y utilizar `BrowserWindow.addDevToolsExtension` para cargarlas, las extensiones cargadas
-serán recordadas para que no sea necesario llamar a la función cada vez que creas una ventana.
-
-Por ejemplo, para usar la extensión [React DevTools](https://github.com/facebook/react-devtools), primero debes descargar el código fuente:
-
-```bash
-$ cd /some-directory
-$ git clone --recursive https://github.com/facebook/react-devtools.git
-```
-
-Luego cargas la aplicación en Electron, abriendo devtools en cualquier ventana,
-y ejecutando este código en la consola devtools:
-
-```javascript
-require('remote').require('browser-window').addDevToolsExtension('/some-directory/react-devtools')
-```
-
-Para remover una extensión, puedes utilizar `BrowserWindow.removeDevToolsExtension`
-especificando el nombre, y esta ya no se cargará la siguiente vez que abras devtools:
-
-```javascript
-require('remote').require('browser-window').removeDevToolsExtension('React Developer Tools')
-```
-
-## Formato de las extensiones devtools
-
-Idealmente todas las extensiones devtools escritas para Chrome pueden ser cargadas por Electron,
-pero para ello deben estar en un directorio plano, las extensiones empaquetadas como `crx`
-no pueden ser cargadas por Chrome a no ser que halles una forma de extraerlas a un directorio.
-
-## Páginas en segundo plano (background)
-
-Electron no soporta la característica de páginas en segundo plano de las extensiones de Chrome,
-las extensiones que utilizan esta característica podrían no funcionar.
-
-## APIs `chrome.*`
-
-Algunas extensiones utilizan las APIs `chrome.*`, hemos realizado un esfuerzo
-para implementar esas APIs en Electron, sin embargo no han sido implementadas en su totalidad.
-
-Dado que no todas las funciones `chrome.*` han sido implementadas, si la extensión devtools está utilizando otras APIs más allá de `chrome.devtools.*`, es muy probable que no funcione. Puedes reportar fallos en el issue tracker para que podamos agregar soporte a esas APIs.
-
-[devtools-extension]: https://developer.chrome.com/extensions/devtools

docs-translations/es/tutorial/online-offline-events.md

@@ -1,80 +0,0 @@
-# Detección del evento en línea/fuera de línea
-
-La detección de estos eventos puede ser implementada en el proceso renderer utilizando las APIs HTML5 estándar,
-como en este ejemplo:
-
-_main.js_
-
-```javascript
-var app = require('app')
-var BrowserWindow = require('browser-window')
-var onlineStatusWindow
-
-app.on('ready', function () {
-  onlineStatusWindow = new BrowserWindow({ width: 0, height: 0, show: false })
-  onlineStatusWindow.loadURL(`file://${__dirname}/online-status.html`)
-})
-```
-
-_online-status.html_
-
-```html
-<!DOCTYPE html>
-<html>
-  <body>
-    <script>
-      var alertOnlineStatus = function() {
-        window.alert(navigator.onLine ? 'online' : 'offline');
-      };
-
-      window.addEventListener('online',  alertOnlineStatus);
-      window.addEventListener('offline',  alertOnlineStatus);
-
-      alertOnlineStatus();
-    </script>
-  </body>
-</html>
-```
-
-Existen casos en donde necesitas responder a estos eventos desde el proceso principal.
-El proceso principal no posee un objeto `navigator`, por lo tanto no puede detectar estos eventos directamente.
-Es posible reenviar el evento al proceso principal mediante la utilidad de intercomunicación entre procesos (ipc):
-
-_main.js_
-
-```javascript
-var app = require('app')
-var ipc = require('ipc')
-var BrowserWindow = require('browser-window')
-var onlineStatusWindow
-
-app.on('ready', function () {
-  onlineStatusWindow = new BrowserWindow({ width: 0, height: 0, show: false })
-  onlineStatusWindow.loadURL(`file://${__dirname}/online-status.html`)
-})
-
-ipc.on('online-status-changed', function (event, status) {
-  console.log(status)
-})
-```
-
-_online-status.html_
-
-```html
-<!DOCTYPE html>
-<html>
-  <body>
-    <script>
-      var ipc = require('ipc');
-      var updateOnlineStatus = function() {
-        ipc.send('online-status-changed', navigator.onLine ? 'online' : 'offline');
-      };
-
-      window.addEventListener('online',  updateOnlineStatus);
-      window.addEventListener('offline',  updateOnlineStatus);
-
-      updateOnlineStatus();
-    </script>
-  </body>
-</html>
-```

docs-translations/es/tutorial/quick-start.md

@@ -1,148 +0,0 @@
-## Introducción
-
-Electron permite la creación de aplicaciones de escritorio utilizando JavaScript puro, a través de un runtime con APIs nativas. Puedes verlo como una variante de io.js, enfocado a aplicaciones de escritorio, en vez de servidores web.
-
-Esto no significa que Electron sea un binding de librerías GUI para JavaScript.
-Electron utiliza páginas web como su GUI, por lo cual puedes verlo como un navegador Chromium mínimo,
-controlado por JavaScript.
-
-### El proceso principal (main process)
-
-En Electron, el proceso que ejecuta el script `main` del `package.json` se llama __el proceso principal__.
-El script que corre en el proceso principal puede crear páginas para mostrar la GUI.
-
-### El proceso renderer (renderer process)
-
-Dado que Electron utiliza Chromium para mostrar las páginas web,
-también es utilizada la arquitectura multiproceso de Chromium.
-Cada página web en Electron se ejecuta en su propio proceso,
-el cual es llamado __el proceso renderer__.
-
-En los navegadores normales, las páginas web usualmente se ejecutan en un entorno
-sandbox y no tienen acceso a los recursos nativos. Los usuarios de Electron tienen el poder
-de utilizar las APIs de io.js en las páginas web, permitiendo interacciones de bajo nivel con el sistema operativo.
-
-### Diferencias entre el proceso principal y el proceso renderer
-
-El proceso principal crea páginas web mediante instancias de `BrowserWindow`. Cada instancia de `BrowserWindow`  ejecuta su propia página web y su propio proceso renderer.
-Cuando una instancia de `BrowserWindow` es destruida, también su proceso renderer correspondiente acaba.
-
-El proceso principal gestiona las páginas web y sus correspondientes procesos renderer.
-Cada proceso renderer es aislado y sólo considera relevante la página web que corre en él.
-
-En las páginas web, no está permitido llamar a APIs relacionadas a la GUI nativa
-porque la gestión de los recursos GUI nativos es peligrosa, y tiende a que ocurran leaks de memoria.
-Si deseas realizar operaciones GUI en una página web, el proceso renderer de la página web debe comunicarse
-con el proceso principal, y solicitar a este que realice esas operaciones.
-
-En Electron, hemos proveído el módulo [ipc](../../../docs/api/ipc-renderer.md) para la comunicación
-entre el proceso principal y el proceso renderer. Y también hay un módulo [remote](../../../docs/api/remote.md)
-para comunicación al estilo RPC.
-
-## Escribe tu primera aplicación Electron
-
-Generalmente, una aplicación Electron tendrá la siguiente estructura:
-
-```text
-your-app/
-├── package.json
-├── main.js
-└── index.html
-```
-
-El formato de `package.json` es exactamente el mismo que cualquier módulo Node,
-y el script especificado en el campo `main` será el script de arranque de tu aplicación,
-a ser ejecutado por el proceso principal. Un ejemplo de `package.json` podría verse así:
-
-```javascripton
-{
-  "name"    : "your-app",
-  "version" : "0.1.0",
-  "main"    : "main.js"
-}
-```
-
-El `main.js` debería crear las ventanas y gestionar los eventos del sistema, un ejemplo típico sería:
-
-```javascript
-var app = require('app')  // Módulo para controlar el ciclo de vida de la aplicación.
-var BrowserWindow = require('browser-window')  // Módulo para crear uan ventana de navegador.
-
-// Mantener una referencia global al objeto window, si no lo haces, esta ventana
-// se cerrará automáticamente cuando el objeto JavaScript sea recolectado (garbage collected):
-var mainWindow = null
-
-// Salir de todas las ventanas cuando se cierren.
-app.on('window-all-closed', function () {
-  // En macOS es común que las aplicaciones y su barra de menú
-  // se mantengan activas hasta que el usuario cierre la aplicación
-  // explícitamente utilizando Cmd + Q
-  if (process.platform !== 'darwin') {
-    app.quit()
-  }
-})
-
-// Este método será llamado cuando Electron haya finalizado la inicialización
-// y esté listo para crear ventanas de navegador.
-app.on('ready', function () {
-  // Crear la ventana.
-  mainWindow = new BrowserWindow({width: 800, height: 600})
-
-  // cargar el index.html de nuestra aplicación.
-  mainWindow.loadURL(`file://${__dirname}/index.html`)
-
-  // Desplegar devtools.
-  mainWindow.openDevTools()
-
-  // Evento emitido cuando se cierra la ventana.
-  mainWindow.on('closed', function () {
-    // Eliminar la referencia del objeto window.
-    // En el caso de soportar multiples ventanas, es usual almacenar
-    // los objetos window en un array, este es el momento en el que debes eliminar el elemento correspondiente.
-    mainWindow = null
-  })
-})
-```
-
-Finalmente el `index.html` es la página web que mostraremos:
-
-```html
-<!DOCTYPE html>
-<html>
-  <head>
-    <title>Hello World!</title>
-  </head>
-  <body>
-    <h1>Hello World!</h1>
-    We are using io.js <script>document.write(process.version)</script>
-    and Electron <script>document.write(process.versions.electron)</script>.
-  </body>
-</html>
-```
-
-## Ejecutar la aplicación
-
-Cuando termines de escribir tu aplicación, puedes distribuirla
-siguiendo la [guía de distribución](./application-distribution-es.md)
-y luego ejecutar la aplicación empaquetada. También puedes utilizar el binario de Electron
-para ejecutar tu aplicación de forma directa.
-
-En Windows:
-
-```bash
-$ .\electron\electron.exe your-app\
-```
-
-En Linux:
-
-```bash
-$ ./electron/electron your-app/
-```
-
-En macOS:
-
-```bash
-$ ./Electron.app/Contents/MacOS/Electron your-app/
-```
-
-`Electron.app` es parte del paquete de release de Electron, puedes descargarlo [aquí](https://github.com/electron/electron/releases).

docs-translations/es/tutorial/supported-platforms.md

@@ -1,30 +0,0 @@
-# Plataformas soportadas
-
-Las siguientes plataformas son soportadas por Electron:
-
-### macOS
-
-Sólo se proveen binarios de 64 bit para macOS.
-La versión mínima soportada es macOS 10.8.
-
-### Windows
-
-Windows 7 y posteriores son soportados, las versiones antiguas no son soportadas (y no funcionan).
-
-Se proveen binarios para las arquitecturas `x86` y `amd64` (x64).
-Nota: La versión para `ARM` de Windows no está soportada aún.
-
-### Linux
-
-Los binarios preconstruidos para `ia32`(`i686`) y `x64`(`amd64`) son construidos sobre
-Ubuntu 12.04, el binario para `arm` es construido sobre ARM v7 con la ABI hard-float
-y NEON para Debian Wheezy.
-
-La posibilidad de que un binario preconstruido se ejecute en una distribución determinada
-depende de las librerías contra las que fue enlazado Electron.
-Por ahora sólo se garantiza la ejecución en Ubuntu 12.04, aunque también se ha verificado
-el funcionamiento de los binarios preconstruidos en las siguientes plataformas:
-
-* Ubuntu 12.04 and later
-* Fedora 21
-* Debian 8

docs-translations/es/tutorial/using-native-node-modules.md

@@ -1,57 +0,0 @@
-# Utilizando módulos Node nativos
-
-Los módulos Node nativos son soportados por Electron, pero dado que Electron
-está utilizando una versión distinta de V8, debes especificar manualmente la
-ubicación de las cabeceras de Electron a la hora de compilar módulos nativos.
-
-## Compatibilidad de módulos nativos
-
-A partir de Node v0.11.x han habido cambios vitales en la API de V8.
-Es de esperar que los módulos escritos para Node v0.10.x no funcionen con Node v0.11.x.
-Electron utiliza Node v.0.11.13 internamente, y por este motivo tiene el mismo problema.
-
-Para resolver esto, debes usar módulos que soporten Node v0.11.x,
-[muchos módulos](https://www.npmjs.org/browse/depended/nan) soportan ambas versiones.
-En el caso de los módulos antiguos que sólo soportan Node v0.10.x, debes usar el módulo
-[nan](https://github.com/rvagg/nan) para portarlos a v0.11.x.
-
-## ¿Cómo instalar módulos nativos?
-
-### La forma fácil
-
-La forma más sencilla de recompilar módulos nativos es a través del paquete
-[`electron-rebuild`](https://github.com/paulcbetts/electron-rebuild),
-el cual abstrae y maneja los pasos de descargar las cabeceras y compilar los módulos nativos:
-
-```sh
-npm install --save-dev electron-rebuild
-
-# Ejecuta esto cada vez que ejecutes npm install
-./node_modules/.bin/electron-rebuild
-```
-
-### La forma node-gyp
-
-Para compilar módulos Node con las cabeceras de Electron, debes indicar a `node-gyp`
-desde dónde descargar las cabeceras y cuál versión usar:
-
-```bash
-$ cd /path-to-module/
-$ HOME=~/.electron-gyp node-gyp rebuild --target=0.29.1 --arch=x64 --dist-url=https://atom.io/download/electron
-```
-
-Los cambios en `HOME=~/.electron-gyp` fueron para especificar la ruta de las cabeceras.
-La opción `--target=0.29.1` es la versión de Electron. La opción `--dist-url=...` especifica
-dónde descargar las cabeceras. `--arch=x64` indica que el módulo será compilado para un sistema de 64bit.
-
-### La forma npm
-
-También puedes usar `npm` para instalar módulos, los pasos son exactamente igual a otros módulos Node,
-con la excepción de que necesitas establecer algunas variables de entorno primero:
-
-```bash
-export npm_config_disturl=https://atom.io/download/electron
-export npm_config_target=0.29.1
-export npm_config_arch=x64
-HOME=~/.electron-gyp npm install module-name
-```

docs-translations/es/tutorial/using-pepper-flash-plugin.md

@@ -1,55 +0,0 @@
-# Utilizando el plugin Pepper Flash
-
-El plugin Pepper Flash es soportado ahora. Para utilizar pepper flash en Electron, debes especificar la ubicación del plugin manualmente y activarlo en tu aplicación.
-
-## Preparar una copia del plugin Flash
-
-En macOS y Linux, el detalle del plugin puede encontrarse accediendo a `chrome://plugins` en el navegador. Su ubicación y versión son útiles para el soporte. También puedes copiarlo a otro lugar.
-
-## Agrega la opción a Electron
-
-Puedes agregar la opción `--ppapi-flash-path` y `ppapi-flash-version`  o utilizar el método `app.commandLine.appendSwitch` antes del evento ready de la aplicación.
-También puedes agregar la opción `plugins` de `browser-window`. Por ejemplo,
-
-```javascript
-var app = require('app')
-var BrowserWindow = require('browser-window')
-
-// Keep a global reference of the window object, if you don't, the window will
-// be closed automatically when the javascript object is GCed.
-var mainWindow = null
-
-// Quit when all windows are closed.
-app.on('window-all-closed', function () {
-  if (process.platform !== 'darwin') {
-    app.quit()
-  }
-})
-
-// Specify flash path.
-// On Windows, it might be /path/to/pepflashplayer.dll
-// On macOS, /path/to/PepperFlashPlayer.plugin
-// On Linux, /path/to/libpepflashplayer.so
-app.commandLine.appendSwitch('ppapi-flash-path', '/path/to/libpepflashplayer.so')
-
-// Specify flash version, for example, v17.0.0.169
-app.commandLine.appendSwitch('ppapi-flash-version', '17.0.0.169')
-
-app.on('ready', function () {
-  mainWindow = new BrowserWindow({
-    'width': 800,
-    'height': 600,
-    'web-preferences': {
-      'plugins': true
-    }
-  })
-  mainWindow.loadURL(`file://${__dirname}/index.html`)
-  // Something else
-})
-```
-
-## Activar el plugin flash en una etiqueta `<webview>`
-Agrega el atributo `plugins`.
-```html
-<webview src="http://www.adobe.com/software/flash/about/" plugins></webview>
-```

docs-translations/es/tutorial/using-selenium-and-webdriver.md

@@ -1,72 +0,0 @@
-# Utilizando Selenium y WebDriver
-
-De [ChromeDriver - WebDriver for Chrome][chrome-driver]:
-
-> WebDriver es una herramienta de código abierto para automatizar el testing de aplicaciones web
-> en varios navegadores. WebDriver provee funciones de navegación, entrada de usuario,
-> ejecución de JavaScript, y más. ChromeDriver es un servidor standalone que implementa
-> el protocolo de WebDriver para Chromium. Se encuentra en desarrollo por los miembros de 
-> Chromium y WebDriver.
-
-En la página de [lanzamientos](https://github.com/electron/electron/releases) de Electron encontrarás paquetes de `chromedriver`.
-
-## Ajustando parámetros con WebDriverJs
-
-[WebDriverJs](https://code.google.com/p/selenium/wiki/WebDriverJs) provee
-un paquete Node para realizar testing con web driver, lo usaremos como ejemplo.
-
-### 1. Inicia chrome driver
-
-Primero necesitas descargar el binario `chromedriver` y ejecutarlo:
-
-```bash
-$ ./chromedriver
-Starting ChromeDriver (v2.10.291558) on port 9515
-Only local connections are allowed.
-```
-
-Recuerda el puerto `9515`, lo utilizaremos después.
-
-### 2. Instala WebDriverJS
-
-```bash
-$ npm install selenium-webdriver
-```
-
-### 3. Conecta chrome driver
-
-El uso de `selenium-webdriver` junto con Electron es básicamente el mismo que el original,
-excepto que necesitas especificar manualmente cómo se conectará el chrome driver
-y dónde encontrará el binario de Electron:
-
-```javascript
-var webdriver = require('selenium-webdriver')
-
-var driver = new webdriver.Builder()
-  // El puerto "9515" es que abre chrome driver.
-  .usingServer('http://localhost:9515')
-  .withCapabilities({chromeOptions: {
-    // Aquí especificamos la ruta a Electron
-    binary: '/Path-to-Your-App.app/Contents/MacOS/Atom'}})
-  .forBrowser('electron')
-  .build()
-
-driver.get('http://www.google.com')
-driver.findElement(webdriver.By.name('q')).sendKeys('webdriver')
-driver.findElement(webdriver.By.name('btnG')).click()
-driver.wait(function () {
-  return driver.getTitle().then(function (title) {
-    return title === 'webdriver - Google Search'
-  })
-}, 1000)
-
-driver.quit()
-```
-
-## Workflow
-
-Para probar tu aplicación sin recompilar Electron, simplemente [copia](https://github.com/electron/electron/blob/master/docs/tutorial/application-distribution.md) las fuentes de tu aplicación en el directorio de recursos de Electron.
-
-[chrome-driver]: https://sites.google.com/a/chromium.org/chromedriver/
-
-

docs-translations/fr-FR/README.md

@@ -1,91 +0,0 @@
-Vérifiez que vous utilisez la bonne version de la documentation.
-Le numéro de version devrait faire partie de l'URL de la page.
-Si ce n'est pas le cas, vous utilisez probablement la documentation d'une
-branche de développement qui peut contenir des changements API qui ne sont pas
-compatibles avec votre version d'Electron. Si c'est le cas, vous pouvez changer
-de version sur la liste [versions disponibles](https://electron.atom.io/docs/),
-ou, si vous utilisez l'interface de GitHub, ouvrez la liste déroulante "Switch
-branches/tags" afin de sélectionner le tag de votre version.
-
-## FAQ
-
-Avant de créer un ticket, vérifiez que votre problème n'a pas déjà sa réponse
-dans la FAQ :
-
-* [Electron FAQ](faq/electron-faq.md)
-
-## Guides
-
-* [Plateformes supportées](tutorial/supported-platforms.md)
-* [Distribution de l'Application](tutorial/application-distribution.md)
-* [Guide de Soumission Mac App Store](tutorial/mac-app-store-submission-guide.md)
-* [Créer une archive](tutorial/application-packaging.md)
-* [Utiliser Modules Natifs de Node](tutorial/using-native-node-modules.md)
-* [Debugger Processus Principal](tutorial/debugging-main-process.md)
-* [Utiliser Selenium et WebDriver](tutorial/using-selenium-and-webdriver.md)
-* [Extension DevTools](tutorial/devtools-extension.md)
-* [Utiliser le Plugin Pepper Flash](tutorial/using-pepper-flash-plugin.md)
-* [Utiliser le Plugin Widevine CDM](tutorial/using-widevine-cdm-plugin.md)
-
-## Tutoriels
-
-* [Démarrage Rapide](tutorial/quick-start.md)
-* [Intégration Environnement de Bureau](tutorial/desktop-environment-integration.md)
-* [Détection des Evènements En ligne/Hors ligne](tutorial/online-offline-events.md)
-
-## Références API
-
-* [Synopsis](api/synopsis.md)
-* [L'objet Process](api/process.md)
-* [Commandes Chromes Supportées](api/chrome-command-line-switches.md)
-* [Variables d'Environnement](api/environment-variables.md)
-
-### Eléments DOM Personnalisés:
-
-* [Objet `File`](api/file-object.md)
-* [Tag `<webview>`](api/webview-tag.md)
-* [Fonction `window.open`](api/window-open.md)
-
-### Modules pour le Processus Principal :
-
-* [app](api/app.md)
-* [autoUpdater](api/auto-updater.md)
-* [BrowserWindow](api/browser-window.md)
-* [contentTracing](api/content-tracing.md)
-* [dialog](api/dialog.md)
-* [globalShortcut](api/global-shortcut.md)
-* [ipcMain](api/ipc-main.md)
-* [Menu](api/menu.md)
-* [MenuItem](api/menu-item.md)
-* [powerMonitor](api/power-monitor.md)
-* [powerSaveBlocker](api/power-save-blocker.md)
-* [protocol](api/protocol.md)
-* [session](api/session.md)
-* [webContents](api/web-contents.md)
-* [Tray](api/tray.md)
-
-### Modules pour le Processus d'Affichage (Page Web) :
-
-* [desktopCapturer](api/desktop-capturer.md)
-* [ipcRenderer](api/ipc-renderer.md)
-* [remote](api/remote.md)
-* [webFrame](api/web-frame.md)
-
-### Modules pour les deux Processus :
-
-* [clipboard](api/clipboard.md)
-* [crashReporter](api/crash-reporter.md)
-* [nativeImage](api/native-image.md)
-* [screen](api/screen.md)
-* [shell](api/shell.md)
-
-## Développement
-
-* [Style de Code](development/coding-style.md)
-* [Hiérarchie du Code Source](development/source-code-directory-structure.md)
-* [Différences Techniques par rapport à NW.js (anciennement node-webkit)](development/atom-shell-vs-node-webkit.md)
-* [Aperçu du Système de Build](development/build-system-overview.md)
-* [Instructions de Build (macOS)](development/build-instructions-osx.md)
-* [Instructions de Build (Windows)](development/build-instructions-windows.md)
-* [Instructions de Build (Linux)](development/build-instructions-linux.md)
-* [Installer un Serveur de Symbol dans le debugger](development/setting-up-symbol-server.md)

docs-translations/fr-FR/faq/electron-faq.md

@@ -1,129 +0,0 @@
-# Electron FAQ
-
-## Quand est mise à jour la version de Chrome utilisée par Electron ?
-
-La version de Chrome qu'utilise Electron est en général mise à jour une ou deux
-semaines après la sortie d'une nouvelle version stable de Chrome.
-
-Etant donné que nous n'utilisons que les versions stables de Chrome, si un fix
-important est en beta ou en dev, nous l'intégrerons à la version que nous
-utilisons.
-
-## Quand est mise à jour la version de Node.js utilisée par Electron ?
-
-Quand une nouvelle version de Node.js sort, nous attendons en général un mois
-avant de mettre à jour celle que nous utilisons dans Electron. Ceci afin
-d'éviter les bugs introduits par les nouvelles versions, ce qui arrive très
-souvent.
-
-Les nouvelles fonctionnalités de Node.js arrivant la plupart du temps via V8,
-et Electron utilisant le V8 du navigateur Chrome, la nouvelle fonctionnalité
-JavaScript de la nouvelle version de Node.js est bien souvent déjà dans
-Electron.
-
-## La fenêtre/barre d'état de mon application disparait après quelques minutes.
-
-Cela se produit quand la variable qui est utilisée pour stocker la fenêtre/barre
-d'état est libérée par le ramasse-miettes.
-
-Nous vous recommandons de lire les articles suivants quand vous rencontrez le
-problème :
-
-* [Management de la Mémoire][memory-management] (Anglais)
-* [Portée d'une Variable][variable-scope] (Anglais)
-
-Si vous voulez corriger rapidement le problème, vous pouvez rendre les variables
-globales en changeant votre code de ça :
-
-```javascript
-app.on('ready', function () {
-  var tray = new Tray('/path/to/icon.png')
-})
-```
-
-à ça :
-
-```javascript
-var tray = null
-app.on('ready', function () {
-  tray = new Tray('/path/to/icon.png')
-})
-```
-
-## Je n'arrive pas à utiliser jQuery/RequireJS/Meteor/AngularJS dans Electron.
-
-A cause de l'intégration de Node.js dans Electron, certains mots-clés sont
-insérés dans la DOM, comme `module`, `exports`, `require`. Ceci pose des
-problèmes pour certaines bibliothèques qui utilisent les mêmes mots-clés.
-
-Pour résoudre ce problème, vous pouvez désactiver l'intégration de node dans
-Electron :
-
-```javascript
-// Dans le processus principal.
-var mainWindow = new BrowserWindow({
-  webPreferences: {
-    nodeIntegration: false
-  }
-})
-```
-
-Mais si vous voulez garder la possibilité d'utiliser Node.js et les APIs
-Electron, vous devez renommer les mots-clés dans la page avant d'inclure
-d'autres bibliothèques :
-
-```html
-<head>
-<script>
-window.nodeRequire = require;
-delete window.require;
-delete window.exports;
-delete window.module;
-</script>
-<script type="text/javascript" src="jquery.js"></script>
-</head>
-```
-
-## `require('electron').xxx` is undefined.
-
-Lors de l'utilisation des modules d'Electron, vous pouvez avoir une erreur :
-
-```
-> require('electron').webFrame.setZoomFactor(1.0);
-Uncaught TypeError: Cannot read property 'setZoomLevel' of undefined
-```
-
-Ceci se produit quand vous avez le [module npm `electron`][electron-module]
-d'installé, soit en local ou en global, ce qui a pour effet d'écraser les
-modules de base d'Electron.
-
-Vous vérifiez que vous utilisez les bons modules, vous pouvez afficher le
-chemin du module `electron` :
-
-```javascript
-console.log(require.resolve('electron'))
-```
-
-et vérifier si il est de la forme :
-
-```
-"/path/to/Electron.app/Contents/Resources/atom.asar/renderer/api/lib/exports/electron.js"
-```
-
-S'il est de la forme `node_modules/electron/index.js`, vous devez supprimer le
-module npm `electron`, ou le renommer.
-
-```bash
-npm uninstall electron
-npm uninstall -g electron
-```
-
-Si vous utilisez le module de base mais que vous continuez d'avoir
-l'erreur, ça vient probablement du fait que vous utilisez le module dans le
-mauvais processus. Par exemple `electron.app` peut uniquement être utilisé
-dans le processus principal, tandis que `electron.webFrame` est uniquement
-disponible dans le processus d'affichage.
-
-[memory-management]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Memory_Management
-[variable-scope]: https://msdn.microsoft.com/library/bzt2dkta(v=vs.94).aspx
-[electron-module]: https://www.npmjs.com/package/electron

docs-translations/fr-FR/styleguide.md

@@ -1,101 +0,0 @@
-# Règles de style pour la documentation d'Electron
-
-Choisissez la section appropriée : [lire la documentation d'Electron](#reading-electron-documentation)
-ou [écrire de la documentation pour Electron](#writing-electron-documentation).
-
-## Ecrire de la documentation pour Electron
-
-La documentation d'Electron a été écrite en suivant les règles ci-dessous :
-
-- Maximum un titre `h1` par page.
-- Utilisation de `bash` au lieu de `cmd` dans les blocs de code (à cause de la
-  coloration syntaxique).
-- Les titres `h1` devraient reprendre le nom de l'objet (i.e. `browser-window` →
-  `BrowserWindow`).
-  - Cependant, les traits d'union sont acceptés pour les noms de fichier.
-- Pas de titre directement après un autre, ajoutez au minimum une ligne de
-  description entre les deux.
-- Les entêtes des méthodes sont entre accents graves (backquotes) `code`.
-- Les entêtes des évènements sont entre des apostrophes 'quotation'.
-- Les listes ne doivent pas dépasser 2 niveaux (à cause du formattage du
-  markdown).
-- Ajouter des titres de section: Evènements, Méthodes de classe, et Méthodes
-  d'instance.
-- Utiliser 'will' au lieu de 'would' lors de la description du retour.
-- Les évènements et méthodes sont des titres `h3`.
-- Les arguments optionnels sont notés `function (required[, optional])`.
-- Les arguments optionnels sont indiqués quand appelés dans la liste.
-- La longueur des lignes ne dépasse pas 80 caractères.
-- Les méthodes spécifiques à une plateforme sont notées en italique.
- - ```### `method(foo, bar)` _macOS_```
-- Préférer 'in the ___ process' au lieu de 'on'
-
-### Traductions de la Documentation
-
-Les traductions de la documentation d'Electron sont dans le dossier
-`docs-translations`.
-
-Pour ajouter une nouvelle langue (ou commencer) :
-
-- Créer un sous-dossier avec comme nom le code langage.
-- A l'intérieur de ce dossier, dupliquer le dossier `docs`, en gardant le même
-  nom de dossiers et de fichiers.
-- Traduire les fichiers.
-- Mettre à jour le `README.md` à l'intérieur du dossier de langue en mettant les
-  liens vers les fichiers traduits.
-- Ajouter un lien vers le nouveau dossier de langue dans le [README](https://github.com/electron/electron#documentation-translations)
-  principal d'Electron.
-
-## Lire la documentation d'Electron
-
-Quelques indications pour comprendre la syntaxe de la documentation d'Electron.
-
-### Méthodes
-
-Un exemple de la documentation d'une [méthode](https://developer.mozilla.org/en-US/docs/Glossary/Method)
-(Anglais)
-
----
-
-`methodName(required[, optional]))`
-
-* `require` String (**required**)
-* `optional` Integer
-
----
-
-Le nom de la méthode est suivi des arguments de celle-ci. Les arguments
-optionnels sont notés entre crochets, avec une virgule si ceux-ci suivent un
-autre argument.
-
-En-dessous de la méthode, chaque argument est détaillé avec son type.
-Celui-ci peut être un type générique :
-[`String`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String),
-[`Number`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number),
-[`Object`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object),
-[`Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)
-ou un type personnalisé comme le [`webContent`](api/web-content.md) d'Electron.
-
-### Evènements
-
-Un exemple d'une documentation d'un [évènement](https://developer.mozilla.org/en-US/docs/Web/API/Event)
-(Anglais)
----
-
-Event: 'wake-up'
-
-Returns:
-
-* `time` String
-
----
-
-L'évènement est une chaine utilisée après un listener `.on`. Si il retourne une
-valeur, elle est écrite en dessous ainsi que son type. Si vous voulez écouter et
-répondre à l'évènement wake-up, ça donne quelque chose comme :
-
-```javascript
-Alarm.on('wake-up', function (time) {
-  console.log(time)
-})
-```

docs-translations/fr-FR/tutorial/electron-versioning.md

@@ -1,14 +0,0 @@
-# Versionage d'Electron
-
-Si vous êtes un développeur Node expérimenté, vous êtes sûrement au courant de `semver` - et pourrez l'utiliser pour donner à vos systèmes de gestion de dépendances seulement des lignes directrices générales plutôt que des numéros de version fixes. En raison d'une forte dépendence avec Node et
-Chromium, Electron est dans une position quelque peu difficile et ne suit pas
-semver. Vous devez donc toujours faire référence à une version spécifique d'Electron.
-
-Les numéros de version sont mis à jour selon les règles suivantes:
-
-* Majeur: Pour les gros changements entrainant des ruptures dans l'API d'Electron - Si vous passez de la version `0.37.0`
-  à `1.0.0`, vous devrez effectuer une migration de votre application.
-* Mineur: Pour des changements majeurs de Chrome et des changements mineurs de Node; ou des changements importants d'Electron - si vous mettez à jour de `1.0.0` vers `1.1.0`, le plus gros de votre application fonctionnera, seuls de petits changements seront à effectuer.
-* Patch: Pour de nouvelles fonctionalités et des résolutions de bugs - si vous passez de la version `1.0.0` à `1.0.1`, votre application continuera de s'exécuter telle quelle.
-
-Si vous utilisez `electron` ou `electron-prebuilt`, nous vous recommandons de fixer le numéro de version (`1.1.0` au lieu de `^1.1.0`) pour être sûr que toutes les mises à jour d'Electron sont une opération manuelle faite par vous, le développeur.

docs-translations/fr-FR/tutorial/quick-start.md

@@ -1,245 +0,0 @@
-# Démarrage Rapide
-
-Electron vous permet de créer des applications de bureau avec du JavaScript
-fournissant un runtime avec des API riches natives (système d'exploitation).
-Vous pourriez le voir comme une variante d'un Node.js directement exécutable
-sur le bureau au lieu des serveurs Web.
-
-Cela ne signifie pas que Electron est une liaison JavaScript à l'interface
-utilisateur graphique (GUI). Au lieu de cela, Electron utilise des pages
-Web comme GUI, donc vous pouvez aussi le voir comme un navigateur minimal
-Chromium, contrôlé par JavaScript.
-
-### Processus principal
-
-Dans Electron, le processus qui exécute le script `main` de` package.json`
-est appelé __le processus principal__. Le script qui s'exécute dans le
-processus principal peut afficher une interface graphique en créant des
-pages Web.
-
-### Processus de rendu
-
-Puisque Electron utilise Chromium pour afficher des pages Web, Chromium
-Multi-process architecture est également utilisé. Chaque page Web d'Electron
-fonctionne avec son propre processus, qui est appelé __le processus de rendu__.
-
-Dans les navigateurs normaux, les pages Web sont habituellement exécutées
-dans un environnement aux ressources indépendantes. Les utilisateurs d'électrons
-ont cependant le pouvoir d'utiliser les API Node.js dans des pages Web permettant
-un système d'exploitation de niveau inférieur d'interactions.
-
-### Différences entre le processus principal et le processus de rendu
-
-Le processus principal crée des pages Web en créant des instances `BrowserWindow`.
-Chaque instance `BrowserWindow` exécute la page Web dans son propre processus
-de rendu. Lorsqu'une occurrence `BrowserWindow` est détruite, le processus
-de rendu correspondant est également terminé.
-
-Le processus principal gère toutes les pages Web et leur processus rendu correspondant.
-Chaque processus de rendu est isolé et ne se soucie que de la page Web en cours
-d'exécution.
-
-Dans les pages Web, l'appel des API relatives aux GUI natives n'est pas autorisé
-car la gestion des ressources natives GUI dans les pages Web est très dangereuse,
-il est facile de perdre des ressources. Si vous souhaitez effectuer des opérations
-GUI dans une page Web, le Processus de la page Web doit communiquer avec le
-processus principal pour lui demander d'effectuer ces opérations.
-
-Dans Electron, nous avons plusieurs façons de communiquer entre le processus principal et
-le processeurs. Comme [`ipcRenderer`](../api/ipc-renderer.md) et [`ipcMain`](../api/ipc-main.md) pour envoyer des messages, et les [Remote](../api/remote.md)
-pour la communication de style RPC. Il y a aussi une entrée de FAQ sur
-[comment partager des données entre des pages Web][share-data].
-
-## Écrivez votre première application Electron
-
-Généralement, une application Electron est structurée comme ceci :
-
-```text
-your-app/
-├── package.json
-├── main.js
-└── index.html
-```
-
-Le format de `package.json` est exactement le même que celui des modules de Node, et
-le script spécifié par le champ `main` est le script de démarrage de votre application,
-qui exécutera le processus principal. Un exemple de votre `package.json` peut être
-comme cela :
-
-```json
-{
-  "name"    : "your-app",
-  "version" : "0.1.0",
-  "main"    : "main.js"
-}
-```
-
-__Note__ : Si le champ `main` n'est pas présent dans` package.json`, Electron
-tentera de charger un fichier `index.js`.
-
-Le fichier `main.js` devrait créer des fenêtres et gérer les événements du système.
-Exemple :
-
-```javascript
-const {app, BrowserWindow} = require('electron')
-const path = require('path')
-const url = require('url')
-
-// Gardez une référence globale de l'objet fenêtre, sinon, la fenêtre
-// sera automatiquement fermée lorsque l'objet JavaScript est récupéré.
-let win
-
-function createWindow () {
-  // Créer la fenêtre du navigateur.
-  win = new BrowserWindow({width: 800, height: 600})
-
-  // charger index.html de l'application.
-  win.loadURL(url.format({
-    pathname: path.join(__dirname, 'index.html'),
-    protocol: 'file:',
-    slashes: true
-  }))
-
-  // Ouvrir DevTools.
-  win.webContents.openDevTools()
-
-  // Émis lorsque la fenêtre est fermée.
-  win.on('closed', () => {
-    // Déréférencer l'objet fenêtre, habituellement vous stockez des fenêtres
-    // dans un tableau si votre application prend en charge plusieurs fenêtres,
-    // c'est l'heure où vous devez supprimer l'élément correspondant.
-    win = null
-  })
-}
-
-// Cette méthode sera appelée lorsque Electron aura terminé l'initialisation
-// et est prét à créer des fenêtres de navigation. Certaines API ne peuvent
-// être utilisées qu'après le lancement de cet événement.
-app.on('ready', createWindow)
-
-// Quittez lorsque toutes les fenêtres sont fermées.
-app.on('window-all-closed', () => {
-  // Sur macOS, il est fréquent que les applications et leur barre de menus
-  // restent actives jusqu'à ce que l'utilisateur quitte explicitement avec Cmd + Q
-  if (process.platform !== 'darwin') {
-    app.quit()
-  }
-})
-
-app.on('activate', () => {
-  // Sur macOS, il est fréquent de recréer une fenêtre dans l'application lorsque
-  // l'icône du dock est cliquée et qu'il n'y a pas d'autres fenêtres ouvertes.
-  if (win === null) {
-    createWindow()
-  }
-})
-
-// Dans ce fichier, vous pouvez inclure le reste du code du processus principal
-// spécifique de votre application. Vous pouvez également les mettres dans des
-// fichiers distincts et les écrire ici.
-```
-
-Enfin, `index.html` est la page web que vous voulez afficher :
-
-```html
-<!DOCTYPE html>
-<html>
-  <head>
-    <meta charset="UTF-8">
-    <title>Hello World!</title>
-  </head>
-  <body>
-    <h1>Hello World!</h1>
-    Nous utilisons le noeud <script>document.write(process.versions.node)</script>,
-    Chrome <script>document.write(process.versions.chrome)</script>,
-    et Electron <script>document.write(process.versions.electron)</script>.
-  </body>
-</html>
-```
-
-## Exécuter votre application
-
-Une fois que vous avez créé vos fichiers `main.js`,` index.html` et `package.json`,
-vous voudriez probablement essayer d'exécuter votre application localement pour la
-tester et vous assurer qu'elle fonctionne comme prévu.
-
-### `electron`
-
-[`electron`](https://github.com/electron-userland/electron-prebuilt) est
-un module `npm` qui contient des versions pré-compilées d'Electron.
-
-Si vous l'avez installé globalement avec `npm`, vous n'en aurez pas besoin
-dans le répertoire source de votre application :
-
-```bash
-electron .
-```
-
-Si vous l'avez installé localement :
-
-#### macOS / Linux
-
-```bash
-$ ./node_modules/.bin/electron .
-```
-
-#### Windows
-
-```bash
-$ .\node_modules\.bin\electron .
-```
-
-### Executable d'Electron téléchargé manuellement
-
-Si vous avez téléchargé Electron manuellement, vous pouvez également utiliser
-binaire pour exécuter votre application directement.
-
-#### Windows
-
-```bash
-$ .\electron\electron.exe your-app\
-```
-
-#### Linux
-
-```bash
-$ ./electron/electron your-app/
-```
-
-#### macOS
-
-```bash
-$ ./Electron.app/Contents/MacOS/Electron your-app/
-```
-
-`Electron.app` fait partie du package de libération de l'Electron, vous pouvez
-télécharger à partir [ici](https://github.com/electron/electron/releases).
-
-### Exécuter en tant que distribution
-
-Une fois que vous avez terminé d'écrire votre application, vous pouvez
-créer une distribution en suivant le guide [Distribuer une application](./application-distribution.md) puis exécuter l'application packagée.
-
-### Essayez cet exemple
-
-Clonez et exécutez le code dans ce didacticiel en utilisant le
-[`electron/electron-quick-start`](https://github.com/electron/electron-quick-start).
-
-**Note** : Exécuter cela nécessite [Git](https://git-scm.com) et [Node.js](https://nodejs.org/en/download/) (que comprend [npm](https://npmjs.org)) sur votre système.
-
-```bash
-# Clone the repository
-$ git clone https://github.com/electron/electron-quick-start
-# Go into the repository
-$ cd electron-quick-start
-# Install dependencies
-$ npm install
-# Run the app
-$ npm start
-```
-
-Pour plus d'exemples app, consultez la section
-[list of boilerplates](https://electron.atom.io/community/#boilerplates)
-Créé par la communauté impressionnante d'électrons.
-
-[share-data]: ../faq.md#how-to-share-data-between-web-pages

docs-translations/fr-FR/tutorial/security.md

@@ -1,75 +0,0 @@
-# Securité, Application Natives, et Votre Responsabilité
-
-En tant que développeurs Web, nous avons l'habitude de bénéficier d'une sécurité élevée au niveau du navigateur - les
-risques associés au code que nous écrivons sont relativement faibles. Nos sites internet ont des droits limités au sein 
-d'une sandbox, et nous faisons confiance à nos utilisateurs pour utiliser des navigateurs créés par de grosses équipes d'ingénieurs 
-capables de réagir rapidement lorsqu'une faille de sécurité est découverte.
-
-Quand on travaille avec Electron, il est important de comprendre qu'Electron n'est pas un navigateur web.
-Il vous permet de construire des applications de bureau riches de fonctionnalités au travers de technologies web familières,
-mais votre code a beaucoup plus de possibilités. Javascript peut accéder au système de fichiers, au shell, et plus. 
-Cela vous permet de construire des applications natives de haute qualité, mais les problèmes de sécurité sont inhérents à toutes ces possibilités.
-
-Avec ça en tête, soyez conscient qu'afficher du contenu arbitraire depuis des sources extérieures pose un gros risque au niveau de la sécurité qu'Electron ne peut gérer.
-En fait, les applications utilisant Electron les plus populaires (Atom, Slack, Visual Studio Code, ...etc) affichent principalement du contenu local (ou de confiance, il s'agit alors de contenu distant sécurisé sans intégration avec Node) - si votre application exécute du code depuis une source extérieure, il est de votre responsabilité de vous assurer que ce code n'est pas malveillant.
-
-
-## Problèmes de sécurité liés à Chromium et mises à jour
-
-Tandis qu'Electron essaie de supporter les nouvelles versions de Chromium dès que possible,
-les developpeurs doivent garder à l'esprit que le fait de mettre à jour l'application est une tâche laborieuse durant laquelle plusieurs douzaines, voire plusieurs centaines de fichiers doivent être modifiés à la main.
-Selon les ressources et les contributions actuelles, Electron ne fonctionnera pas toujours avec la dernière version de Chromium, un délai de quelques jours voire quelques semaines est à prévoir.
-
-Nous pensons que notre système actuel de mises à jour du composant Chromium correspond à un
-équilibre approprié entre les ressources dont nous disposons et les besoins de la
-majorité des applications construites autour du framework.
-Les Pull requests et les contributions supportant cet effort sont toujours les bienvenues.
-
-## Ignorer les conseils précédents
-
-Un problème de sécurité existe quand vous recevez du code depuis une source distante puis l'exécutez localement. Prenons comme exemple l'affichage d'un site web distant affiché à l'intérieur d'une fenêtre de navigateur.
-Si un attaquant parvient d'une quelconque façon de changer son contenu
-(soit en attaquant la source directement, ou bien en se placant entre votre application et sa destination actuelle), ils seront capables d'executer du code natif sur la machine de l'utilisateur.
-
-> :warning: En aucun cas vous ne devez charger puis exécuter du code distant avec Node. A la place, utilisez seulement des fichiers locaux (regroupés avec votre application) pour exécuter du code de Node. Pour afficher du contenu distant, utilisez le tag
-`webview` et assurez vous de désactiver `nodeIntegration`.
-
-#### Checklist
-
-Il ne s'agit pas d'une liste exhaustive, mais au moins, pour palier aux problèmes de sécurités vous devez essayer de:
-
-* Afficher seulement du contenu (https) sécurisé
-* Désactiver l'intégration de Node dans tout ce qui gère le rendu avec du contenu distant
-  (using `webPreferences`)
-* Ne pas désactiver `webSecurity`. Disabling it will disable the same-origin policy.
-* Définir une [`Content-Security-Policy`](http://www.html5rocks.com/en/tutorials/security/content-security-policy/)
-, et utiliser des règles strictes (i.e. `script-src 'self'`)
-* [Surcharger et désactiver `eval`](https://github.com/nylas/N1/blob/0abc5d5defcdb057120d726b271933425b75b415/static/index.js#L6-L8)
-, qui permet à des chaînes de caractères d'être exécutées comme du code.
-* Ne pas assigner `allowRunningInsecureContent` à true.
-* Ne pas activer `experimentalFeatures` ou `experimentalCanvasFeatures` à moins d'être sûr ce que vous faites.
-* Ne pas utiliser `blinkFeatures` à moins d'être sûr ce que vous faites.
-* WebViews: Assigner `nodeintegration` à false
-* WebViews: Ne pas utiliser `disablewebsecurity`
-* WebViews: Ne pas utiliser `allowpopups`
-* WebViews: Ne pas utiliser `insertCSS` ou `executeJavaScript` avec du CSS/JS distant.
-
-Encore une fois, cette liste permet de diminuer les risques de problème de sécurité, mais en aucun cas elle ne l'enlève complètement. Si votre objectif est d'afficher un site internet, choisir un navigateur sera une option plus sûre.
-
-## Buffer Global
-
-La classe [Buffer](https://nodejs.org/api/buffer.html) de Node est actuellement disponible
-en tant que global même quand `nodeIntegration` est à `false`. Vous pouvez le supprimer en faisant la manipulation suivante dans votre script `preload`:
-
-```js
-delete global.Buffer
-```
-
-Le supprimer peut casser les modules Node utilisés dans votre script preload script et votre application depuis que plusieurs librairies s'attendent à ce qu'il soit en tant que global plutôt que de le demander de manière explicite via:
-
-```js
-const {Buffer} = require('buffer')
-```
-
-Le `Buffer` global risque d'être supprimé dans de futures versions d'Electron.
-

docs-translations/fr-FR/tutorial/supported-platforms.md

@@ -1,26 +0,0 @@
-# Plateformes supportées
-
-Les plateformes suivantes sont supportées par Electron:
-
-### macOS
-
-Seuls les binaires en 64bit sont fournis sur macOS, et la version minimale de macOS suportée est macOS 10.9.
-
-### Windows
-
-Les systèmes d'exploitations Windows 7 et supérieur sont supportés. Les versions antérieures ne sont pas supportées (et ne marchent pas).
-
-Les binaires `ia32` (`x86`) et `x64` (`amd64`) sont fournis pour Windows.
-Veuillez noter que la version `ARM` de Windows n'est pas supportée à ce jour.
-
-### Linux
-
-Les binaires précompilés `ia32` (`i686`) et `x64` (`amd64`) d'Electron sont compilés sous
-Ubuntu 12.04, le binaire `arm` est compilé à partir d'une version ARM v7 hard-float ABI et
-NEON pour Debian Wheezy.
-
-Pour que les binaires pré-compilés puissent s'exécuter sur une certaine distribution, il faut que cette distribution inclut les librairies dont Electron a besoin. C'est à dire que seulement Ubuntu 12.04 est garanti de fonctionner, même si les plateformes suivantes sont aussi verifiées et capables d'exécuter les binaires pré-compilés d'Electron:
-
-* Ubuntu 12.04 et suivantes
-* Fedora 21
-* Debian 8

docs-translations/id/README.md

@@ -1,84 +0,0 @@
-[![Electron Logo](https://electron.atom.io/images/electron-logo.svg)](https://electron.atom.io/)
-
-[![Travis Build Status](https://travis-ci.org/electron/electron.svg?branch=master)](https://travis-ci.org/electron/electron)
-[![AppVeyor Build Status](https://ci.appveyor.com/api/projects/status/bc56v83355fi3369/branch/master?svg=true)](https://ci.appveyor.com/project/electron-bot/electron/branch/master)
-[![devDependency Status](https://david-dm.org/electron/electron/dev-status.svg)](https://david-dm.org/electron/electron?type=dev)
-[![Join the Electron Community on Slack](http://atom-slack.herokuapp.com/badge.svg)](http://atom-slack.herokuapp.com/)
-
-:memo: Terjemahan yg tersedia: [Korean](https://github.com/electron/electron/tree/master/docs-translations/ko-KR/project/README.md) | [Simplified Chinese](https://github.com/electron/electron/tree/master/docs-translations/zh-CN/project/README.md) | [Brazilian Portuguese](https://github.com/electron/electron/tree/master/docs-translations/pt-BR/project/README.md) | [Traditional Chinese](https://github.com/electron/electron/tree/master/docs-translations/zh-TW/project/README.md) | [Spanish](https://github.com/electron/electron/tree/master/docs-translations/es/project/README.md) | [Turkish](https://github.com/electron/electron/tree/master/docs-translations/tr-TR/project/README.md)
-
-Framework Electron membuat Anda bisa menulis aplikasi desktop yang cross-platform menggunakan JavaScript, HTML dan CSS. Framework ini bersumber dari
-
-[Node.js](https://nodejs.org/) dan
-[Chromium](http://www.chromium.org) dan dipakai dalam
-[Atom editor](https://github.com/atom/atom) dan applikasi-applikasi lainnya [apps](https://electron.atom.io/apps).
-
-Ikuti [@ElectronJS](https://twitter.com/electronjs) lewat Twitter untuk informasi-informasi penting.
-
-Proyek ini mengikuti perjanjian kontributor [code of conduct](CODE_OF_CONDUCT.md).
-Partisipasi Anda di proyek ini harus mengikuti panduan di atas. Harap laporkan perbuatan yg kurang berkenan melalui electron@github.com.
-
-## Unduhan
-
-Untuk instalasi versi binari Electron, pakai
-[`npm`](https://docs.npmjs.com/):
-
-```sh
-# Install as a development dependency
-npm install electron --save-dev
-
-# Install the `electron` command globally in your $PATH
-npm install electron -g
-```
-
-Ikuti [releases page](https://github.com/electron/electron/releases) untuk prebuilt binaries, debug symbols, dan lain-lain.
-
-### Mirrors
-
-- [China](https://npm.taobao.org/mirrors/electron)
-
-## Dokumentasi
-
-Panduan dan referensi API bisa ditemukan di direktori
-[docs](https://github.com/electron/electron/tree/master/docs). Direktori tersebut juga berisi dokumen-dokumen yg menunjukkan bagaimana Anda bisa berkontribusi ke proyek Electron.
-
-## Terjemahan Dokumentasi
-
-- [Brazilian Portuguese](https://github.com/electron/electron/tree/master/docs-translations/pt-BR)
-- [Korean](https://github.com/electron/electron/tree/master/docs-translations/ko-KR)
-- [Japanese](https://github.com/electron/electron/tree/master/docs-translations/jp)
-- [Spanish](https://github.com/electron/electron/tree/master/docs-translations/es)
-- [Simplified Chinese](https://github.com/electron/electron/tree/master/docs-translations/zh-CN)
-- [Traditional Chinese](https://github.com/electron/electron/tree/master/docs-translations/zh-TW)
-- [Turkish](https://github.com/electron/electron/tree/master/docs-translations/tr-TR)
-- [Thai](https://github.com/electron/electron/tree/master/docs-Translations/th-TH)
-- [Ukrainian](https://github.com/electron/electron/tree/master/docs-translations/uk-UA)
-- [Russian](https://github.com/electron/electron/tree/master/docs-translations/ru-RU)
-- [French](https://github.com/electron/electron/tree/master/docs-translations/fr-FR)
-- [Indonesian](https://github.com/electron/electron/tree/master/docs-translations/id)
-
-## Mulai Cepat
-
-Klon dan jalankan repo [`electron/electron-quick-start`](https://github.com/electron/electron-quick-start) untuk melihat aplikasi sederhana menggunakan Electron.
-
-## Komunitas
-
-Anda bisa berinteraksi di lokasi-lokasi ini:
-- [`electron`](http://discuss.atom.io/c/electron) kategori forum Atom
-- `#atom-shell` channel di Freenode
-- [`Atom`](http://atom-slack.herokuapp.com/) channel di Slack
-- [`electron-ru`](https://telegram.me/electron_ru) *(Russian)*
-- [`electron-br`](https://electron-br.slack.com) *(Brazilian Portuguese)*
-- [`electron-kr`](http://www.meetup.com/electron-kr/) *(Korean)*
-- [`electron-jp`](https://electron-jp.slack.com) *(Japanese)*
-- [`electron-tr`](http://electron-tr.herokuapp.com) *(Turkish)*
-- [`electron-id`](https://electron-id.slack.com) *(Indonesia)*
-
-Cek [awesome-electron](https://github.com/sindresorhus/awesome-electron)
-untuk menemukan daftar contoh-contoh aplikasi dan sumber-sumber berguna lainnya.
-
-## Lisensi
-
-[MIT](https://github.com/electron/electron/blob/master/LICENSE)
-
-Kalau menggunakan logo Electro ata logo Github lainnya gunakan panduan berikut [GitHub logo guidelines](https://github.com/logos).

docs-translations/id/tutorial/using-widevine-cdm-plugin.md

@@ -1,92 +0,0 @@
-# Menggunakan *Plugin Widevine CDM*
-
-Di Electron, anda dapat menggunakan *plugin Widevine CDM* yang disertakan dengan
-*browser* Chrome.
-
-## Mendapatkan *plugin*
-
-Elektron tidak disertakan dengan *plugin Widevine CDM* karena alasan lisensi,
-untuk mendapatkanny, anda perlu menginstal *browser* Chrome resmi terlebih dahulu,
-yang seharusnya cocok dengan arsitektur dan versi Chrome dari Elektron yang anda
-gunakan.
-
-**Catatan:** Versi utama *browser* Chrome harus sama dengan versi Chrome yang
-digunakan oleh Electron, jika tidak cocok, *plugin* tidak akan bekerja sekalipun
-`Navigator.plugins` akan menunjukkan bahwa ia telah dimuat.
-
-### Windows & macOS
-
-Buka `chrome://components/` di *browser* Chrome, cari `WidevineCdm` dan pastikan
-apabila itu *up-to-date*, maka Anda dapat menemukan semua plugin binari dari direktori
-`APP_DATA / Google / Chrome / WidevineCDM / VERSION / _platform_specific / PLATFORM_ARCH /`.
-
-
-
-`APP_DATA` adalah lokasi sistem untuk menyimpan data aplikasi, di sistem Windows
-itu ada di `% LOCALAPPDATA%`, di macOS itu ada di `~ / Library / Application Support`.
-`VERSION` adalah versi *Widevine CDM plugin*, seperti `1.4.8.866`. `PLATFORM` adalah `mac`
-atau `win`. `ARCH` adalah` x86` atau `x64`.
-
-Di Windows, binari yang dibutuhkan adalah `widevinecdm.dll` dan
-`Widevinecdmadapter.dll`, di macOS adalah` libwidevinecdm.dylib` dan
-`Widevinecdmadapter.plugin`. Anda bisa menyalinnya ke manapun Anda suka, tapi
-mereka harus di letakkan bersama.
-
-
-### Linux
-
-
-Di Linux, binari plugin disertakan bersama dengan *browser* Chrome, anda bisa
-menemukannya di `/ opt / google / chrome`, nama filenya adalah` libwidevinecdm.so` dan
-`Libwidevinecdmadapter.so`.
-
-
-
-## Menggunakan *plugin*
-
-Setelah mendapatkan *file* plugin, anda harus meneruskan `widevinecdmadapter`
-ke Electron dengan baris perintah penghubung `--widevine-cdm-path`, dan versi
-pluginnya dengan pengubung `--widevine-cdm-version`.
-
-**Catatan:** Meskipun hanya binari `widevinecdmadapter` yang dilewatkan ke Electron, binari
-`Widevinecdm` harus disertakan bersama.
-
-Penghubung baris perintah harus dilewati sebelum `ready` dari` app` modul dipancarkan,
-dan halaman yang menggunakan plugin ini harus mempunyai *plugin* yang sudah diaktifkan.
-
-
-Contoh kode:
-
-```javascript
-const {app, BrowserWindow} = require('electron')
-
-// Anda harus melewatkan filename `widevinecdmadapter` di sini, yang disebut adalah:
-// * `widevinecdmadapter.plugin` on macOS,
-// * `libwidevinecdmadapter.so` on Linux,
-// * `widevinecdmadapter.dll` on Windows.
-app.commandLine.appendSwitch('widevine-cdm-path', '/path/to/widevinecdmadapter.plugin')
-// Versi plugin dapat didapatkan dari halaman `chrome://plugins` di Chrome.
-app.commandLine.appendSwitch('widevine-cdm-version', '1.4.8.866')
-
-let win = null
-app.on('ready', () => {
-  win = new BrowserWindow({
-    webPreferences: {
-      // `plugins` harus diaktifkan.
-      plugins: true
-    }
-  })
-  win.show()
-})
-```
-
-## Verifikasi plugin
-
-Untuk memverifikasi jika plugin telah berhasil, anda dapat menggunakan cara berikut:
-
-* Buka *devtools* dan periksa apakah `navigator.plugins` menyertakan *Widevine
-Plugin CDM*
-* Buka https://shaka-player-demo.appspot.com/ dan muat manifes yang menggunakan
-`Widevine`.
-* Buka http://www.dash-player.com/demo/drm-test-area/, periksa apakah di halamannya
-terdapat `bitdash uses Widevine in your browser`, lalu putar videonya.

docs-translations/id/tutorial/windows-store-guide.md

@@ -1,170 +0,0 @@
-# Panduan Windows Store
-
-Dengan Windows 10, eksekusi win32 yg lama mendapatkan saudara yang baru: *The
-Universal Windows Platform*. Format `.appx` yang baru tidak hanya memungkinkan
-sejumlah API yang baru dan hebat seperti *Cortana* atau *Push Notifications*,
-tetapi juga melalui *Windows Store*, ini akan menyederhanakan instalasi dan update.
-
-Microsoft [telah mengembangkan sebuah alat yang mengkompilasi aplikasi Elektron sebagai paket `.appx`][electron-windows-store], memungkinkan *developer* untuk menggunakan beberapa
-sarana yang dapat ditemukan di model aplikasi baru. Panduan ini menjelaskan cara
-menggunakannya - dan kemampuan dan keterbatasan paket Electron AppX.
-
-## Latar Belakang dan Persyaratan
-
-Windows 10 "Anniversary Update" dapat menjalankan win32 `.exe` *binaries* dengan cara
-meluncurkan mereka bersama-sama dengan *filesystem* virtual dan pendaftaran . Keduanya
-dibuat saat kompilasi dengan menjalankan aplikasi and instalasi di dalam *Windows
-Container*, memungkinkan *Windows* untuk mengidentifikasi secara tepat modifikasi
-sistem operasi mana yang dilakukan saat instalasi. Memasangkan eksekusi
-*filesystem* virtual dan pendaftaran virtual yang memungkinkan *Windows* untuk
-menjalankan *one-click* instalasi and menghapus instalasi.
-
-Selain itu, exe diluncurkan di dalam bentuk appx - yang berarti bisa menggunakan
-API banyak yang tersedia di *Windows Universal Platform*. Untuk mendapatkan
-kemampuan yang lebih, aplikasi Electron dapat dipasangkan dengan *UWP background task*
-tersembunyi yang dapat diluncurkan bersamaan dengan `exe` - seperti diluncurkan
-sebagai dampingan untuk menjalankan *tasks* yang berjalan di *background*,
-menerima *push-notification*, atau untuk berkomunikasi dengan aplikasi UWP lainnya.
-
-Untuk mengkompilasi aplikasi Elektron yang ada, pastikan anda memenuhi
-persyaratan berikut:
-
-* Windows 10 with Anniversary Update (dikeluarkan August 2nd, 2016)
-* The Windows 10 SDK, [unduh disini][windows-sdk]
-* Setidaknya Node 4 (untuk mengecek, jalankan `node -v`)
-
-
-Kemudian, instal `electron-windows-store` CLI:
-
-```
-npm install -g electron-windows-store
-```
-
-## Step 1:  Kemas Aplikasi Elektron Anda
-
-Kemas aplikasi menggunakan [electron-packager][electron-packager] (atau alat serupa).
-Pastikan untuk menghapus `node_modules` yang tidak anda perlukan dalam aplikasi akhir
-anda, karena modul yang tidak anda butuhkan hanya akan meningkatkan ukuran aplikasi anda.
-
-Outputnya kira-kira akan terlihat seperti ini:
-```
-├── Ghost.exe
-├── LICENSE
-├── content_resources_200_percent.pak
-├── content_shell.pak
-├── d3dcompiler_47.dll
-├── ffmpeg.dll
-├── icudtl.dat
-├── libEGL.dll
-├── libGLESv2.dll
-├── locales
-│   ├── am.pak
-│   ├── ar.pak
-│   ├── [...]
-├── natives_blob.bin
-├── node.dll
-├── resources
-│   ├── app
-│   └── atom.asar
-├── snapshot_blob.bin
-├── squirrel.exe
-└── ui_resources_200_percent.pak
-```
-
-
-## 2: Menjalankan *electron-windows-store*
-
-Dari *PowerShell* (jalankan sebagai "Administrator"), jalankan
-`Electron-windows-store` dengan parameter yang dibutuhkan, menggunakan kedua
-direktori *input* dan *output*, nama dan versi aplikasi, dan konfirmasi
-`Node_modules` harus di *flatten*.
-
-```
-electron-windows-store `
-    --input-directory C:\myelectronapp `
-    --output-directory C:\output\myelectronapp `
-    --flatten true `
-    --package-version 1.0.0.0 `
-    --package-name myelectronapp
-```
-
-Setelah dijalankan, alat ini akan mulai bekerja: Ia akan menerima aplikasi Elektron
-anda sebagai *input*, *flattening* `node_modules`. Kemudian, ia akan mengarsipkan
-aplikasi anda sebagai `app.zip`. Dengan menggunakan *installer* dan *Windows Container*
-, alat ini menciptakan paket AppX yang "diperluas" - termasuk *Windows Application
-Manifest* (`AppXManifest.xml`) berserta dengan sistem *virtual file* dan pendaftaran
-virtual di dalam map *output* anda.
-
-
-Setelah *file* AppX yang diperluas telah dibuat, alat ini menggunakan
-*Windows App Packager* (`MakeAppx.exe`) untuk menggabungkan paket AppX menjadi satu
-*file* dari file-file yang ada di *disk*. Akhirnya, alat ini juga bisa digunakan
-untuk membuat sertifikat terpercaya di komputer anda untuk menandatangani paket
-AppX yang baru. Dengan paket AppX yang telah ditandatangani, CLI juga bisa
-secara otomatis menginstal paket di mesin anda.
-
-
-## 3: Menggunakan Paket AppX
-
-Untuk menjalankan paket, pengguna akan memerlukan Windows 10 dengan apa
-yang disebutnya *"Anniversary Update"* - rincian tentang cara memperbarui Windows
-dapat ditemukan [di sini][how-to-update].
-
-Di sisi lain dari aplikasi-aplikasi UWP tradisional, aplikasi yang terpaket saat ini
-perlu menjalani proses verifikasi manual, yang dapat anda terapkan
-[disini][centennial-campaigns]. Sementara itu, semua pengguna bisa menginstal
-paket anda dengan mengklik dua kali, oleh sebab itu, pengiriman submisi ke toko
-tidak diperlukan jika anda hanya mencari metode instalasi yang mudah. Di lingkungan
-yang dikelola (biasanya perusahaan), `Add-AppxPackage` [PowerShell Cmdlet dapat digunakan untuk menginstalnya secara otomatis][add-appxpackage].
-
-Keterbatasan penting lainnya adalah paket AppX yang telah dikompilasi masih berisi
-*Win32 executable* - dan karena itu tidak akan berjalan di *Xbox*, *HoloLens*,
-atau Telepon.
-
-
-## Opsional: Tambahkan Fitur UWP menggunakan *BackgroundTask*
-
-Anda dapat memasangkan aplikasi Elektron Anda dengan tugas *background* UWP yang
-tersembunyi yang akan memanfaatkan sepenuhnya fitur Windows 10 - seperti *push-notification*,
-integrasi Cortana, atau *live tiles*.
-
-Untuk mencari tahu bagaimana aplikasi Elektron yang menggunakan *background task*
-untuk mengirim *toast notification* dan *live tiles*, [lihat contoh yang disediakan Microsoft][background-task].
-
-
-## Opsional: Mengkonversi menggunakan *Container Virtualization*
-
-Untuk menghasilkan paket AppX, `elektron-windows-store` CLI menggunakan *template*
-yang seharusnya bekerja untuk sebagian besar aplikasi Electron. Namun, jika anda
-menggunakan *custom installer*, atau jika anda mengalami masalah dengan paket
-yang dihasilkan, anda dapat mencoba membuat paket menggunakan kompilasi dengan
-bantuan Windows Container - di dalam mode itu, CLI akan menginstal dan menjalankan
-aplikasi Anda di dalam *Windows Container* yang kosong untuk menentukan
-modifikasi apa yang aplikasi Anda lakukan pada sistem operasi.
-
-Sebelum menjalankan CLI, anda harus mengatur *"Windows Desktop App Converter"*.
-Ini akan memakan waktu beberapa menit, tapi jangan khawatir - anda hanya perlu
-melakukan ini sekali saja. Unduh *Desktop App Converter* dari [di sini][app-converter].
-Anda akan menerima dua file: `DesktopAppConverter.zip` dan` BaseImage-14316.wim`.
-
-1. *Unzip* `DesktopAppConverter.zip`. Dari PowerShell (dibuka dengan
-  "jalankan sebagai Administrator", pastikan bahwa kebijakan eksekusi sistem
-anda mengizinkan untuk menjalankan semua yang ingin dijalankan dengan menggunakan `Set-ExecutionPolicy bypass`.
-2. Kemudian, jalankan instalasi *Desktop App Converter*, dengan menggunakan lokasi
-*Windows Base Image* (di unduh sebagai `BaseImage-14316.wim`), dengan cara memanggil
-perintah `. \ DesktopAppConverter.ps1 -Setup -BaseImage. \ BaseImage-14316.wim`.
-3. Jika menjalankan perintah tersebut menyebabkan *reboot*, silakan *restart*
-mesin anda dan mejalankan perintah yang telah disebutkan diatas setelah berhasil
-*restart*.
-
-Setelah instalasi telah berhasil, anda dapat melajutkan untuk mengkompilasi
-aplikasi Electron anda.
-
-[windows-sdk]: https://developer.microsoft.com/en-us/windows/downloads/windows-10-sdk
-[app-converter]: https://www.microsoft.com/en-us/download/details.aspx?id=51691
-[add-appxpackage]: https://technet.microsoft.com/en-us/library/hh856048.aspx
-[electron-packager]: https://github.com/electron-userland/electron-packager
-[electron-windows-store]: https://github.com/catalystcode/electron-windows-store
-[background-task]: https://github.com/felixrieseberg/electron-uwp-background
-[centennial-campaigns]: https://developer.microsoft.com/en-us/windows/projects/campaigns/desktop-bridge
-[how-to-update]: https://blogs.windows.com/windowsexperience/2016/08/02/how-to-get-the-windows-10-anniversary-update

docs-translations/it-IT/README.md

@@ -1,100 +0,0 @@
-Sii certo di usare la documentazione che corrisponde alla tua versione di
-Electron. Il numero della versione dovrebbe fare parte dell'URL della pagina.
-Se cos<6F> non fosse, stai probabilmente utilizzando una documentazione facente
-parte di una branch di sviluppo che potrebbe contenere modifiche all'API che non
-sono compatibili con la tua versione di Electron. In questo caso, puoi passare a
-una differente versione della documentazione dalla lista di
-[versioni disponibili](https://electron.atom.io/docs/) su atom.io, o nel caso tu
-stia usando l'interfaccia di GitHub, apri il menu a tendina "Switch
-branches/tags" e seleziona il tag che corrisponde alla tua versione.
-
-## FAQ
-
-Ci sono domande che vengono chieste abbastanza spesso, quindi controlla questa
-sezione prima di creare una issue:
-
-* [Electron FAQ](faq.md)
-
-## Guide
-
-* [Piattaforme Supportate](tutorial/piattaforme-supportate.md)
-* [Sicurezza](tutorial/sicurezza.md)
-* [Versionamento Electron](tutorial/versionamento-electron.md)
-* [Distribuzione dell'Applicazione](tutorial/distribuzione-applicazione.md)
-* [Guida Mac App Store](tutorial/guida-mac-app-store.md)
-* [Guida Windows Store](tutorial/guida-windows-store.md)
-* [Packaging Applicazione](tutorial/packaging-applicazione.md)
-* [Usare Moduli Node Nativi](tutorial/usare-moduli-node-nativi.md)
-* [Debugging Processo Principale](tutorial/debugging-processo-principale.md)
-* [Usare Selenium e WebDriver](tutorial/usare-selenium-e-webdriver.md)
-* [Estensioni DevTools](tutorial/estensioni-devtools.md)
-* [Usare Plugin Pepper Flash](tutorial/usare-plugin-pepper-flash.md)
-* [Usare Plugin Widevine CDM](tutorial/usare-plugin-widevine-cdm.md)
-* [Testare su Sistemi Headless CI (Travis, Jenkins)](tutorial/testare-su-sistemi-headless-ci.md)
-* [Rendering Offscreen](tutorial/rendering-offscreen.md)
-
-## Tutorial
-
-* [Guida Rapida](tutorial/guida-rapida.md)
-* [Integrazione Ambiente Desktop](tutorial/integrazione-ambiente-desktop.md)
-* [Rilevazione Eventi Online/Offline](tutorial/eventi-online-offline.md)
-
-## Documentazione API
-
-* [Sinossi](api/sinossi.md)
-* [Oggetto Process](api/process.md)
-* [Parametri Linea di Comando Chrome Supportati](api/parametri-linea-comando-chrome.md)
-* [Variabili di Ambiente](api/variabili-ambiente.md)
-
-### Elementi personalizzati DOM:
-
-* [Oggetto `File`](api/oggetto-file.md)
-* [Tag `<webview>`](api/webview-tag.md)
-* [Funzione `window.open`](api/window-open.md)
-
-### Moduli per il Processo Main:
-
-* [app](api/app.md)
-* [autoUpdater](api/auto-updater.md)
-* [BrowserWindow](api/browser-window.md)
-* [contentTracing](api/content-tracing.md)
-* [dialog](api/dialog.md)
-* [globalShortcut](api/global-shortcut.md)
-* [ipcMain](api/ipc-main.md)
-* [Menu](api/menu.md)
-* [MenuItem](api/menu-item.md)
-* [powerMonitor](api/power-monitor.md)
-* [powerSaveBlocker](api/power-save-blocker.md)
-* [protocol](api/protocol.md)
-* [session](api/session.md)
-* [systemPreferences](api/system-preferences.md)
-* [Tray](api/tray.md)
-* [webContents](api/web-contents.md)
-
-### Moduli per il Processo di Rendering (Pagina Web):
-
-* [desktopCapturer](api/desktop-capturer.md)
-* [ipcRenderer](api/ipc-renderer.md)
-* [remote](api/remote.md)
-* [webFrame](api/web-frame.md)
-
-### Moduli per Entrambi i Processi:
-
-* [clipboard](api/clipboard.md)
-* [crashReporter](api/crash-reporter.md)
-* [nativeImage](api/native-image.md)
-* [screen](api/screen.md)
-* [shell](api/shell.md)
-
-## Sviluppo
-
-* [Stile Codice](development/stile-codice.md)
-* [Struttura Cartella Codice Sorgente](development/struttura-cartella-codice-sorgente.md)
-* [Differenze Tecniche da NW.js (precedentemente node-webkit)](development/atom-shell-vs-node-webkit.md)
-* [Panoramica Sistema di Build](development/panoramica-sistema-build.md)
-* [Istruzioni Build (macOS)](development/istruzioni-build-macos.md)
-* [Istruzioni Build (Windows)](development/istruzioni-build-windows.md)
-* [Istruzioni Build (Linux)](development/istruzioni-build-linux.md)
-* [Istruzioni Debug (macOS)](development/istruzioni-debug-macos.md)
-* [Istruzioni Debug (Windows)](development/istruzioni-debug-windows.md)
-* [Impostare Symbol Server nel debugger](development/impostare-symbol-server.md)

docs-translations/it-IT/faq.md

@@ -1,167 +0,0 @@
-# Electron FAQ
-
-## Quando verrà utilizzata l'ultima versione di Chrome per Electron?
-
-La versione di Chrome usata da Electron viene aggiornata solitamente entro una o
-due settimane dal rilascio di una versione stabile di Chrome. Questa stima non è
-garantita e dipende dall'ammontare di lavoro necessario all'aggiornamento.
-
-E' utilizzato solo il canale stabile di Chrome. Se un fix importante si trovasse
-sui canali beta o dev, lo applicheremo a una versione precedente.
-
-Per maggiori informazioni, leggi l'[introduzione alla sicurezza](tutorial/sicurezza.md).
-
-## Quando verrà utilizzata l'ultima versione di Node.js per Electron?
-
-Quando una nuova versione di Node.js viene rilasciata, aspettiamo per circa un
-mese prima di aggiornare quella di Electron. Possiamo così evitare di essere
-influenzati dai bug introdotti nelle nuove versioni di Node.js, cosa che accade
-spesso.
-
-Le nuove funzionalità di Node.js sono solitamente introdotte dagli aggiornamenti
-di V8. Siccome Electron usa la versione di V8 integrata nel browser Chrome, le
-nuove funzionalità di JavaScript implementate nella nuova versione di Node.js
-sono già presenti in Electron.
-
-## Come condividere dati tra pagine web?
-
-Il modo più semplice per condividere dati tra pagine web (il processo di 
-rendering) è usare le API di HTML5 già disponibili nei browser. Alcune buone
-opzioni sono [Storage API][storage], [`localStorage`][local-storage],
-[`sessionStorage`][session-storage] e [IndexDB][indexed-db].
-
-Oppure puoi usare il sistema IPC, che è specifico di Electron, per memorizzare
-gli oggetti nel processo principale come variabile globale e accedervi poi
-dai renderer tramite la proprietà `remote` del modulo `electron`:
-
-```javascript
-// Nel processo principale.
-global.sharedObject = {
-  someProperty: 'valore di default'
-}
-```
-
-```javascript
-// Nella pagina 1.
-require('electron').remote.getGlobal('sharedObject').someProperty = 'nuovo valore'
-```
-
-```javascript
-// Nella pagina 2.
-console.log(require('electron').remote.getGlobal('sharedObject').someProperty)
-```
-
-## La finestra/icona della mia app è sparita dopo qualche minuto.
-
-Ciò accade quando una variabile usata per la memorizzazione della finestra/
-icona viene garbage-collected.
-
-Se dovessi incontrare questo problema, i seguenti articoli potrebbero esserti
-d'aiuto:
-
-* [Gestione Memoria][memory-management]
-* [Visibilità Variabili][variable-scope]
-
-Se hai bisogno di un fix veloce, puoi rendere le variabili globali cambiando il
-tuo codice da così:
-
-```javascript
-const {app, Tray} = require('electron')
-app.on('ready', () => {
-  const tray = new Tray('/percorso/icona.png')
-  tray.setTitle('ciao mondo')
-})
-```
-
-a così:
-
-```javascript
-const {app, Tray} = require('electron')
-let tray = null
-app.on('ready', () => {
-  tray = new Tray('/percorso/icona.png')
-  tray.setTitle('ciao mondo')
-})
-```
-
-## Non posso usare jQuery/RequireJS/Meteor/AngularJS in Electron.
-
-Data l'integrazione di Node.js di Electron, vi sono alcuni simboli extra
-inseriti nel DOM quali `module`, `exports`, `require`. Ciò causa problemi ad
-alcune librerie in quanto vogliono inserire simboli con gli stessi nomi.
-
-Per risolvere il problema, puoi disattivare l'integrazione di Node in Electron:
-
-```javascript
-// Nel processo principale.
-const {BrowserWindow} = require('electron')
-let win = new BrowserWindow({
-  webPreferences: {
-    nodeIntegration: false
-  }
-})
-win.show()
-```
-
-Se invece volessi mantenere la capacità di usare Node.js e le API di Electron,
-devi rinominare i simboli nella pagina prima di includere altre librerie:
-
-```html
-<head>
-<script>
-window.nodeRequire = require;
-delete window.require;
-delete window.exports;
-delete window.module;
-</script>
-<script type="text/javascript" src="jquery.js"></script>
-</head>
-```
-
-## `require('electron').xxx` is undefined.
-
-Mentre usi il modulo integrato di Electron potresti incorrere in un errore
-come questo:
-
-```
-> require('electron').webFrame.setZoomFactor(1.0)
-Uncaught TypeError: Cannot read property 'setZoomLevel' of undefined
-```
-
-Ciò è causato dal fatto che hai il [modulo npm `electron`][electron-module]
-installato localmente o globalmente, e ciò sovrascrive il modulo integrato di
-Electron.
-
-Per verificare che tu stia usando il modulo integrato corretto, puoi stampare a
-schermo il percorso del modulo `electron`:
-
-```javascript
-console.log(require.resolve('electron'))
-```
-
-e dopodiché controlla che sia in questa forma
-
-```
-"/percorso/Electron.app/Contents/Resources/atom.asar/renderer/api/lib/exports/electron.js"
-```
-
-Se dovesse essere simile a `node_modules/electron/index.js`, allora devi
-rimuovere il modulo npm `electron` oppure rinominarlo.
-
-```bash
-npm uninstall electron
-npm uninstall -g electron
-```
-
-Tuttavia, se usi il modulo integrato e continui a ricevere questo errore è molto
-probabile che tu stia usando il modulo in un processo sbagliato. Per esempio
-`electron.app` può essere usato solo nel processo principale, mentre
-`electron.webFrame` è disponibile solo nel processo di rendering.
-
-[memory-management]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Memory_Management
-[variable-scope]: https://msdn.microsoft.com/library/bzt2dkta(v=vs.94).aspx
-[electron-module]: https://www.npmjs.com/package/electron
-[storage]: https://developer.mozilla.org/en-US/docs/Web/API/Storage
-[local-storage]: https://developer.mozilla.org/en-US/docs/Web/API/Window/localStorage
-[session-storage]: https://developer.mozilla.org/en-US/docs/Web/API/Window/sessionStorage
-[indexed-db]: https://developer.mozilla.org/en-US/docs/Web/API/IndexedDB_API

docs-translations/it-IT/styleguide.md

@@ -1,246 +0,0 @@
-# Guida allo Stile della Documentazione
-
-Queste sono le linee guida per la stesura della documentazione di Electron.
-
-## Titoli
-
-* Ogni pagina deve avere un singolo titolo di livello `#` all'inizio.
-* I capitoli di una stessa pagina devono avere titoli di livello `##`.
-* I sotto-capitoli devono avere un numero crescente di `#` a seconda del loro
-livello di annidamento.
-* Tutte le parole nel titolo della pagina devono iniziare con la lettera
-maiuscola, a eccezione delle congiunzioni come "di" ed "e".
-* Solo la prima lettera della prima parola di un capitolo deve essere maiuscola.
-
-Prendendo `Guida Rapida` come esempio:
-
-```markdown
-# Guida Rapida
-
-...
-
-## Processo principale
-
-...
-
-## Processo di rendering
-
-...
-
-## Esegui la tua app
-
-...
-
-### Crea una distribuzione
-
-...
-
-### Electron scaricato manualmente
-
-...
-```
-
-Esistono eccezioni a queste regole per quanto riguarda la documentazione delle
-API.
-
-## Regole markdown
-
-* Usa `bash` invece di `cmd` nei blocchi di codice (per via della diversa
-evidenziazione della sintassi).
-* Le linee devono essere lunghe al massimo 80 caratteri.
-* Non annidare le liste per pi<70> di due livelli (per via del rendering compiuto
-da markdown).
-* Tutti i blocchi di codice `js` o `javascript` sono analizzati con
-[standard-markdown](http://npm.im/standard-markdown). 
-
-## Documentazione API
-
-Le regole seguenti vengono applicate solo alla documentazione delle API.
-
-### Titolo della pagina
-
-Ogni pagina deve avere come titolo il nome dell'oggetto a cui si riferisce
-seguito da `require('electron')`, come ad esempio `BrowserWindow`, `autoUpdater`
-e `session`.
-
-Sotto il titolo della pagina deve esserci una descrizione della lunghezza di una
-linea che comincia con `>`.
-
-Prendendo `session` come esempio:
-
-```markdown
-# session
-
-> Gestisce le sessioni browser, cookies, cache, impostazioni proxy, etc.
-```
-
-### Metodi ed eventi dei moduli
-
-Per i moduli che non sono classi, i loro metodi ed eventi devono essere elencati
-sotto i capitoli `## Metodi` ed `## Eventi`.
-
-Prendendo `autoUpdate` come esempio:
-
-```markdown
-# autoUpdater
-
-## Eventi
-
-### Evento: 'error'
-
-## Metodi
-
-### `autoUpdater.setFeedURL(url[, requestHeaders])`
-```
-
-### Classi
-
-* Le classi API e le classi che sono parte di moduli devono essere elencate
-sotto un capitolo `## Classe: NomeDellaClasse`.
-* Una pagina pu<70> avere pi<70> classi.
-* I costruttoi devono essere elencati con un titolo di livello `###`.
-* I [Metodi Statici](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes/static) (Inglese) devono essere elencati sotto un capitolo
-`### Metodi Statici`.
-* I [Metodi di Istanza](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes#Prototype_methods) (Inglese) devono essere elencati sotto un
-capitolo `### Metodi di Istanza`.
-* Gli Eventi di Istanza devono essere elencati sotto un capitolo
-`## Eventi di Istanza`.
-* Le Propriet<65> di Istanza devono essere elencate sotto un capitolo `## Propriet<65> di Istanza`.
-
-Prendendo le classi `Session` e `Cookies` come esempi:
-
-```markdown
-# session
-
-## Metodi
-
-### session.fromPartition(partition)
-
-## Propriet<65>
-
-### session.defaultSession
-
-## Classe: Session
-
-### Eventi di Istanza
-
-#### Evento: 'will-download'
-
-### Metodi di Istanza
-
-#### `ses.getCacheSize(callback)`
-
-### Propriet<65> di Istanza
-
-#### `ses.cookies`
-
-## Classe: Cookies
-
-### Metodi di Istanza
-
-#### `cookies.get(filter, callback)`
-```
-
-### Metodi
-
-Il capitolo dei metodi deve seguire il seguente formato:
-
-```markdown
-### `objectName.methodName(required[, optional]))`
-
-* `required` String
-* `optional` Integer (optional)
-
-...
-```
-
-Il titolo pu<70> essere di livello `###` o `####` a seconda che sia un metodo di
-un modulo o di una classe.
-
-Per i moduli, il `nomeOggetto` <20> il nome del modulo. Per le classi, deve essere
-il nome dell'istanza della classe e non deve essere lo stesso del modulo.
-
-Per esempio, i metodi della classe `Session` sotto il modulo `session` devono
-usare `ses` come `nomeOggetto`.
-
-I parametri opzionali sono caratterizzati sia dalle parentesi quadre `[]` che
-circondano il parametro, sia dalla virgola obbligatoria in caso il parametro
-ne segua un altro.
-
-```
-required[, optional]
-```
-
-Sotto ogni metodo si trovano informazioni dettagliate su ogni parametro. Il tipo
-di parametro <20> caratterizzato da uno dei tipi di dati comuni:
-
-* [`String`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)
-* [`Number`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)
-* [`Object`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)
-* [`Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)
-* [`Boolean`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)
-* O da un tipo di dati personalizzato come [`WebContent`](api/web-content.md) di
-Electron
-
-Se un parametro o un metodo sono limitati a certe piattaforme, esse sono
-segnalate, dopo il tipo di dato, attraverso l'uso di una lista di elementi in
-corsivo e delimitati da uno spazio. I valori possono essere `macOS`,
-`Windows` e `Linux`.
-
-```markdown
-* `animate` Boolean (optional) _macOS_ _Windows_
-```
-
-I parametri di tipo `Array` devono specificare nella descrizione sottostante
-che elementi pu<70> contenere l'array.
-
-La descrizione per i parametri di tipo `Funzione` dovrebbero rendere chiaro come
-sia possibile chiamarli, ed elencare i tipi di parametri che vi saranno passati.
-
-### Eventi
-
-Il capitolo degli eventi deve seguire il seguente formato:
-
-```markdown
-### Evento: 'wake-up'
-
-Ritorna:
-
-* `time` String
-
-...
-```
-
-Il titolo pu<70> essere di livello `###` o `####` a seconda che sia di un evento di
-un modulo o di una classe.
-
-I parametri di un evento seguono le stesse regole di quelli dei metodi.
-
-### Propriet<65>
-
-Il capitolo delle propriet<65> deve seguire il seguente formato:
-
-```markdown
-### session.defaultSession
-
-...
-```
-
-Il titolo pu<70> essere di livello `###` o `####` a seconda che sia una propriet<65>
-di un metodo o di una classe.
-
-## Traduzioni della Documentazione
-
-Le traduzioni della documentazione di Electron si trovano nella cartella
-`docs-translations`.
-
-Per aggiungere un altro set (o set parziale):
-
-* Crea una sottocartella che abbia come nome il codice della lingua.
-* Traduci i file.
-* Aggiorna il file README.md dentro la cartella della lingua in modo che
-reindirizzi ai file che hai tradotto.
-* Aggiungi un collegamento alla cartella della traduzione nel [README](https://github.com/electron/electron#documentation-translations) principale di Electron.
-
-Nota che tutti i file nella cartella `docs-translations` devono includere solo
-i file tradotti. I file originali in inglese non devono essere copiati l<>.

docs-translations/jp/README.md

@@ -1,97 +0,0 @@
-使用している Electron のバージョンに応じたドキュメントを使うように確認してください。
-ドキュメントのバージョン番号はページの URL の一部になっています。
-そうでない場合、おそらくご使用の Electron のバージョンと互換性のない API 変更を含んだ development ブランチのドキュメントを使っているものと思われます。
-その場合、atom.io の [available versions](https://electron.atom.io/docs/) リストにある別のバージョンのドキュメントに切り替えることができます。また GitHub で閲覧している場合、"Switch branches/tags" ドロップダウンを開いて、バージョンに対応したタグを選ぶこともできます。
-
-_リンクになっていないリストは未翻訳のものです。_
-## FAQ
-
-頻繁に聞かれる質問がありますので、issueを作成する前にこれをチェックしてください。
-
-* [Electron FAQ](faq/electron-faq.md)
-
-## ガイド
-
-* [サポートするプラットフォーム](tutorial/supported-platforms.md)
-* [セキュリティ](tutorial/security.md)
-* [Electronのバージョン管理](tutorial/electron-versioning.md)
-* [アプリケーションの配布](tutorial/application-distribution.md)
-* [Mac App Store 提出ガイド](tutorial/mac-app-store-submission-guide.md)
-* Windows Store Guide (tutorial/windows-store-guide.md)
-* [アプリケーションのパッケージ化](tutorial/application-packaging.md)
-* [ネイティブのNodeモジュールを使用する](tutorial/using-native-node-modules.md)
-* [メインプロセスのデバッグ](tutorial/debugging-main-process.md)
-* [Selenium と WebDriverを使用する](tutorial/using-selenium-and-webdriver.md)
-* [DevTools エクステンション](tutorial/devtools-extension.md)
-* [Pepper Flashプラグインを使用する](tutorial/using-pepper-flash-plugin.md)
-* [Widevine CDMプラグインを使用する](tutorial/using-widevine-cdm-plugin.md)
-* [継続的インテグレーションシステムによるテスト(Travis, Jenkins)](tutorial/testing-on-headless-ci.md)
-* [キーボードショートカット](tutorial/keyboard-shortcuts.md)
-
-
-# チュートリアル
-
-* [クイックスタート](tutorial/quick-start.md)
-* [デスクトップ環境の統合](tutorial/desktop-environment-integration.md)
-* [オンライン/オフライン イベントの検知](tutorial/online-offline-events.md)
-
-## API リファレンス
-
-* [概要](api/synopsis.md)
-* [Process Object](api/process.md)
-* [サポートしているChromeコマンドラインスイッチ](api/chrome-command-line-switches.md)
-* [環境変数](api/environment-variables.md)
-
-### カスタムDOM要素:
-
-* [`File` Object](api/file-object.md)
-* [`<webview>` タグ](api/webview-tag.md)
-* [`window.open` 関数](api/window-open.md)
-
-### Main Processのモジュール:
-
-* [app](api/app.md)
-* [autoUpdater](api/auto-updater.md)
-* BrowserWindow (api/browser-window.md)
-    * [フレームの無いウィンドウ](api/frameless-window.md)
-* [contentTracing](api/content-tracing.md)
-* [dialog](api/dialog.md)
-* [globalShortcut](api/global-shortcut.md)
-* [ipcMain](api/ipc-main.md)
-* [Menu](api/menu.md)
-* [MenuItem](api/menu-item.md)
-* [powerMonitor](api/power-monitor.md)
-* [powerSaveBlocker](api/power-save-blocker.md)
-* [protocol](api/protocol.md)
-* [session](api/session.md)
-* [systemPreferences](api/system-preferences.md)
-* [Tray](api/tray.md)
-* webContents (api/web-contents.md)
-
-### Renderer Processのモジュール (Web Page):
-
-* [desktopCapturer](api/desktop-capturer.md)
-* [ipcRenderer](api/ipc-renderer.md)
-* [remote](api/remote.md)
-* [webFrame](api/web-frame.md)
-
-###  両方のProcessのモジュール :
-
-* [clipboard](api/clipboard.md)
-* [crashReporter](api/crash-reporter.md)
-* [nativeImage](api/native-image.md)
-* [screen](api/screen.md)
-* [shell](api/shell.md)
-
-## 開発
-
-
-* [コーディング規約](development/coding-style.md)
-* Source Code Directory Structure (development/source-code-directory-structure.md)
-* [NW.js(node-webkit) との技術的違い](development/atom-shell-vs-node-webkit.md)
-* Build System Overview (development/build-system-overview.md)
-* [ビルド方法(macOS)](development/build-instructions-osx.md)
-* Build Instructions (Windows) (development/build-instructions-windows.md)
-* [ビルド方法(Linux)](development/build-instructions-linux.md)
-* Debug Instructions (Windows) (development/debug-instructions-windows.md)
-* Setting Up Symbol Server in debugger (development/setting-up-symbol-server.md)

docs-translations/jp/api/accelerator.md

@@ -1,43 +0,0 @@
-# Accelerator
-
-acceleratorは、キーボードショートカットを示す文字列です。複数の修飾語句とキーコードを `+` 文字で結合します。
-
-例:
-
-* `Command+A`
-* `Ctrl+Shift+Z`
-
-## プラットフォームの留意点
-
-
-macOSでは`Command` キー、LinuxとWindowsでは`Control` キーを意味する`CommandOrControl`はいくつかのacceleratorを定義しますが、LinuxとWindowsでは、`Command` キーは何の効果もありません。
-
- `Super` キーは、WindowsとLinuxでは `Windows` キーに、macOSでは、`Cmd` キーに関連付けられます。
-
-## 提供されている修飾語句
-
-* `Command` (または、短く `Cmd`)
-* `Control` (または、短く `Ctrl`)
-* `CommandOrControl` (または、短く `CmdOrCtrl`)
-* `Alt`
-* `Shift`
-* `Super`
-
-## 提供されているキーコード
-
-* `0` to `9`
-* `A` to `Z`
-* `F1` to `F24`
-* `~`, `!`, `@`, `#`, `$`などの記号
-* `Plus`
-* `Space`
-* `Backspace`
-* `Delete`
-* `Insert`
-* `Return` (またはエイリアスで `Enter`)
-* `Up`と `Down`,`Left`、 `Right`
-* `Home` と `End`
-* `PageUp` と `PageDown`
-* `Escape` (または、短く `Esc`)
-* `VolumeUp`と `VolumeDown` 、 `VolumeMute`
-* `MediaNextTrack`と `MediaPreviousTrack`、 `MediaStop` 、 `MediaPlayPause`

docs-translations/jp/api/app.md

@@ -1,442 +0,0 @@
-# app
-
- `app` モジュールは、アプリケーションのライフサイクルコントロールを担います。
-
-次の例は、最後のウィンドウが閉じたときにアプリケーションを終了させる方法を示しています。
-
-```javascript
-const app = require('electron').app
-app.on('window-all-closed', function () {
-  app.quit()
-})
-```
-
-## イベント
-
-`app` オブジェクトは次のイベントを出力します。
-
-### イベント: 'will-finish-launching'
-
-アプリケーションの基礎起動が終わったときに出力されます。Windows と Linuxでは、 `will-finish-launching` イベントと`ready`イベントは同じです。macOSでは、`NSApplication`の `applicationWillFinishLaunching` 通知をに相当します。通常、`open-file`と`open-url` 用のリスナーの設定、クラッシュレポートの開始、自動アップデートをします。
-
-ほとんどの場合、 `ready` イベントハンドラーですべてをするべきです。
-
-### イベント: 'ready'
-
-Electronの初期化が終わった時に出力します。
-
-### イベント: 'window-all-closed'
-
-全てのウィンドウを閉じたときに出力します。
-
-このイベントは、アプリケーションが終了する予定ではないときのみ出力します。ユーザーが `Cmd + Q`を押したり、開発者が`app.quit()`をコールすると、Electronは最初にすべてのウィンドウをクローズしようとし、`will-quit`イベントを出力します。この場合、`window-all-closed`イベントは出力されません。
-
-### イベント: 'before-quit'
-
-戻り値:
-
-* `event` Event
-
-アプリケーションがウィンドウをクローズし始める前に出力します。`event.preventDefault()`をコールすると、アプリケーションを終了させる既定の挙動を止めることができます。
-
-### イベント: 'will-quit'
-
-戻り値:
-
-* `event` Event
-
-全てのウィンドウが閉じて、アプリケーションを終了するときに出力します。`event.preventDefault()`をコールすると、アプリケーションを終了させる既定の挙動を止めることができます。
-
-詳細は、`will-quit`イベント と `window-all-closed` イベントの違いは、`window-all-closed` イベントの説明を見てください。
-
-### イベント: 'quit'
-
-戻り値:
-
-* `event` Event
-* `exitCode` Integer
-
-アプリケーションが終了したときに出力されます。
-
-### イベント: 'open-file' _macOS_
-
-戻り値:
-
-* `event` Event
-* `path` String
-
-アプリケーションでファイルを開こうとしたときに出力します。アプリケーションがすでに起動し、OSがファイルを開くアプリケーションを再使用したいとき、`open-file`イベントは出力します。ファイルがdockにドロップアウトされ、アプリケーションがまだ起動していないときにも`open-file` は出力します。このケースを処理するために、アプリケーションの起動のかなり早い段階で、`open-file` イベントをリッスンして確認します（まだ `ready` イベントが出力する前に）。
-
-このイベントをハンドルしたいときには `event.preventDefault()` をコールすべきです。
-
-Windowsでは、ファイルパスを取得するために、 `process.argv` をパースする必要があります。
-
-### イベント: 'open-url' _macOS_
-
-戻り値:
-
-* `event` Event
-* `url` String
-
-アプリケーションでURLを開こうとしたときに出力されます。URLスキーマーは、アプリケーションが開くように登録しなければなりません。
-
-このイベントをハンドルしたい場合は、`event.preventDefault()`をコールすべきです。
-
-### イベント: 'activate' _macOS_
-
-戻り値:
-
-* `event` Event
-* `hasVisibleWindows` Boolean
-
-アプリケーションがアクティブになったときに出力されます。通常は、アプリケーションのドックアイコンをクリックしたときに発生します。
-
-### イベント: 'browser-window-blur'
-
-戻り値:
-
-* `event` Event
-* `window` BrowserWindow
-
-[browserWindow](browser-window.md) からフォーカスが外れたときに出力されます。
-
-### イベント: 'browser-window-focus'
-
-戻り値:
-
-* `event` Event
-* `window` BrowserWindow
-
-[browserWindow](browser-window.md) にフォーカスが当たったとき出力されます。
-
-### イベント: 'browser-window-created'
-
-戻り値:
-
-* `event` Event
-* `window` BrowserWindow
-
-新しい [browserWindow](browser-window.md) が作成されたときに出力されます。
-
-### イベント: 'certificate-error'
-
-戻り値:
-
-* `event` Event
-* `webContents` [WebContents](web-contents.md)
-* `url` URL
-* `error` String - The error code
-* `certificate` Object
-  * `data` Buffer - PEM encoded data
-  * `issuerName` String
-* `callback` Function
-
- `url` の  `certificate` 検証に失敗したときに発生します。証明書を信頼するために`event.preventDefault()` と `callback(true)`をコールして既定の動作を止める必要があります。
-
-```javascript
-app.on('certificate-error', (event, webContents, url, error, certificate, callback) => {
-  if (url === 'https://github.com') {
-    // Verification logic.
-    event.preventDefault()
-    callback(true)
-  } else {
-    callback(false)
-  }
-})
-```
-
-### イベント: 'select-client-certificate'
-
-戻り値:
-
-* `event` Event
-* `webContents` [WebContents](web-contents.md)
-* `url` URL
-* `certificateList` [Objects]
-  * `data` Buffer - PEM encoded data
-  * `issuerName` String - Issuer's Common Name
-* `callback` Function
-
-クライアント証明書が要求されたときに出力されます。
-
-`url` は、クライアント証明書を要求するナビゲーションエントリーに対応し、`callback` リストからエントリをフィルターしてコールするのに必要です。`event.preventDefault()` を使用して、アプリケーションの証明書ストアから最初の証明書を使用するのを止めることができます。
-
-```javascript
-app.on('select-client-certificate', function (event, webContents, url, list, callback) {
-  event.preventDefault()
-  callback(list[0])
-})
-```
-
-### イベント: 'login'
-
-Returns:
-
-* `event` Event
-* `webContents` [WebContents](web-contents.md)
-* `request` Object
-  * `method` String
-  * `url` URL
-  * `referrer` URL
-* `authInfo` Object
-  * `isProxy` Boolean
-  * `scheme` String
-  * `host` String
-  * `port` Integer
-  * `realm` String
-* `callback` Function
-
-`webContents` がベーシック認証をしようとしたときに出力されます。
-
-既定の動作ではすべての認証をキャンセルしたり、`event.preventDefault()` と `callback(username, password)` とを証明書でコールし既定の動作をとめてオーバーライドします。
-
-```javascript
-app.on('login', function (event, webContents, request, authInfo, callback) {
-  event.preventDefault()
-  callback('username', 'secret')
-})
-```
-
-### イベント: 'gpu-process-crashed'
-
-gpu プロセスがクラッシュしたときに出力されます。
-
-## メソッド
-
-`app` オブジェクトは次のメソッドを持ちます。
-
-**Note:** いくつかのメソッドは、特定のオペレーティングシステム向けに提供され、そのようにラベルで表示します。
-
-### `app.quit()`
-
-全てのウィンドウを閉じようとします。`before-quit`イベントは、最初に出力されます。すべてのウィンドウを閉じることに成功したら、`will-quit`イベントが出力され、既定では、アプリケーションが終了します。
-
-このメソッドは、全ての`beforeunload`と`unload`イベントハンドラは正確に発生することを保証されます。`beforeunload` イベントハンドラで、`false`を返すことでウィンドウの終了をキャンセルすることができます。
-
-### `app.exit(exitCode)`
-
-* `exitCode` Integer
-
-`exitCode`で今すぐ終了します。
-
-全てのウィンドウは、ユーザーに確認することなく、すぐに閉じ、`before-quit`と`will-quit` イベントは出力されません。
-
-### `app.getAppPath()`
-
-減殺のアプリケーションディレクトリを戻します。
-
-### `app.getPath(name)`
-
-* `name` String
-
-`name`に関連した特定のディレクトリやファイルへのパスを返します。失敗したら、`Error`をスローします。
-
-`name`で次のパスをリクエストできます。
-
-* `home` ユーザーのホームディレクトリ
-* `appData` 既定で示すユーザーごとのアプリケーションディレクトリ
-  * `%APPDATA%` Windows上
-  * `$XDG_CONFIG_HOME` or `~/.config` Linux上
-  * `~/Library/Application Support` macOS上
-* `userData` アプリの設定ファイルを格納するディレクトリで、既定では`appData` ディレクトリ配下のアプリ名ディレクトリです
-* `temp` 一時ディレクトリ
-* `exe` 現在の実行ファイル
-* `module` `libchromiumcontent` ライブラリ
-* `desktop` 現在のユーザーのデスクトップディレクトリ
-* `documents` ユーザーの "My Documents"用ディレクトリ
-* `downloads` ユーザーのダウンロード用ディレクトリ
-* `music` ユーザーのミュージック用ディレクトリ
-* `pictures` ユーザーのピクチャー用ディレクトリ
-* `videos` ユーザーのビデオ用ディレクトリ
-
-### `app.setPath(name, path)`
-
-* `name` String
-* `path` String
-
-`name`に関連した特定のディレクトリやファイルへの`path` を上書きします。存在しないパスを指定した場合、このメソッドがディレクトリを作成します。失敗したら、`Error`をスローします。
-
-`app.getPath`で、`name` で定義されたパスを上書きできます。
-
-既定では、webページのクッキーとキャッシュは`userData`ディレクトリ配下に格納できます。ロケーションを変更したい場合、 `app` モジュールの `ready` イベントが出力される前に`userData`パスを上書きする必要があります。
-
-### `app.getVersion()`
-
-ロードしたアプリケーションのバージョンを戻します。アプリケーションの `package.json`ファイルにversionが無ければ、現在のバンドルまたは実行ファイルのバージョンになります。
-
-### `app.getName()`
-
-現在のアプリケーション名を戻し、`package.json` ファイルのnameです。
-
-通常、 `package.json`の`name` フィールドは、短い小文字名で、npm module spec と一致します。通常、`productName`で、アプリケーションの大文字正式名を指定し、Electronでは`name`をそれで上書きます。
-
-### `app.getLocale()`
-
-現在のアプリケーションのロケールを戻します。
-
-### `app.addRecentDocument(path)` _macOS_ _Windows_
-
-* `path` String
-
-最近のドキュメント一覧に`path`を追加します。
-
-この一覧はOSが管理しています。Windowsではタスクバーからこの一覧を見れ、macOSではdockメニューから見れます。
-
-### `app.clearRecentDocuments()` _macOS_ _Windows_
-
-最近のドキュメント一覧をクリアします。
-
-### `app.setUserTasks(tasks)` _Windows_
-
-* `tasks` Array - `Task` オブジェクトの配列
-
-Windowsのジャンプリストの[Tasks][tasks]カテゴリに`tasks`を追加します。
-
-`tasks` は`Task`オブジェクトの配列で、次のフォーマットになります。
-
-`Task` Object:
-
-* `program` String - 実行するプログラムのパスで、通常はプログラムが開く`process.execPath`を指定します
-* `arguments` String - `program` を実行するときのコマンドライン引数です
-* `title` String - ジャンプリストに表示される文字列です
-* `description` String - タスクの説明
-* `iconPath` String - ジャンプリストに表示するアイコンの絶対パスで、アイコンを含む任意のリソースファイルです。通常、プログラムのアイコンを表示する`process.execPath`を指定します。
-* `iconIndex` Integer - アイコンファイルのアイコンインデックスです。アイコンファイルに2つ以上のアイコンが含まれている場合、この値でアイコンを指定します。1つしかアイコンファイルに含まれていない場合は、この値は0です。
-
-### `app.allowNTLMCredentialsForAllDomains(allow)`
-
-* `allow` Boolean
-
-HTTP NTLMまたはNegotiate認証用の照明を常に送信するかどうかを動的に設定できます。通常、Electronはローカルインターネットサイト（例えば、あなたと同じドメイン名のとき）に該当するURL用のNTLM/Kerberos証明書のみ送信します。しかし、この検知はコーポレートネットワークの設定が悪いときには、頻繁に失敗するので、この挙動を共通に行うことを選べば、全てのURLで有効にできます。
-
-### `app.makeSingleInstance(callback)`
-
-* `callback` Function
-
-このメソッドは、アプリケーションをシングルインスタンスアプリケーションにします。アプリの実行を複数のインスタンスで実行することを許可せず、アプリケーション実行をシングルインスタンスのみにすることを保証し、ほかのインスタンスにはこのインスタンスの存在を知らせ終了さえます。
-
-2つ目のインスタンスが起動したとき、`callback` は、`callback(argv, workingDirectory)` でコールします。`argv` は、2つ目のインスタンスのコマンドライン引数の配列で、`workingDirectory` は現在のワーキングディレクトリです。通常、アプリケーションはメインのウィンドウにフォーカスをあて最小化させないことで対応します。
-
-The `callback` は、 `app`の`ready` イベントの出力後に実行することを保証します。
-
-プロセスがアプリケーションのプライマリインスタンスでアプリがロードし続けるなら、このメソッドは `false`を戻します。プロセスがほかのインスタンスにパラメーターを送信し、`true`を戻すと、直ちに終了します。
-
-macOSは、ユーザーがFinderで2つ目のアプリインスタンスを開いたり、`open-file` 、 `open-url`イベントが出力しようとすると、システムが自動的にシングルインスタンスを強制します。しかし、コマンドラインでアプリを開始するとシステムのシングルインスタンスメカニズムは無視されるので、シングルインスタンスを強制するためには、このメソッドを使う必要があります。
-
-2つ目のインスタンスを起動するとき、メインのインスタンスのウィンドウをアクティブにする例
-
-```javascript
-var myWindow = null
-
-var shouldQuit = app.makeSingleInstance(function (commandLine, workingDirectory) {
-  // Someone tried to run a second instance, we should focus our window
-  if (myWindow) {
-    if (myWindow.isMinimized()) myWindow.restore()
-    myWindow.focus()
-  }
-  return true
-})
-
-if (shouldQuit) {
-  app.quit()
-}
-
-app.on('ready', function () {
-  // Create myWindow, load the rest of the app, etc...
-})
-```
-
-### `app.setAppUserModelId(id)` _Windows_
-
-* `id` String
-
-[Application User Model ID][app-user-model-id] を `id`に変更します。
-
-### `app.isAeroGlassEnabled()` _Windows_
-
-[DWM composition](https://msdn.microsoft.com/en-us/library/windows/desktop/aa969540.aspx)(Aero Glass) が有効なら、このメソッドは`true`を戻し、有効でなければ`false`を戻します。透明なウィンドウを作成する必要があるか、またはできないとき（DWM compositionが無効なとき用明なウィンドウは正しく動作しません）、このAPIを使うことができます。
-
-使用例:
-
-```javascript
-let browserOptions = {width: 1000, height: 800}
-
-// Make the window transparent only if the platform supports it.
-if (process.platform !== 'win32' || app.isAeroGlassEnabled()) {
-  browserOptions.transparent = true
-  browserOptions.frame = false
-}
-
-// Create the window.
-win = new BrowserWindow(browserOptions)
-
-// Navigate.
-if (browserOptions.transparent) {
-  win.loadURL(`file://${__dirname}/index.html`)
-} else {
-  // No transparency, so we load a fallback that uses basic styles.
-  win.loadURL(`file://${__dirname}/fallback.html`)
-}
-```
-
-### `app.commandLine.appendSwitch(switch[, value])`
-
-Chromiumのコマンドラインにスイッチ（ `value`をオプションにし）を追加します。
-
-**Note:** これは、`process.argv`に影響せず、開発者が、Chromiumのローレベルな挙動をコントロールするのに使用します。
-
-### `app.commandLine.appendArgument(value)`
-
-Chromiumのコマンドダインに引数を追加します。引数は正しく引用符で囲まれます。
-
-**Note:** `process.argv`に影響しません。
-
-### `app.dock.bounce([type])` _macOS_
-
-* `type` String (optional) - `critical` または `informational`を指定できます。既定では、 `informational`です。
-
-`critical`を渡すと、アプリケーションがアクティブ、もしくはリクエストがキャンセルされるまでは、dockアイコンは、バウンスします。
-
-`informational` を渡すと、1秒dockアイコンはバウンスします。しかし、アプリケーションがアクティブ、もしくはリクエストがキャンセルされるまでは、リクエストは残ります。
-
-リクエストを示すIDを戻します。
-
-### `app.dock.cancelBounce(id)` _macOS_
-
-* `id` Integer
-
-`id`のバウンスをキャンセルします。
-
-### `app.dock.setBadge(text)` _macOS_
-
-* `text` String
-
-dockのバッジエリアで表示する文字列を設定します。
-
-### `app.dock.getBadge()` _macOS_
-
-dockのバッジ文字列を戻します。
-
-### `app.dock.hide()` _macOS_
-
-dock アイコンを隠します。
-
-### `app.dock.show()` _macOS_
-
-dock アイコンを表示します。
-
-### `app.dock.setMenu(menu)` _macOS_
-
-* `menu` Menu
-
-アプリケーションの[dock menu][dock-menu]を設定します。
-
-### `app.dock.setIcon(image)` _macOS_
-
-* `image` [NativeImage](native-image.md)
-
-dock アイコンに紐づいた`image`を設定します。
-
-[dock-menu]:https://developer.apple.com/library/mac/documentation/Carbon/Conceptual/customizing_docktile/concepts/dockconcepts.html#//apple_ref/doc/uid/TP30000986-CH2-TPXREF103
-[tasks]:http://msdn.microsoft.com/en-us/library/windows/desktop/dd378460(v=vs.85).aspx#tasks
-[app-user-model-id]: https://msdn.microsoft.com/en-us/library/windows/desktop/dd378459(v=vs.85).aspx

docs-translations/jp/api/auto-updater.md

@@ -1,85 +0,0 @@
-# autoUpdater
-
-このモジュールは、`Squirrel`オートアップデートフレームワークのインターフェイスを提供します。
-
-## プラットフォーム留意点
-
-`autoUpdater`は、異なるプラットフォーム用に統一したAPIを提供していますが、それぞれのプラットフォーム上で、まだ多少の差があります。
-
-### macOS
-
-macOSでは、 `autoUpdater` モジュールは、[Squirrel.Mac][squirrel-mac]上に構築されていて、動作させるのに特別な設定が不要であることを意味します。サーバーサイドの要件は、[Server Support][server-support]を読んでください。
-
-### Windows
-
-Windowsでは、auto-updaterを使う前に、ユーザーのPCにアプリをインストールする必要があるので、Windows インストーラーを生成するために[grunt-electron-installer][installer]モジュールを使用することをお勧めします。
-
-Squirrelで生成されたインストーラーは、`com.squirrel.PACKAGE_ID.YOUR_EXE_WITHOUT_DOT_EXE`のフォーマット（例えば、`com.squirrel.slack.Slack` と `com.squirrel.code.Code`）で[Application User Model ID][app-user-model-id]とショートカットアイコンを作成します。`app.setAppUserModelId`APIで同じIDを使う必要があります。同じIDでないと、Windowsはタスクバーに適切にピン止めすることができません。
-
-サーバーサイドのセットアップは、macOSと異なります。詳細は、[Squirrel.Windows][squirrel-windows] を参照してください。
-
-### Linux
-
-Linuxでは、auot-updater用のサポートがビルトインされていないので、アプリをアップデートするためにディストリビューションのパッケージマネジャーを使用することをお勧めします。
-
-## イベント
-
-`autoUpdater` オブジェクトは次のイベントを出力します。
-
-### イベント: 'error'
-
-戻り値:
-
-* `error` Error
-
-アップデート中にエラーがあった場合に出力されます。
-
-### イベント: 'checking-for-update'
-
-アップデートを開始したかチェックしたときに出力されます。
-
-### イベント: 'update-available'
-
-アップデートが提供されているときに出力されます。アップデートは自動的にダウンロードされます。
-
-### イベント: 'update-not-available'
-
-アップデートが提供されていないときに出力されます。
-
-### イベント: 'update-downloaded'
-
-戻り値:
-
-* `event` Event
-* `releaseNotes` String
-* `releaseName` String
-* `releaseDate` Date
-* `updateURL` String
-
-アップデートをダウンロードしたときに出力されます。
-
-Windowsでは、`releaseName` のみ提供されます。
-
-## メソッド
-
-`autoUpdater` オブジェクトは次のメソッドを持っています。
-
-### `autoUpdater.setFeedURL(url)`
-
-* `url` String
-
- `url`を設定し、自動アップデートを初期化します。 `url`は一度設定すると変更できません。
-
-### `autoUpdater.checkForUpdates()`
-
-アップデートがあるかどうかサーバーに問い合わせます。APIを使う前に、`setFeedURL`をコールしなければなりません。
-
-### `autoUpdater.quitAndInstall()`
-
-ダウンロード後、アプリを再起動して、アップデートをインストールします。`update-downloaded`が出力された後のみ、コールすべきです。
-
-[squirrel-mac]: https://github.com/Squirrel/Squirrel.Mac
-[server-support]: https://github.com/Squirrel/Squirrel.Mac#server-support
-[squirrel-windows]: https://github.com/Squirrel/Squirrel.Windows
-[installer]: https://github.com/atom/grunt-electron-installer
-[app-user-model-id]: https://msdn.microsoft.com/en-us/library/windows/desktop/dd378459(v=vs.85).aspx

docs-translations/jp/api/chrome-command-line-switches.md

@@ -1,129 +0,0 @@
-#サポートしているChromeコマンドラインスイッチ
-
-> Electronでサポートされているコマンドラインスイッチ
-
-アプリケーションのメインスクリプトで[app.commandLine.appendSwitch][append-switch]を使うことで、[app][app]モジュールの[ready][ready]イベントが発行される前にコマンドラインスイッチを追加できます。
-
-```javascript
-const {app} = require('electron')
-app.commandLine.appendSwitch('remote-debugging-port', '8315')
-app.commandLine.appendSwitch('host-rules', 'MAP * 127.0.0.1')
-
-app.on('ready', () => {
-  // Your code here
-})
-```
-
-
-## --ignore-connections-limit=`domains`
-
-`domains`で指定されたリストは接続数制限を無視します。リストは`,`で区切られます。
-
-## --disable-http-cache
-
-HTTPリクエストのディスクキャッシュの無効化。
-
-## --disable-http2
-
-HTTP/2 と SPDY/3.1 プロトコルを無効にします。
-
-## --remote-debugging-port=`port`
-
-`port`で指定したHTTP越しのリモートデバッグの有効化。
-
-## --js-flags=`flags`
-
-JSエンジンに渡されるフラグの指定。メインプロセスで`flags`を有効化したいのなら、Electron開始時に渡される必要があります。
-
-```bash
-$ electron --js-flags="--harmony_proxies --harmony_collections" your-app
-```
-
-## --proxy-server=`address:port`
-
-システム設定を上書きし、指定したプロキシサーバーを使用します。HTTPS、WebSocketリクエストを含むHTTPプロトコルのリクエストのみに影響します。全てのプロキシサーバーがHTTPSとWebSocketリクエストに対応しているわけではないことに注意してください。
-
-## --proxy-bypass-list=`hosts`
-
-プロキシを使用しないサーバーをセミコロンで区切って指定します。
-このフラグは、`--proxy-server`と同時に使われるときのみに影響します。
-
-例:
-
-```javascript
-app.commandLine.appendSwitch('proxy-bypass-list', '<local>;*.google.com;*foo.com;1.2.3.4:5678')
-```
-
-ローカルアドレス（`localhost`や`127.0.0.1`など）、`google.com`サブドメイン、`foo.com` サフィックスを含むホスト、`1.2.3.4:5678`を除いてすべてのホストでプロキシサーバーが使われます。
-
-## --proxy-pac-url=`url`
-
-`url`で指定したPACスクリプトが使われます。
-
-## --no-proxy-server
-
-プロキシサーバーを使わず、常に直接接続します。ほかのプロキシサーバーフラグを上書きします。
-
-## --host-rules=`rules`
-
-ホスト名がどのようにマップされているかを制御するコンマで分割された`rules`一覧
-
-例:
-
-* `MAP * 127.0.0.1` 全てのホスト名を127.0.0.1にマッピングするよう強制します。
-* `MAP *.google.com proxy` すべてのgoogle.comサブドメインを "proxy"で解決するよう強制します。
-* `MAP test.com [::1]:77` "test.com"をIPv6ループバックで解決するよう強制します。結果ポートのをソケットアドレス77番にするよう強制します。
-* `MAP * baz, EXCLUDE www.google.com` 全てを"baz"に再マッピングし、  "www.google.com"は除外します。
-
-これらのマッピングは、ネットリクエスト（直接接続で、TCP接続とホスト解決とHTTPプロキシ接続での`CONNECT`、`SOCKS`プロキシ接続でのエンドポイントホスト）でエンドポイントホストに適用されます。
-
-## --host-resolver-rules=`rules`
-
-`--host-rules`のようですが、`rules` はホスト解決のみに適用されます。
-
-## --ignore-certificate-errors
-
-証明書関連エラーを無視します。
-
-## --ppapi-flash-path=`path`
-
-pepper flash pluginの`path`を設定します。
-
-## --ppapi-flash-version=`version`
-
-pepper flash pluginの`version`を設定します。
-
-## --log-net-log=`path`
-
-ネットログイベントを保存し、`path`に書き込みを有効化します。
-
-## --disable-renderer-backgrounding
-
-不可視のページのレンダラープロセスの優先度を下げることからChromiumを防ぎます。
-
-このフラグは、グローバルですべてのレンダラープロセスに有効で、一つのウィンドウだけで無効化したい場合、[無音を再生する][play-silent-audio]というハックで対応します。
-
-## --enable-logging
-
-コンソールにChromiumのログを出力します。
-
-ユーザーのアプリが読み込まれる前に解析されるため、`app.commandLine.appendSwitch`では使用できませんが、`ELECTRON_ENABLE_LOGGING`を環境変数に設定すると同じ効果を得ることができます。
-
-## --v=`log_level`
-
-標準のloggingレベルを設定します。0が既定です。通常、V-loggingレベルには正の値が使用されます。
-
-`--enable-logging` が渡された時だけ、このスイッチは動作します。
-
-## --vmodule=`pattern`
-
-`--v`で付与された値を上書きするために、モジュール毎の最大V-loggingレベルを付与します。例えば、 `my_module=2,foo*=3` は、`my_module.*` と `foo*.*`のソースファイル全てのロギングレベルを変更します。
-
-前方または後方スラッシュを含む任意のパターンは、全体のパス名だけでなく、モジュールに対してもテストとされます。例えば、`*/foo/bar/*=2`は`foo/bar`ディレクトリ下のソースファイルですべてのコードのロギングレベルを変更します。
-
-このスイッチは、`--enable-logging`が渡された時のみ動作します。
-
-[app]: app.md
-[append-switch]: app.md#appcommandlineappendswitchswitch-value
-[ready]: app.md#event-ready
-[play-silent-audio]: https://github.com/atom/atom/pull/9485/files

docs-translations/jp/api/clipboard.md

@@ -1,103 +0,0 @@
-# clipboard
-
-`clipboard`モジュールは、コピーとペースト操作を実行するメソッドを提供します。次の例は、クリップボードに文字列を書き込む方法を示しています：
-
-```javascript
-const clipboard = require('electron').clipboard
-clipboard.writeText('Example String')
-```
-
-X Windowsシステム上では、セレクションクリップボードがあります。それを操作するために、それぞれのメソッドで、`selection`を通す必要があります。
-
-```javascript
-clipboard.writeText('Example String', 'selection')
-console.log(clipboard.readText('selection'))
-```
-
-## メソッド
-
-`clipboard`モジュールには、次のメソッドがあります:
-
-**Note:** 実験的APIには、そのようにマークしてあり、将来的には削除される可能性があります。
-
-### `clipboard.readText([type])`
-
-* `type` String (optional)
-
-プレーンテキストとしてクリップボードの内容を返します。
-
-### `clipboard.writeText(text[, type])`
-
-* `text` String
-* `type` String (optional)
-
-プレーンテキストとしてクリップボードに`text`を書き込みます。
-
-### `clipboard.readHTML([type])`
-
-* `type` String (optional)
-
-HTMLマークアップとして、クリップボードの内容を返します。
-
-### `clipboard.writeHTML(markup[, type])`
-
-* `markup` String
-* `type` String (optional)
-
-クリップボードにHTMLマークアップとして書き込みます。
-
-### `clipboard.readImage([type])`
-
-* `type` String (optional)
-
-[NativeImage](native-image.md)としてクリップボードの内容を返します。
-
-### `clipboard.writeImage(image[, type])`
-
-* `image` [NativeImage](native-image.md)
-* `type` String (optional)
-
-`image` としてクリップボードに書き込みます。
-
-### `clipboard.clear([type])`
-
-* `type` String (optional)
-
-クリップボードの内容をクリアします。
-
-### `clipboard.availableFormats([type])`
-
-* `type` String (optional)
-
-`type`のクリップボードがサポートしているフォーマット配列を返します。
-
-### `clipboard.has(data[, type])` _実験_
-
-* `data` String
-* `type` String (optional)
-
-`data`で指定したフォーマットをクリップボードがサポートしているかどうかを返します。
-
-```javascript
-console.log(clipboard.has('<p>selection</p>'))
-```
-
-### `clipboard.read(data[, type])` _実験_
-
-* `data` String
-* `type` String (optional)
-
-クリップボードから`data`を読み込みます。
-
-### `clipboard.write(data[, type])`
-
-* `data` Object
-  * `text` String
-  * `html` String
-  * `image` [NativeImage](native-image.md)
-* `type` String (optional)
-
-```javascript
-clipboard.write({text: 'test', html: '<b>test</b>'})
-```
-クリップボードに`data`を書き込みます。

docs-translations/jp/api/content-tracing.md

@@ -1,117 +0,0 @@
-# contentTracing
-
-`content-tracing`モジュールは、Chromiumコンテンツモジュールによって生成されるトーレスデータを収集するのに使われます。このモジュールはウェブインターフェイスを含んでいないので、Chromeブラウザーで `chrome://tracing/`を開いて、結果を表示するために生成されたファイルを読み込む必要があります。
-
-```javascript
-const contentTracing = require('electron').contentTracing
-
-const options = {
-  categoryFilter: '*',
-  traceOptions: 'record-until-full,enable-sampling'
-}
-
-contentTracing.startRecording(options, function () {
-  console.log('Tracing started')
-
-  setTimeout(function () {
-    contentTracing.stopRecording('', function (path) {
-      console.log('Tracing data recorded to ' + path)
-    })
-  }, 5000)
-})
-```
-
-## メソッド
-
-`content-tracing`モジュールは次のメソッドを持っています。
-
-### `contentTracing.getCategories(callback)`
-
-* `callback` Function
-
-カテゴリグループ一式を取得します。新しいコードパスに到達しているとしてカテゴリグループを変更できます。
-
-一度、全ての子プロセスが`getCategories`リクエストを認識すると、カテゴリグループの配列で`callback`が呼び出されます。
-
-### `contentTracing.startRecording(options, callback)`
-
-* `options` Object
-  * `categoryFilter` String
-  * `traceOptions` String
-* `callback` Function
-
-全てのプロセスで記録を開始します。
-
-EnableRecordingリクエストを受信するとすぐに、子プロセス上でただちに非同期にローカルに記録を始めます。全ての子プロセスが`startRecording`リクエストを認識すると、`callback`が呼び出されます。
-
-`categoryFilter`はどのカテゴリグループをトレースすべきかをフィルタリングします。フィルターは、マッチしたカテゴリーを含むカテゴリグループを除外する`-`プレフィックスをオプションうぃ持っています。同じリストでの、対象カテゴリパターンと、除外カテゴリーパターンの両方を持つことはサポートしていません。
-
-例:
-
-* `test_MyTest*`,
-* `test_MyTest*,test_OtherStuff`,
-* `"-excluded_category1,-excluded_category2`
-
-`traceOptions` は、どの種類のトレースを有効にするかを制御し、コンマ区切りのリストです。
-
-取りうるオプション:
-
-* `record-until-full`
-* `record-continuously`
-* `trace-to-console`
-* `enable-sampling`
-* `enable-systrace`
-
-最初の3つのオプションは、トレースの記録モードで、そのため相互排他的です。`traceOptions`文字列に1つ以上のトレース記録モードが現れると、最後のモードが優先されます。トレース記録モードが指定されていない場合、記録モードは、`record-until-full`です。
-
-適用される`traceOptions`からオプションをパースする前に、トレースオプションは最初に既定のオプションにリセットされます（`record_mode`は、`record-until-full`を設定し、 `enable_sampling`と `enable_systrace` は `false`に設定します）。
-
-### `contentTracing.stopRecording(resultFilePath, callback)`
-
-* `resultFilePath` String
-* `callback` Function
-
-全てのプロセスで記録を止めます。
-
-子プロセスは基本的にトレースデータをキャッシュし、まれにフラッシュし、メインプロセスにトレースデータを送り返します。IPC越しにトレースデータを送信するのは高コストな操作なので、トレースのランタイムオーバーヘッドを最小限にするのに役立ちます。トレースが終了すると、保留されているトレースデータのフラッシュをするためにすべての子プロセスに非道に問い合わせすべきです。
-
-
-一度、すべての子プロセスが`stopRecording` リクエストを認識すると、トレースデータを含んだファイルで`callback`が呼び出されます。
-
-トレースデータは`resultFilePath`が空でなければ、そこに書き込まれ、空の場合は一時ファイルに書き込まれます。実際のファイルパスは`null`でなければ `callback` に通します。
-
-### `contentTracing.startMonitoring(options, callback)`
-
-* `options` Object
-  * `categoryFilter` String
-  * `traceOptions` String
-* `callback` Function
-
-全てのプロセス上で監視を開始します。
-
-`startMonitoring`リクエスト受信するとすぐに、子プロセス上でローカルに非同期にただちに監視を始めます。
-
-全ての子プロセスが`startMonitoring`リクエストを認識すると、`callback`がコールされます。
-
-### `contentTracing.stopMonitoring(callback)`
-
-* `callback` Function
-
-全てのプロセス上で監視を止めます。
-
-全ての子プロセスが`stopMonitoring`リクエスト認識すると、`callback`がコールされます。
-
-### `contentTracing.captureMonitoringSnapshot(resultFilePath, callback)`
-
-* `resultFilePath` String
-* `callback` Function
-
-現在の監視トレースデータを取得します。子プロセスは基本的にトレースデータをキャッシュし、まれにフラッシュし、メインプロセスにトレースデータを送り返します。IPC越しにトレースデータを送信するのは高コストな操作なので、トレースによる不必要なランタイムオーバーヘッドを避けるます。トレースが終了するために、保留されているトレースデータのフラッシュをするためにすべての子プロセスに非道に問い合わせすべきです。
-
-全ての子プロセスが`captureMonitoringSnapshot`リクエストを認識すると、トレースデータを含んだファイルで`callback`が呼び出されます。
-
-### `contentTracing.getTraceBufferUsage(callback)`
-
-* `callback` Function
-
-プロセスのトレースバッファのプロセス間で最大使用量をフルの状態の何%かで取得します。TraceBufferUsage値が設定されていると、 `callback`がコールされます。

docs-translations/jp/api/crash-reporter.md

@@ -1,66 +0,0 @@
-# crashReporter
-
-`crash-reporter`モジュールはアプリのクラッシュレポートを送信することができます。
-
-リモートサーバーに自動的にクラッシュレポートを登録する例です。
-
-```javascript
-const crashReporter = require('electron').crashReporter
-
-crashReporter.start({
-  productName: 'YourName',
-  companyName: 'YourCompany',
-  submitURL: 'https://your-domain.com/url-to-submit',
-  autoSubmit: true
-})
-```
-
-## メソッド
-
-`crash-reporter`モジュールは次のメソッドを持ちます:
-
-### `crashReporter.start(options)`
-
-`options` Object, properties:
-
-* `productName` String, デフォルト: Electron.
-* `companyName` String (**必須**)
-* `submitURL` String, (**必須**)
-  * クラッシュレポートがPOSTで送信されるURL
-* `autoSubmit` Boolean, デフォルト: `true`.
-  * ユーザーの判断なくクラッシュレポートを送信します
-* `ignoreSystemCrashHandler` Boolean, デフォルト: `false`.
-* `extra` Object
-  * あなたが定義できるオブジェクトは、レポートと一緒に送信されます。
-  * 文字列プロパティのみが正しく送信されます。
-  * オブジェクトのネストはサポートしていません。
-
-他の`crashReporter`APIを使用する前にこのメソッドをコールする必要があります。
-
-**Note:** macOSでは、Electronは、WindowsとLinux上の`breakpad` とは異なる、新しい`crashpad`クライアントを使用します。クラッシュ収集機能を有効にするために、メインプロセスや、クラッシュレポートを収集したいそれぞれのレンダラープロセスで、`crashpad`を初期化するために`crashReporter.start`APIをコールする必要があります。
-
-### `crashReporter.getLastCrashReport()`
-
-日付と最後のクラッシュレポートのIDを返します。もしなんのクラッシュレポートも送信されていないか、クラッシュレポーターが起動していない場合、`null`を返します。
-
-### `crashReporter.getUploadedReports()`
-
-すべてのアップロードされたクラッシュレポートが返されます。それぞれのレポートには日付とアップロードされたIDが含まれます。
-
-## crash-reporter Payload
-
-クラッシュレポーターは`POST`で`submitURL` に次のデーターが送信されます。
-
-* `ver` String - Electronのバージョン
-* `platform` String - 例： 'win32'.
-* `process_type` String - 例： 'renderer'.
-* `guid` String - 例： '5e1286fc-da97-479e-918b-6bfb0c3d1c72'
-* `_version` String - `package.json`でのバージョン
-* `_productName` String - `crashReporter`でのプロダクト名 `オプション`
-  object.
-* `prod` String - 基盤となる製品の名前。この場合は、Electronです。
-* `_companyName` String - `crashReporter`での会社名 `オプション`
-  object.
-* `upload_file_minidump` File - ファイル形式のクラッシュレポート
-* `crashReporter`での`extra`オブジェクトのすべてのレベル1のプロパティ
-  `オプション` object

docs-translations/jp/api/desktop-capturer.md

@@ -1,65 +0,0 @@
-# desktopCapturer
-
-`desktopCapturer`モジュールは`getUserMedia`でキャプチャーするのに使える利用可能なソースを取得するのに使われます。
-
-```javascript
-// In the renderer process.
-var desktopCapturer = require('electron').desktopCapturer
-
-desktopCapturer.getSources({types: ['window', 'screen']}, function (error, sources) {
-  if (error) throw error
-  for (var i = 0; i < sources.length; ++i) {
-    if (sources[i].name === 'Electron') {
-      navigator.webkitGetUserMedia({
-        audio: false,
-        video: {
-          mandatory: {
-            chromeMediaSource: 'desktop',
-            chromeMediaSourceId: sources[i].id,
-            minWidth: 1280,
-            maxWidth: 1280,
-            minHeight: 720,
-            maxHeight: 720
-          }
-        }
-      }, gotStream, getUserMediaError)
-      return
-    }
-  }
-})
-
-function gotStream (stream) {
-  document.querySelector('video').src = URL.createObjectURL(stream)
-}
-
-function getUserMediaError (e) {
-  console.log('getUserMediaError')
-}
-```
-
-`navigator.webkitGetUserMedia`用の制限されたオブジェクトコールを作成し、`desktopCapturer`からソースを使用するのなら、`chromeMediaSource`は`"desktop"`を設定し、`audio`は`false`を設定しなければなりません。
-
-全てのデスクトップから音とビデオをキャプチャーしたいなら、`chromeMediaSource``"screen"`、`audio` に `true`.を設定します。このメソッドを使うとき、`chromeMediaSourceId`は指定できません。
-
-## メソッド
-
-`desktopCapturer`モジュールは次のメソッドを持ちます。
-
-### `desktopCapturer.getSources(options, callback)`
-
-* `options` Object
-  * `types` Array - キャプチャーされるデスクトップソースの種類一覧の文字列配列で、 提供される種類は`screen` と `window`です。
-  * `thumbnailSize` Object (オプション) - サムネイルがスケールすべきサイズの指定で、既定では`{width: 150, height: 150}` です。
-* `callback` Function
-
-全てのデスクトップソールを取得するためのリクエストを開始し、リクエストが完了すると、`callback`は`callback(error, sources)` でコールされます。
-
-`sources`は、`Source`オブジェクトの配列で、それぞれの`Source`はキャプチャーしたスクリーンか、1つのウィンドウを示し、次のプロパティを持ちます。
-
-
-* `id` String - The id of the captured window or screen used in
-  `navigator.webkitGetUserMedia`で使われるキャプチャーしたウィンドウか画面のidです。`window:XX` か`screen:XX`のようなフォーマットで、`XX`はランダムに生成された数字です。
-* `name` String - キャプチャーする画面かウィンドウの説明名ソースが画面なら名前は`Entire Screen`で、`Screen <index>`はウィンドウで、名前はウィンドウのタイトルです。
-* `thumbnail` [NativeImage](NativeImage.md) - サムネイル画像
-
-**Note:**  `source.thumbnail`のサイズはいつも`options`の`thumnbailSize`と同じ保証はありません。画面またはウィンドウのサイズに依存します。

docs-translations/jp/api/dialog.md

@@ -1,87 +0,0 @@
-# dialog
-
-`dialog`モジュールは、ファイルやアラートを開くようなネイティブシステムダイアログを表示するためのAPIを提供します。そのため、ネイティブアプリケーションのようにウェブアプリケーションに同じユーザー体験を提供できます。
-
-複数のファイルやディレクトリを選択するためのダイアログを表示する例です:
-
-```javascript
-const {dialog} = require('electron')
-console.log(dialog.showOpenDialog({properties: ['openFile', 'openDirectory', 'multiSelections']}))
-```
-
-**Note for macOS**: シートとしてダイアログを表示したい場合、唯一しなければならないことは、`browserWindow`パラメーターを参照する`BrowserWindow`を提供することです。
-
-## メソッド
-
-`dialog`モジュールは次のメソッドを持っています:
-
-### `dialog.showOpenDialog([browserWindow, ]options[, callback])`
-
-* `browserWindow` BrowserWindow (オプション)
-* `options` Object
-  * `title` String
-  * `defaultPath` String
-  * `filters` Array
-  * `properties` Array - ダイアログが使うべき機能を含め、`openFile`と`openDirectory`、`multiSelections`、`createDirectory`を含められます。
-* `callback` Function (オプション)
-
-成功したら、このメソッドはユーザーが選択したファイルパスの配列を返し、さうでなければ`undefined`を返します。
-
-ユーザーが選択できる種類を制限したいときに、`filters`で表示したり選択できるファイル種別の配列を指定します。
-
-```javascript
-{
-  filters: [
-    { name: 'Images', extensions: ['jpg', 'png', 'gif'] },
-    { name: 'Movies', extensions: ['mkv', 'avi', 'mp4'] },
-    { name: 'Custom File Type', extensions: ['as'] },
-    { name: 'All Files', extensions: ['*'] }
-  ]
-}
-```
-
-`extensions`配列は、ワイルドカードやドットなしで拡張子を指定すべきです（例えば、`'png'`は良いですが、`'.png'` と `'*.png'`はダメです）。すべてのファイルを表示するために、`'*'`ワイルドカードを使用します（それいがいのワイルドカードはサポートしていません）。
-
-`callback`を通すと、APIは非同期に読み出し、結果は`callback(filenames)`経由で通します。
-
-**Note:** WindowsとLinuxでは、オープンダイアログがファイル選択とディレクトリ選択の両方を選択することはできません。プラットフォーム上で `properties`に`['openFile', 'openDirectory']`を設定すると、ディレクトリ選択が表示されます。
-
-### `dialog.showSaveDialog([browserWindow, ]options[, callback])`
-
-* `browserWindow` BrowserWindow (オプション)
-* `options` Object
-  * `title` String
-  * `defaultPath` String
-  * `filters` Array
-* `callback` Function (オプション)
-
-成功すると、このメソッドはユーザーが選択したファイルのパスが返され、そうでなければ`undefined`が返されます。
-
-`filters`が表示できるファイル種別配列を指定します。例えば、`dialog.showOpenDialog`を参照してください。
-
-`callback`を通すと、APIは非同期でコールされ、結果は`callback(filename)`経由で通します。
-
-### `dialog.showMessageBox([browserWindow, ]options[, callback])`
-
-* `browserWindow` BrowserWindow (オプション)
-* `options` Object
-  * `type` String - `"none"`と `"info"`、 `"error"`、 `"question"`、`"warning"`を設定できます。Windowsでは、 "icon"オプションを使用してアイコンを設定しない限り、"question"は"info"として同じアイコンを表示します。
-  * `buttons` Array - ボタン用のテキスト配列。
-  * `defaultId` Integer - メッセージボックスを開くとき、既定で選択されるボタン配列でのボタンインデックスです
-  * `title` String - メッセージボックスのタイトルで、いくつかのプラットフォームでは表示されません。
-  * `message` String - メッセージボックスのコンテンツ。
-  * `detail` String - メッセージの外部情報
-  * `icon` [NativeImage](native-image.md)
-  * `cancelId` Integer - ダイアログのボタンをクリックする代わりにユーザーがダイアログをキャンセルしたときに返す値です。既定では、ラベルの "cancel"や"no"を持つボタンのインデックスまたは、そのようなボタンが無ければ0を返します。macOSやWindowsでは、 すでに指定されているかどうかは関係なく、"Cancel"ボタンのインデックスはいつでも `cancelId`が使われます。
-  * `noLink` Boolean - Windowsでは、Electronは、 ("Cancel" または "Yes"のような)共通ボタンである`buttons`の一つを見つけようとし、ダイアログ内のコマンドリンクとして表示します。この挙動が気に入らない場合は、 `noLink` を `true`に設定できます。
-* `callback` Function
-
-メッセージボックスを表示し、メッセージボックスが閉じるまでプロセスをブロックします。クリックされたボタンのインデックスを返します。
-
-`callback`が通されると、APIは非同期にコールし、結果は`callback(response)`経由で通されます。
-
-### `dialog.showErrorBox(title, content)`
-
-エラーメッセージを表示するモデルダイアログを表示します。
-
- `app`モジュールが`ready`イベントを出力する前に、このAPIは安全にコールできます。スタートアップの早い段階でエラーを報告するのに通常は使われます。Linuxで、アプリの`ready`イベントの前にコールすると、メッセージは標準エラーに出力され、GUIダイアログは表示されません。

docs-translations/jp/api/download-item.md

@@ -1,101 +0,0 @@
-# DownloadItem
-
-`DownloadItem`は、Electronでアイテムのダウンロードを示すEventEmitterです。 `Session`モジュールの`will-download`イベントで使用され、ダウンロードしたアイテムをコントロールすることができます。
-
-```javascript
-// In the main process.
-const {BrowserWindow} = require('electron')
-let win = new BrowserWindow()
-win.webContents.session.on('will-download', (event, item, webContents) => {
-  // Set the save path, making Electron not to prompt a save dialog.
-  item.setSavePath('/tmp/save.pdf')
-
-  item.on('updated', (event, state) => {
-    if (state === 'interrupted') {
-      console.log('Download is interrupted but can be resumed')
-    } else if (state === 'progressing') {
-      if (item.isPaused()) {
-        console.log('Download is paused')
-      } else {
-        console.log(`Received bytes: ${item.getReceivedBytes()}`)
-      }
-    }
-  })
-  item.once('done', (event, state) => {
-    if (state === 'completed') {
-      console.log('Download successfully')
-    } else {
-      console.log(`Download failed: ${state}`)
-    }
-  })
-})
-```
-
-## イベント
-
-### イベント: 'updated'
-
-`downloadItem`が更新されたときに出力されます。
-
-### イベント: 'done'
-
-* `event` Event
-* `state` String
-  * `completed` - ダウンロードが成功で完了
-  * `cancelled` - ダウンロードをキャンセル
-  * `interrupted` - ファイルサーバーとの接続が切れてエラー
-
-ダウンロードが終了状態になったときに出力されます。終了状態には、ダウンロードの完了、ダウンロードのキャンセル（`downloadItem.cancel()`経由）、レジュームできないダウンロードの中断などです。
-
-## メソッド
-
-`downloadItem`オブジェクトは次のメソッドを持ちます:
-
-### `downloadItem.setSavePath(path)`
-
-* `path` String - ダウンロードアイテムの保存ファイルパスを設定します。
-
-APIはセッションの`will-download`コールバック関数のみで提供されます。API経由で保存パスを設定しなかった場合、Electronは保存パスを決めるための元のルーチン（通常は保存ダイアログ）を使用します。
-
-### `downloadItem.pause()`
-
-ダウンロードをポーズします。
-
-### `downloadItem.resume()`
-
-ポーズしたダウンロードを再開します。
-
-### `downloadItem.cancel()`
-
-ダウンロード操作をキャンセルします。
-
-### `downloadItem.getURL()`
-
-どのURLからアイテムをダウンロードするのかを示す`String`を返します。
-
-### `downloadItem.getMimeType()`
-
-mimeタイプを示す`String`を返します。
-
-### `downloadItem.hasUserGesture()`
-
-ダウンロードがユーザージェスチャーを持っているかどうかを示す`Boolean`を返します。
-
-### `downloadItem.getFilename()`
-
-ダウンロードアイテムのファイル名を示す`String`を返します。
-
-**Note:** ファイル名はローカルディスクに実際に保存するものといつも同じとは限りません。ダウンロード保存ダイアログでユーザーがファイル名を変更していると、保存するファイルの実際の名前は異なります。
-
-### `downloadItem.getTotalBytes()`
-
-ダウンロードアイテムの合計バイトサイズを示す`Integer`を返します。
-サイズが不明な場合、0を返します。
-
-### `downloadItem.getReceivedBytes()`
-
-ダウンロードしたアイテムの受信バイト数を示す`Integer`を返します。
-
-### `downloadItem.getContentDisposition()`
-
-レスポンスヘッダーからContent-Dispositionを示す`String`を返します。