'lib_sources': [
'atom/app/atom_content_client.cc',
'atom/app/atom_content_client.h',
+ 'atom/app/atom_main_args.cc',
+ 'atom/app/atom_main_args.h',
'atom/app/atom_main_delegate.cc',
'atom/app/atom_main_delegate.h',
'atom/app/atom_main_delegate_mac.mm',
#include "atom/app/atom_library_main.h"
+#include "atom/app/atom_main_args.h"
#include "atom/app/atom_main_delegate.h"
#include "atom/app/node_main.h"
#include "base/at_exit.h"
content::ContentMainParams params(&delegate);
params.argc = argc;
params.argv = argv;
+ atom::AtomCommandLine::Init(argc, argv);
return content::ContentMain(params);
}
// found in the LICENSE file.
#include "atom/app/atom_main.h"
+#include "atom/app/atom_main_args.h"
#include <stdlib.h>
#include <string.h>
freopen_s(&dontcare, "CON", "r", stdin);
}
- std::string node_indicator, crash_service_indicator;
- if (env->GetVar("ATOM_SHELL_INTERNAL_RUN_AS_NODE", &node_indicator) &&
- node_indicator == "1") {
- // Convert argv to to UTF8
- char** argv = new char*[argc];
- for (int i = 0; i < argc; i++) {
- // Compute the size of the required buffer
- DWORD size = WideCharToMultiByte(CP_UTF8,
+ // Convert argv to to UTF8
+ char** argv = new char*[argc];
+ for (int i = 0; i < argc; i++) {
+ // Compute the size of the required buffer
+ DWORD size = WideCharToMultiByte(CP_UTF8,
+ 0,
+ wargv[i],
+ -1,
+ NULL,
+ 0,
+ NULL,
+ NULL);
+ if (size == 0) {
+ // This should never happen.
+ fprintf(stderr, "Could not convert arguments to utf8.");
+ exit(1);
+ }
+ // Do the actual conversion
+ argv[i] = new char[size];
+ DWORD result = WideCharToMultiByte(CP_UTF8,
0,
wargv[i],
-1,
- NULL,
- 0,
+ argv[i],
+ size,
NULL,
NULL);
- if (size == 0) {
- // This should never happen.
- fprintf(stderr, "Could not convert arguments to utf8.");
- exit(1);
- }
- // Do the actual conversion
- argv[i] = new char[size];
- DWORD result = WideCharToMultiByte(CP_UTF8,
- 0,
- wargv[i],
- -1,
- argv[i],
- size,
- NULL,
- NULL);
- if (result == 0) {
- // This should never happen.
- fprintf(stderr, "Could not convert arguments to utf8.");
- exit(1);
- }
+ if (result == 0) {
+ // This should never happen.
+ fprintf(stderr, "Could not convert arguments to utf8.");
+ exit(1);
}
- // Now that conversion is done, we can finally start.
+ }
+
+ std::string node_indicator, crash_service_indicator;
+ if (env->GetVar("ATOM_SHELL_INTERNAL_RUN_AS_NODE", &node_indicator) &&
+ node_indicator == "1") {
+ // Now that argv conversion is done, we can finally start.
base::i18n::InitializeICU();
return atom::NodeMain(argc, argv);
} else if (env->GetVar("ATOM_SHELL_INTERNAL_CRASH_SERVICE",
content::ContentMainParams params(&delegate);
params.instance = instance;
params.sandbox_info = &sandbox_info;
+ atom::AtomCommandLine::Init(argc, argv);
return content::ContentMain(params);
}
content::ContentMainParams params(&delegate);
params.argc = argc;
params.argv = argv;
+ atom::AtomCommandLine::Init(argc, argv);
return content::ContentMain(params);
}
--- /dev/null
+// Copyright (c) 2013 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/app/atom_main_args.h"
+
+namespace atom {
+
+ void AtomCommandLine::Init(int argc,
+ const char* const* argv) {
+ for (int i = 0; i < argc; ++i) {
+ argv_.push_back(argv[i]);
+ }
+ }
+
+ std::vector<std::string> AtomCommandLine::argv_;
+
+} // namespace atom
--- /dev/null
+// Copyright (c) 2015 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_APP_ATOM_MAIN_ARGS_H_
+#define ATOM_APP_ATOM_MAIN_ARGS_H_
+
+#include <string>
+#include <vector>
+
+#include "base/logging.h"
+
+namespace atom {
+
+class AtomCommandLine {
+ public:
+ static void Init(int argc, const char* const* argv);
+ static std::vector<std::string> argv() { return argv_; }
+
+ private:
+ static std::vector<std::string> argv_;
+
+ DISALLOW_COPY_AND_ASSIGN(AtomCommandLine);
+};
+
+} // namespace atom
+
+#endif // ATOM_APP_ATOM_MAIN_ARGS_H_
# we need to restore it here.
process.argv.splice 1, 1
-# Pick out switches appended by atom-shell.
-startMark = process.argv.indexOf '--atom-shell-switches-start'
-endMark = process.argv.indexOf '--atom-shell-switches-end'
-# And --force-device-scale-factor on Linux.
-endMark++ if process.platform is 'linux'
-process.argv.splice startMark, endMark - startMark + 1
-
# Add browser/api/lib to require's search paths,
# which contains javascript part of Atom's built-in libraries.
globalPaths = module.globalPaths
#include <string>
#include <vector>
+#include "atom/app/atom_main_args.h"
#include "atom/common/native_mate_converters/file_path_converter.h"
#include "base/command_line.h"
#include "base/base_paths.h"
scoped_ptr<const char*[]> StringVectorToArgArray(
const std::vector<std::string>& vector) {
scoped_ptr<const char*[]> array(new const char*[vector.size()]);
- for (size_t i = 0; i < vector.size(); ++i)
+ for (size_t i = 0; i < vector.size(); ++i) {
array[i] = vector[i].c_str();
+ }
return array.Pass();
}
-#if defined(OS_WIN)
-std::vector<std::string> String16VectorToStringVector(
- const std::vector<base::string16>& vector) {
- std::vector<std::string> utf8_vector;
- utf8_vector.reserve(vector.size());
- for (size_t i = 0; i < vector.size(); ++i)
- utf8_vector.push_back(base::UTF16ToUTF8(vector[i]));
- return utf8_vector;
-}
-#endif
-
base::FilePath GetResourcesPath(base::CommandLine* command_line,
bool is_browser) {
base::FilePath exec_path(command_line->argv()[0]);
node::Environment* NodeBindings::CreateEnvironment(
v8::Handle<v8::Context> context) {
+ auto args = AtomCommandLine::argv();
auto command_line = base::CommandLine::ForCurrentProcess();
- std::vector<std::string> args =
-#if defined(OS_WIN)
- String16VectorToStringVector(command_line->argv());
-#else
- command_line->argv();
-#endif
// Feed node the path to initialization script.
base::FilePath::StringType process_type = is_browser_ ?
BrowserWindow = remote.require 'browser-window'
-isCI = remote.process.argv[1] == '--ci'
+isCI = remote.process.argv[2] == '--ci'
describe 'browser-window module', ->
fixtures = path.resolve __dirname, 'fixtures'
--- /dev/null
+process.on('message', function() {
+ process.send(process.argv);
+ process.exit(0);
+});
done()
child.send 'message'
+ it 'preserves args', (done) ->
+ args = ['--expose_gc', '-test', '1']
+ child = child_process.fork path.join(fixtures, 'module', 'process_args.js'), args
+ child.on 'message', (msg) ->
+ assert.deepEqual args, msg.slice(2)
+ done()
+ child.send 'message'
+
it 'works in forked process', (done) ->
child = child_process.fork path.join(fixtures, 'module', 'fork_ping.js')
child.on 'message', (msg) ->
// Check if we are running in CI.
var argv = require('remote').process.argv;
- var isCi = argv[1] == '--ci';
+ var isCi = argv[2] == '--ci';
if (!isCi) {
var win = require('remote').getCurrentWindow();
event.returnValue = msg;
});
-if (process.argv[1] == '--ci') {
+if (process.argv[2] == '--ci') {
process.removeAllListeners('uncaughtException');
process.on('uncaughtException', function(error) {
console.error(error, error.stack);