mirrors/electron
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages 1 Wiki Activity Actions

Merge pull request #140 from atom/chrome31

Browse source 
Update to Chrome 31
This commit is contained in:
Cheng Zhao 2013-12-26 22:07:17 -08:00
commit 2945e1b50a
128 changed files with 1489 additions and 1579 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
.gitmodules vendored
View file

@ -4,9 +4,6 @@
[submodule "vendor/node"]
path = vendor/node
url = https://github.com/atom/node.git
[submodule "vendor/gyp"]
path = vendor/gyp
url = https://github.com/svn2github/gyp.git
[submodule "vendor/depot_tools"]
path = vendor/depot_tools
url = https://chromium.googlesource.com/chromium/tools/depot_tools.git

33
app/atom_main_delegate.cc
View file

@ -23,19 +23,23 @@ AtomMainDelegate::~AtomMainDelegate() {
bool AtomMainDelegate::BasicStartupComplete(int* exit_code) {
// Disable logging out to debug.log on Windows
#if defined(OS_WIN)
logging::InitLogging(
L"debug.log",
logging::LoggingSettings settings;
#if defined(DEBUG)
logging::LOG_TO_BOTH_FILE_AND_SYSTEM_DEBUG_LOG ,
settings.logging_dest = logging::LOG_TO_ALL;
settings.log_file = L"debug.log";
settings.lock_log = logging::LOCK_LOG_FILE;
settings.delete_old = logging::DELETE_OLD_LOG_FILE;
#else
logging::LOG_ONLY_TO_SYSTEM_DEBUG_LOG,
#endif // defined(NDEBUG)
logging::LOCK_LOG_FILE,
logging::DELETE_OLD_LOG_FILE,
logging::DISABLE_DCHECK_FOR_NON_OFFICIAL_RELEASE_BUILDS);
logging::SetLogItems(true, false, true, false);
settings.logging_dest = logging::LOG_TO_SYSTEM_DEBUG_LOG;
#endif
settings.dcheck_state =
logging::DISABLE_DCHECK_FOR_NON_OFFICIAL_RELEASE_BUILDS;
logging::InitLogging(settings);
#endif // defined(OS_WIN)
// Logging with pid and timestamp.
logging::SetLogItems(true, false, true, false);
return brightray::MainDelegate::BasicStartupComplete(exit_code);
}
@ -43,13 +47,20 @@ void AtomMainDelegate::PreSandboxStartup() {
#if defined(OS_MACOSX)
OverrideChildProcessPath();
OverrideFrameworkBundlePath();
SetProcessName();
#endif
InitializeResourceBundle();
// Disable renderer sandbox for most of node's functions.
CommandLine* command_line = CommandLine::ForCurrentProcess();
// Disable renderer sandbox for most of node's functions.
command_line->AppendSwitch(switches::kNoSandbox);
// Disable accelerated compositing since it caused a lot of troubles (black
// devtools, screen flashes) and needed lots of effort to make it right.
command_line->AppendSwitch(switches::kDisableAcceleratedCompositing);
// Add a flag to mark the end of switches added by atom-shell.
command_line->AppendSwitch("no-more-switches");
}
void AtomMainDelegate::InitializeResourceBundle() {

1
app/atom_main_delegate.h
View file

@ -23,7 +23,6 @@ class AtomMainDelegate : public brightray::MainDelegate {
virtual base::FilePath GetResourcesPakFilePath();
virtual void OverrideChildProcessPath();
virtual void OverrideFrameworkBundlePath();
virtual void SetProcessName();
#endif
private:

18
app/atom_main_delegate_mac.mm
View file

@ -45,22 +45,4 @@ void AtomMainDelegate::OverrideChildProcessPath() {
PathService::Override(content::CHILD_PROCESS_EXE, helper_path);
}
void AtomMainDelegate::SetProcessName() {
const auto& command_line = *CommandLine::ForCurrentProcess();
auto process_type = command_line.GetSwitchValueASCII(switches::kProcessType);
std::string suffix;
if (process_type == switches::kRendererProcess)
suffix = "Renderer";
else if (process_type == switches::kPluginProcess ||
process_type == switches::kPpapiPluginProcess)
suffix = "Plug-In Host";
else if (process_type == switches::kUtilityProcess)
suffix = "Utility";
else
return;
base::mac::SetProcessName(base::mac::NSToCFCast(base::SysUTF8ToNSString(
brightray::GetApplicationName() + " " + suffix)));
}
} // namespace atom

26
atom.gyp
View file

@ -12,7 +12,6 @@
],
'coffee_sources': [
'browser/api/lib/app.coffee',
'browser/api/lib/atom-delegate.coffee',
'browser/api/lib/auto-updater.coffee',
'browser/api/lib/browser-window.coffee',
'browser/api/lib/dialog.coffee',
@ -21,14 +20,15 @@
'browser/api/lib/menu-item.coffee',
'browser/api/lib/power-monitor.coffee',
'browser/api/lib/protocol.coffee',
'browser/atom/atom.coffee',
'browser/atom/objects-registry.coffee',
'browser/atom/rpc-server.coffee',
'browser/lib/init.coffee',
'browser/lib/objects-registry.coffee',
'browser/lib/rpc-server.coffee',
'common/api/lib/callbacks-registry.coffee',
'common/api/lib/clipboard.coffee',
'common/api/lib/crash-reporter.coffee',
'common/api/lib/id-weak-map.coffee',
'common/api/lib/shell.coffee',
'renderer/lib/init.coffee',
'renderer/api/lib/ipc.coffee',
'renderer/api/lib/remote.coffee',
],
@ -165,9 +165,11 @@
'common/platform_util_mac.mm',
'common/platform_util_win.cc',
'common/swap_or_assign.h',
'common/v8_conversions.h',
'common/v8_value_converter_impl.cc',
'common/v8_value_converter_impl.h',
'common/v8/node_common.h',
'common/v8/scoped_persistent.h',
'common/v8/native_type_conversions.h',
'common/v8/v8_value_converter.cc',
'common/v8/v8_value_converter.h',
'renderer/api/atom_api_renderer_ipc.cc',
'renderer/api/atom_api_renderer_ipc.h',
'renderer/api/atom_renderer_bindings.cc',
@ -318,7 +320,7 @@
'type': 'static_library',
'dependencies': [
'vendor/brightray/brightray.gyp:brightray',
'vendor/node/node.gyp:node',
'vendor/node/node.gyp:node_lib',
],
'sources': [
'<@(lib_sources)',
@ -326,6 +328,14 @@
'include_dirs': [
'.',
'vendor',
# Include directories for uv and node.
'vendor/node/src',
'vendor/node/deps/http_parser',
'vendor/node/deps/uv/include',
# The `node.h` is using `#include"v8.h"`.
'vendor/brightray/vendor/download/libchromiumcontent/src/v8/include',
# The `node.h` is using `#include"ares.h"`.
'vendor/node/deps/cares/include',
],
'direct_dependent_settings': {
'include_dirs': [

87
browser/api/atom_api_app.cc
View file

@ -7,8 +7,9 @@
#include "base/values.h"
#include "base/command_line.h"
#include "browser/browser.h"
#include "common/v8_conversions.h"
#include "vendor/node/src/node.h"
#include "common/v8/native_type_conversions.h"
#include "common/v8/node_common.h"
namespace atom {
@ -48,97 +49,69 @@ void App::OnWillFinishLaunching() {
}
void App::OnFinishLaunching() {
Emit("finish-launching");
Emit("ready");
}
// static
v8::Handle<v8::Value> App::New(const v8::Arguments &args) {
v8::HandleScope scope;
void App::New(const v8::FunctionCallbackInfo<v8::Value>& args) {
v8::HandleScope scope(args.GetIsolate());
if (!args.IsConstructCall())
return node::ThrowError("Require constructor call");
new App(args.This());
return args.This();
}
// static
v8::Handle<v8::Value> App::Quit(const v8::Arguments &args) {
v8::HandleScope scope;
void App::Quit(const v8::FunctionCallbackInfo<v8::Value>& args) {
Browser::Get()->Quit();
return v8::Undefined();
}
// static
v8::Handle<v8::Value> App::Exit(const v8::Arguments &args) {
v8::HandleScope scope;
void App::Exit(const v8::FunctionCallbackInfo<v8::Value>& args) {
exit(args[0]->IntegerValue());
return v8::Undefined();
}
// static
v8::Handle<v8::Value> App::Terminate(const v8::Arguments &args) {
v8::HandleScope scope;
void App::Terminate(const v8::FunctionCallbackInfo<v8::Value>& args) {
Browser::Get()->Terminate();
return v8::Undefined();
}
// static
v8::Handle<v8::Value> App::Focus(const v8::Arguments &args) {
v8::HandleScope scope;
void App::Focus(const v8::FunctionCallbackInfo<v8::Value>& args) {
Browser::Get()->Focus();
return v8::Undefined();
}
// static
v8::Handle<v8::Value> App::GetVersion(const v8::Arguments &args) {
return ToV8Value(Browser::Get()->GetVersion());
void App::GetVersion(const v8::FunctionCallbackInfo<v8::Value>& args) {
args.GetReturnValue().Set(ToV8Value(Browser::Get()->GetVersion()));
}
// static
v8::Handle<v8::Value> App::SetVersion(const v8::Arguments &args) {
v8::HandleScope scope;
void App::SetVersion(const v8::FunctionCallbackInfo<v8::Value>& args) {
std::string version;
if (!FromV8Arguments(args, &version))
return node::ThrowError("Bad argument");
Browser::Get()->SetVersion(version);
return v8::Undefined();
}
// static
v8::Handle<v8::Value> App::GetName(const v8::Arguments &args) {
return ToV8Value(Browser::Get()->GetName());
void App::GetName(const v8::FunctionCallbackInfo<v8::Value>& args) {
return args.GetReturnValue().Set(ToV8Value(Browser::Get()->GetName()));
}
// static
v8::Handle<v8::Value> App::SetName(const v8::Arguments &args) {
v8::HandleScope scope;
void App::SetName(const v8::FunctionCallbackInfo<v8::Value>& args) {
std::string name;
if (!FromV8Arguments(args, &name))
return node::ThrowError("Bad argument");
Browser::Get()->SetName(name);
return v8::Undefined();
}
// static
v8::Handle<v8::Value> App::AppendSwitch(const v8::Arguments &args) {
v8::HandleScope scope;
void App::AppendSwitch(const v8::FunctionCallbackInfo<v8::Value>& args) {
std::string switch_string;
if (!FromV8Arguments(args, &switch_string))
return node::ThrowError("Bad argument");
@ -150,27 +123,21 @@ v8::Handle<v8::Value> App::AppendSwitch(const v8::Arguments &args) {
CommandLine::ForCurrentProcess()->AppendSwitchASCII(
switch_string, value);
}
return v8::Undefined();
}
// static
v8::Handle<v8::Value> App::AppendArgument(const v8::Arguments &args) {
v8::HandleScope scope;
void App::AppendArgument(const v8::FunctionCallbackInfo<v8::Value>& args) {
std::string value;
if (!FromV8Arguments(args, &value))
return node::ThrowError("Bad argument");
CommandLine::ForCurrentProcess()->AppendArg(value);
return v8::Undefined();
}
#if defined(OS_MACOSX)
// static
v8::Handle<v8::Value> App::DockBounce(const v8::Arguments& args) {
void App::DockBounce(const v8::FunctionCallbackInfo<v8::Value>& args) {
std::string type;
if (!FromV8Arguments(args, &type))
return node::ThrowError("Bad argument");
@ -184,34 +151,32 @@ v8::Handle<v8::Value> App::DockBounce(const v8::Arguments& args) {
else
return node::ThrowTypeError("Invalid bounce type");
return ToV8Value(request_id);
args.GetReturnValue().Set(request_id);
}
// static
v8::Handle<v8::Value> App::DockCancelBounce(const v8::Arguments& args) {
void App::DockCancelBounce(const v8::FunctionCallbackInfo<v8::Value>& args) {
Browser::Get()->DockCancelBounce(FromV8Value(args[0]));
return v8::Undefined();
}
// static
v8::Handle<v8::Value> App::DockSetBadgeText(const v8::Arguments& args) {
void App::DockSetBadgeText(const v8::FunctionCallbackInfo<v8::Value>& args) {
Browser::Get()->DockSetBadgeText(FromV8Value(args[0]));
return v8::Undefined();
}
// static
v8::Handle<v8::Value> App::DockGetBadgeText(const v8::Arguments& args) {
void App::DockGetBadgeText(const v8::FunctionCallbackInfo<v8::Value>& args) {
std::string text(Browser::Get()->DockGetBadgeText());
return ToV8Value(text);
args.GetReturnValue().Set(ToV8Value(text));
}
#endif // defined(OS_MACOSX)
// static
void App::Initialize(v8::Handle<v8::Object> target) {
v8::HandleScope scope;
v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(App::New);
v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(New);
t->InstanceTemplate()->SetInternalFieldCount(1);
t->SetClassName(v8::String::NewSymbol("Application"));

30
browser/api/atom_api_app.h
View file

@ -33,24 +33,24 @@ class App : public EventEmitter,
virtual void OnFinishLaunching() OVERRIDE;
private:
static v8::Handle<v8::Value> New(const v8::Arguments &args);
static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
static v8::Handle<v8::Value> Quit(const v8::Arguments &args);
static v8::Handle<v8::Value> Exit(const v8::Arguments &args);
static v8::Handle<v8::Value> Terminate(const v8::Arguments &args);
static v8::Handle<v8::Value> Focus(const v8::Arguments &args);
static v8::Handle<v8::Value> GetVersion(const v8::Arguments &args);
static v8::Handle<v8::Value> SetVersion(const v8::Arguments &args);
static v8::Handle<v8::Value> GetName(const v8::Arguments &args);
static v8::Handle<v8::Value> SetName(const v8::Arguments &args);
static v8::Handle<v8::Value> AppendSwitch(const v8::Arguments &args);
static v8::Handle<v8::Value> AppendArgument(const v8::Arguments &args);
static void Quit(const v8::FunctionCallbackInfo<v8::Value>& args);
static void Exit(const v8::FunctionCallbackInfo<v8::Value>& args);
static void Terminate(const v8::FunctionCallbackInfo<v8::Value>& args);
static void Focus(const v8::FunctionCallbackInfo<v8::Value>& args);
static void GetVersion(const v8::FunctionCallbackInfo<v8::Value>& args);
static void SetVersion(const v8::FunctionCallbackInfo<v8::Value>& args);
static void GetName(const v8::FunctionCallbackInfo<v8::Value>& args);
static void SetName(const v8::FunctionCallbackInfo<v8::Value>& args);
static void AppendSwitch(const v8::FunctionCallbackInfo<v8::Value>& args);
static void AppendArgument(const v8::FunctionCallbackInfo<v8::Value>& args);
#if defined(OS_MACOSX)
static v8::Handle<v8::Value> DockBounce(const v8::Arguments& args);
static v8::Handle<v8::Value> DockCancelBounce(const v8::Arguments& args);
static v8::Handle<v8::Value> DockSetBadgeText(const v8::Arguments& args);
static v8::Handle<v8::Value> DockGetBadgeText(const v8::Arguments& args);
static void DockBounce(const v8::FunctionCallbackInfo<v8::Value>& args);
static void DockCancelBounce(const v8::FunctionCallbackInfo<v8::Value>& args);
static void DockSetBadgeText(const v8::FunctionCallbackInfo<v8::Value>& args);
static void DockGetBadgeText(const v8::FunctionCallbackInfo<v8::Value>& args);
#endif // defined(OS_MACOSX)
DISALLOW_COPY_AND_ASSIGN(App);

46
browser/api/atom_api_auto_updater.cc
View file

@ -6,7 +6,9 @@
#include "base/values.h"
#include "browser/auto_updater.h"
#include "common/v8_conversions.h"
#include "common/v8/native_type_conversions.h"
#include "common/v8/node_common.h"
namespace atom {
@ -44,69 +46,63 @@ void AutoUpdater::ReadyForUpdateOnQuit(const std::string& version,
}
// static
v8::Handle<v8::Value> AutoUpdater::New(const v8::Arguments &args) {
v8::HandleScope scope;
void AutoUpdater::New(const v8::FunctionCallbackInfo<v8::Value>& args) {
v8::HandleScope handle_scope(args.GetIsolate());
if (!args.IsConstructCall())
return node::ThrowError("Require constructor call");
new AutoUpdater(args.This());
return args.This();
}
// static
v8::Handle<v8::Value> AutoUpdater::SetFeedURL(const v8::Arguments &args) {
void AutoUpdater::SetFeedURL(const v8::FunctionCallbackInfo<v8::Value>& args) {
auto_updater::AutoUpdater::SetFeedURL(FromV8Value(args[0]));
return v8::Undefined();
}
// static
v8::Handle<v8::Value> AutoUpdater::SetAutomaticallyChecksForUpdates(
const v8::Arguments &args) {
void AutoUpdater::SetAutomaticallyChecksForUpdates(
const v8::FunctionCallbackInfo<v8::Value>& args) {
auto_updater::AutoUpdater::SetAutomaticallyChecksForUpdates(
args[0]->BooleanValue());
return v8::Undefined();
FromV8Value(args[0]));
}
// static
v8::Handle<v8::Value> AutoUpdater::SetAutomaticallyDownloadsUpdates(
const v8::Arguments &args) {
void AutoUpdater::SetAutomaticallyDownloadsUpdates(
const v8::FunctionCallbackInfo<v8::Value>& args) {
auto_updater::AutoUpdater::SetAutomaticallyDownloadsUpdates(
args[0]->BooleanValue());
return v8::Undefined();
FromV8Value(args[0]));
}
// static
v8::Handle<v8::Value> AutoUpdater::CheckForUpdates(const v8::Arguments &args) {
void AutoUpdater::CheckForUpdates(
const v8::FunctionCallbackInfo<v8::Value>& args) {
auto_updater::AutoUpdater::CheckForUpdates();
return v8::Undefined();
}
// static
v8::Handle<v8::Value> AutoUpdater::CheckForUpdatesInBackground(
const v8::Arguments &args) {
void AutoUpdater::CheckForUpdatesInBackground(
const v8::FunctionCallbackInfo<v8::Value>& args) {
auto_updater::AutoUpdater::CheckForUpdatesInBackground();
return v8::Undefined();
}
// static
v8::Handle<v8::Value> AutoUpdater::ContinueUpdate(const v8::Arguments &args) {
void AutoUpdater::ContinueUpdate(
const v8::FunctionCallbackInfo<v8::Value>& args) {
AutoUpdater* self = AutoUpdater::Unwrap<AutoUpdater>(args.This());
self->continue_update_.Run();
return v8::Undefined();
}
// static
v8::Handle<v8::Value> AutoUpdater::QuitAndInstall(const v8::Arguments &args) {
void AutoUpdater::QuitAndInstall(
const v8::FunctionCallbackInfo<v8::Value>& args) {
AutoUpdater* self = AutoUpdater::Unwrap<AutoUpdater>(args.This());
self->quit_and_install_.Run();
return v8::Undefined();
}
// static
void AutoUpdater::Initialize(v8::Handle<v8::Object> target) {
v8::HandleScope scope;
v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
v8::Local<v8::FunctionTemplate> t(
v8::FunctionTemplate::New(AutoUpdater::New));

22
browser/api/atom_api_auto_updater.h
View file

@ -31,19 +31,19 @@ class AutoUpdater : public EventEmitter,
const base::Closure& quit_and_install) OVERRIDE;
private:
static v8::Handle<v8::Value> New(const v8::Arguments &args);
static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
static v8::Handle<v8::Value> SetFeedURL(const v8::Arguments &args);
static v8::Handle<v8::Value> SetAutomaticallyChecksForUpdates(
const v8::Arguments &args);
static v8::Handle<v8::Value> SetAutomaticallyDownloadsUpdates(
const v8::Arguments &args);
static v8::Handle<v8::Value> CheckForUpdates(const v8::Arguments &args);
static v8::Handle<v8::Value> CheckForUpdatesInBackground(
const v8::Arguments &args);
static void SetFeedURL(const v8::FunctionCallbackInfo<v8::Value>& args);
static void SetAutomaticallyChecksForUpdates(
const v8::FunctionCallbackInfo<v8::Value>& args);
static void SetAutomaticallyDownloadsUpdates(
const v8::FunctionCallbackInfo<v8::Value>& args);
static void CheckForUpdates(const v8::FunctionCallbackInfo<v8::Value>& args);
static void CheckForUpdatesInBackground(
const v8::FunctionCallbackInfo<v8::Value>& args);
static v8::Handle<v8::Value> ContinueUpdate(const v8::Arguments &args);
static v8::Handle<v8::Value> QuitAndInstall(const v8::Arguments &args);
static void ContinueUpdate(const v8::FunctionCallbackInfo<v8::Value>& args);
static void QuitAndInstall(const v8::FunctionCallbackInfo<v8::Value>& args);
base::Closure continue_update_;
base::Closure quit_and_install_;

18
browser/api/atom_api_browser_ipc.cc
View file

@ -5,22 +5,18 @@
#include "browser/api/atom_api_browser_ipc.h"
#include "common/api/api_messages.h"
#include "common/v8_conversions.h"
#include "common/v8/node_common.h"
#include "common/v8/native_type_conversions.h"
#include "content/public/browser/render_view_host.h"
#include "vendor/node/src/node.h"
#include "vendor/node/src/node_internals.h"
using content::RenderViewHost;
using content::V8ValueConverter;
namespace atom {
namespace api {
// static
v8::Handle<v8::Value> BrowserIPC::Send(const v8::Arguments &args) {
v8::HandleScope scope;
void BrowserIPC::Send(const v8::FunctionCallbackInfo<v8::Value>& args) {
string16 channel;
int process_id, routing_id;
scoped_ptr<base::Value> arguments;
@ -34,17 +30,15 @@ v8::Handle<v8::Value> BrowserIPC::Send(const v8::Arguments &args) {
if (!render_view_host)
return node::ThrowError("Invalid render view host");
render_view_host->Send(new AtomViewMsg_Message(
args.GetReturnValue().Set(render_view_host->Send(new AtomViewMsg_Message(
routing_id,
channel,
*static_cast<base::ListValue*>(arguments.get())));
return v8::Undefined();
*static_cast<base::ListValue*>(arguments.get()))));
}
// static
void BrowserIPC::Initialize(v8::Handle<v8::Object> target) {
node::SetMethod(target, "send", Send);
NODE_SET_METHOD(target, "send", Send);
}
} // namespace api

2
browser/api/atom_api_browser_ipc.h
View file

@ -17,7 +17,7 @@ class BrowserIPC {
static void Initialize(v8::Handle<v8::Object> target);
private:
static v8::Handle<v8::Value> Send(const v8::Arguments &args);
static void Send(const v8::FunctionCallbackInfo<v8::Value>& args);
DISALLOW_IMPLICIT_CONSTRUCTORS(BrowserIPC);
};

60
browser/api/atom_api_dialog.cc
View file

@ -8,10 +8,8 @@
#include "browser/native_window.h"
#include "browser/ui/file_dialog.h"
#include "browser/ui/message_box.h"
#include "common/v8_conversions.h"
#include "vendor/node/src/node_internals.h"
using node::node_isolate;
#include "common/v8/node_common.h"
#include "common/v8/native_type_conversions.h"
namespace atom {
@ -20,19 +18,14 @@ namespace api {
namespace {
template<typename T>
void CallV8Function(v8::Persistent<v8::Function> callback, T arg) {
DCHECK(!callback.IsEmpty());
v8::HandleScope scope;
void CallV8Function(const RefCountedV8Function& callback, T arg) {
v8::Handle<v8::Value> value = ToV8Value(arg);
callback->Call(callback, 1, &value);
callback.Dispose(node_isolate);
callback->NewHandle(node_isolate)->Call(
v8::Context::GetCurrent()->Global(), 1, &value);
}
template<typename T>
void CallV8Function2(v8::Persistent<v8::Function> callback,
bool result,
T arg) {
void CallV8Function2(const RefCountedV8Function& callback, bool result, T arg) {
if (result)
return CallV8Function<T>(callback, arg);
else
@ -40,7 +33,7 @@ void CallV8Function2(v8::Persistent<v8::Function> callback,
}
void Initialize(v8::Handle<v8::Object> target) {
v8::HandleScope scope;
v8::HandleScope handle_scope(node_isolate);
NODE_SET_METHOD(target, "showMessageBox", ShowMessageBox);
NODE_SET_METHOD(target, "showOpenDialog", ShowOpenDialog);
@ -49,9 +42,7 @@ void Initialize(v8::Handle<v8::Object> target) {
} // namespace
v8::Handle<v8::Value> ShowMessageBox(const v8::Arguments &args) {
v8::HandleScope scope;
void ShowMessageBox(const v8::FunctionCallbackInfo<v8::Value>& args) {
int type;
std::vector<std::string> buttons;
std::string title, message, detail;
@ -68,9 +59,9 @@ v8::Handle<v8::Value> ShowMessageBox(const v8::Arguments &args) {
title,
message,
detail);
return scope.Close(v8::Integer::New(chosen));
args.GetReturnValue().Set(chosen);
} else {
v8::Persistent<v8::Function> callback = FromV8Value(args[6]);
RefCountedV8Function callback = FromV8Value(args[6]);
atom::ShowMessageBox(
native_window,
(MessageBoxType)type,
@ -79,13 +70,10 @@ v8::Handle<v8::Value> ShowMessageBox(const v8::Arguments &args) {
message,
detail,
base::Bind(&CallV8Function<int>, callback));
return v8::Undefined();
}
}
v8::Handle<v8::Value> ShowOpenDialog(const v8::Arguments &args) {
v8::HandleScope scope;
void ShowOpenDialog(const v8::FunctionCallbackInfo<v8::Value>& args) {
std::string title;
base::FilePath default_path;
int properties;
@ -101,15 +89,15 @@ v8::Handle<v8::Value> ShowOpenDialog(const v8::Arguments &args) {
default_path,
properties,
&paths))
return v8::Undefined();
return;
v8::Handle<v8::Array> result = v8::Array::New(paths.size());
for (size_t i = 0; i < paths.size(); ++i)
result->Set(i, ToV8Value(paths[i]));
return scope.Close(result);
args.GetReturnValue().Set(result);
} else {
v8::Persistent<v8::Function> callback = FromV8Value(args[4]);
RefCountedV8Function callback = FromV8Value(args[4]);
file_dialog::ShowOpenDialog(
native_window,
title,
@ -117,13 +105,10 @@ v8::Handle<v8::Value> ShowOpenDialog(const v8::Arguments &args) {
properties,
base::Bind(&CallV8Function2<const std::vector<base::FilePath>&>,
callback));
return v8::Undefined();
}
}
v8::Handle<v8::Value> ShowSaveDialog(const v8::Arguments &args) {
v8::HandleScope scope;
void ShowSaveDialog(const v8::FunctionCallbackInfo<v8::Value>& args) {
std::string title;
base::FilePath default_path;
if (!FromV8Arguments(args, &title, &default_path))
@ -133,21 +118,18 @@ v8::Handle<v8::Value> ShowSaveDialog(const v8::Arguments &args) {
if (!args[3]->IsFunction()) {
base::FilePath path;
if (!file_dialog::ShowSaveDialog(native_window,
title,
default_path,
&path))
return v8::Undefined();
return scope.Close(ToV8Value(path));
if (file_dialog::ShowSaveDialog(native_window,
title,
default_path,
&path))
args.GetReturnValue().Set(ToV8Value(path));
} else {
v8::Persistent<v8::Function> callback = FromV8Value(args[3]);
RefCountedV8Function callback = FromV8Value(args[3]);
file_dialog::ShowSaveDialog(
native_window,
title,
default_path,
base::Bind(&CallV8Function2<const base::FilePath&>, callback));
return v8::Undefined();
}
}

6
browser/api/atom_api_dialog.h
View file

@ -11,9 +11,9 @@ namespace atom {
namespace api {
v8::Handle<v8::Value> ShowMessageBox(const v8::Arguments &args);
v8::Handle<v8::Value> ShowOpenDialog(const v8::Arguments &args);
v8::Handle<v8::Value> ShowSaveDialog(const v8::Arguments &args);
void ShowMessageBox(const v8::FunctionCallbackInfo<v8::Value>& args);
void ShowOpenDialog(const v8::FunctionCallbackInfo<v8::Value>& args);
void ShowSaveDialog(const v8::FunctionCallbackInfo<v8::Value>& args);
} // namespace api

38
browser/api/atom_api_event.cc
View file

@ -6,15 +6,14 @@
#include "browser/native_window.h"
#include "common/api/api_messages.h"
#include "common/v8_conversions.h"
using node::node_isolate;
#include "common/v8/node_common.h"
#include "common/v8/native_type_conversions.h"
namespace atom {
namespace api {
v8::Persistent<v8::FunctionTemplate> Event::constructor_template_;
ScopedPersistent<v8::Function> Event::constructor_template_;
Event::Event()
: sender_(NULL),
@ -29,24 +28,20 @@ Event::~Event() {
// static
v8::Handle<v8::Object> Event::CreateV8Object() {
v8::HandleScope scope;
if (constructor_template_.IsEmpty()) {
v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(New);
constructor_template_ = v8::Persistent<v8::FunctionTemplate>::New(
node_isolate, t);
constructor_template_->InstanceTemplate()->SetInternalFieldCount(1);
constructor_template_->SetClassName(v8::String::NewSymbol("Event"));
t->InstanceTemplate()->SetInternalFieldCount(1);
t->SetClassName(v8::String::NewSymbol("Event"));
NODE_SET_PROTOTYPE_METHOD(t, "preventDefault", PreventDefault);
NODE_SET_PROTOTYPE_METHOD(t, "sendReply", SendReply);
NODE_SET_PROTOTYPE_METHOD(t, "destroy", Destroy);
constructor_template_.reset(t->GetFunction());
}
v8::Handle<v8::Object> v8_event =
constructor_template_->GetFunction()->NewInstance(0, NULL);
return scope.Close(v8_event);
v8::Handle<v8::Function> t = constructor_template_.NewHandle(node_isolate);
return t->NewInstance(0, NULL);
}
void Event::SetSenderAndMessage(NativeWindow* sender, IPC::Message* message) {
@ -64,26 +59,22 @@ void Event::OnWindowClosed() {
}
// static
v8::Handle<v8::Value> Event::New(const v8::Arguments& args) {
void Event::New(const v8::FunctionCallbackInfo<v8::Value>& args) {
Event* event = new Event;
event->Wrap(args.This());
return args.This();
}
// static
v8::Handle<v8::Value> Event::PreventDefault(const v8::Arguments& args) {
void Event::PreventDefault(const v8::FunctionCallbackInfo<v8::Value>& args) {
Event* event = Unwrap<Event>(args.This());
if (event == NULL)
return node::ThrowError("Event is already destroyed");
event->prevent_default_ = true;
return v8::Undefined();
}
// static
v8::Handle<v8::Value> Event::SendReply(const v8::Arguments& args) {
void Event::SendReply(const v8::FunctionCallbackInfo<v8::Value>& args) {
Event* event = Unwrap<Event>(args.This());
if (event == NULL)
return node::ThrowError("Event is already destroyed");
@ -97,14 +88,11 @@ v8::Handle<v8::Value> Event::SendReply(const v8::Arguments& args) {
event->sender_->Send(event->message_);
delete event;
return v8::Undefined();
}
// static
v8::Handle<v8::Value> Event::Destroy(const v8::Arguments& args) {
void Event::Destroy(const v8::FunctionCallbackInfo<v8::Value>& args) {
delete Unwrap<Event>(args.This());
return v8::Undefined();
}
} // namespace api

16
browser/api/atom_api_event.h
View file

@ -7,8 +7,9 @@
#include "base/basictypes.h"
#include "base/compiler_specific.h"
#include "base/string16.h"
#include "base/strings/string16.h"
#include "browser/native_window_observer.h"
#include "common/v8/scoped_persistent.h"
#include "vendor/node/src/node_object_wrap.h"
namespace IPC {
@ -32,9 +33,6 @@ class Event : public node::ObjectWrap,
// Pass the sender and message to be replied.
void SetSenderAndMessage(NativeWindow* sender, IPC::Message* message);
// Accessor to return handle_, this follows Google C++ Style.
v8::Persistent<v8::Object>& handle() { return handle_; }
// Whether event.preventDefault() is called.
bool prevent_default() const { return prevent_default_; }
@ -45,13 +43,13 @@ class Event : public node::ObjectWrap,
virtual void OnWindowClosed() OVERRIDE;
private:
static v8::Handle<v8::Value> New(const v8::Arguments& args);
static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
static v8::Handle<v8::Value> PreventDefault(const v8::Arguments& args);
static v8::Handle<v8::Value> SendReply(const v8::Arguments& args);
static v8::Handle<v8::Value> Destroy(const v8::Arguments& args);
static void PreventDefault(const v8::FunctionCallbackInfo<v8::Value>& args);
static void SendReply(const v8::FunctionCallbackInfo<v8::Value>& args);
static void Destroy(const v8::FunctionCallbackInfo<v8::Value>& args);
static v8::Persistent<v8::FunctionTemplate> constructor_template_;
static ScopedPersistent<v8::Function> constructor_template_;
// Replyer for the synchronous messages.
NativeWindow* sender_;

17
browser/api/atom_api_event_emitter.cc
View file

@ -8,9 +8,9 @@
#include "base/logging.h"
#include "browser/api/atom_api_event.h"
#include "common/v8_conversions.h"
#include "vendor/node/src/node.h"
#include "vendor/node/src/node_internals.h"
#include "common/v8/native_type_conversions.h"
#include "common/v8/node_common.h"
namespace atom {
@ -18,13 +18,6 @@ namespace api {
EventEmitter::EventEmitter(v8::Handle<v8::Object> wrapper) {
Wrap(wrapper);
// process.emit('ATOM_BROWSER_INTERNAL_NEW', this).
v8::Handle<v8::Value> args[] = {
v8::String::New("ATOM_BROWSER_INTERNAL_NEW"),
wrapper,
};
node::MakeCallback(node::process, "emit", 2, args);
}
EventEmitter::~EventEmitter() {
@ -36,10 +29,10 @@ bool EventEmitter::Emit(const std::string& name) {
}
bool EventEmitter::Emit(const std::string& name, base::ListValue* args) {
v8::HandleScope scope;
v8::HandleScope handle_scope(node_isolate);
v8::Handle<v8::Context> context = v8::Context::GetCurrent();
scoped_ptr<content::V8ValueConverter> converter(new V8ValueConverterImpl);
scoped_ptr<V8ValueConverter> converter(new V8ValueConverter);
v8::Handle<v8::Object> v8_event = Event::CreateV8Object();
Event* event = Event::Unwrap<Event>(v8_event);

3
browser/api/atom_api_event_emitter.h
View file

@ -29,9 +29,6 @@ class EventEmitter : public node::ObjectWrap {
bool Emit(const std::string& name);
bool Emit(const std::string& name, base::ListValue* args);
// Small accessor to return handle_, this follows Google C++ Style.
v8::Persistent<v8::Object> handle() const { return handle_; }
protected:
explicit EventEmitter(v8::Handle<v8::Object> wrapper);

124
browser/api/atom_api_menu.cc
View file

@ -5,7 +5,8 @@
#include "browser/api/atom_api_menu.h"
#include "browser/ui/accelerator_util.h"
#include "common/v8_conversions.h"
#include "common/v8/node_common.h"
#include "common/v8/native_type_conversions.h"
#define UNWRAP_MEMNU_AND_CHECK \
Menu* self = ObjectWrap::Unwrap<Menu>(args.This()); \
@ -23,7 +24,7 @@ v8::Handle<v8::Value> CallDelegate(v8::Handle<v8::Value> default_value,
v8::Handle<v8::Object> menu,
const char* method,
int command_id) {
v8::HandleScope scope;
v8::HandleScope handle_scope(node_isolate);
v8::Handle<v8::Value> delegate = menu->Get(v8::String::New("delegate"));
if (!delegate->IsObject())
@ -36,7 +37,7 @@ v8::Handle<v8::Value> CallDelegate(v8::Handle<v8::Value> default_value,
v8::Handle<v8::Value> argv = v8::Integer::New(command_id);
return scope.Close(
return handle_scope.Close(
function->Call(v8::Context::GetCurrent()->Global(), 1, &argv));
}
@ -51,32 +52,32 @@ Menu::~Menu() {
}
bool Menu::IsCommandIdChecked(int command_id) const {
v8::HandleScope scope;
v8::HandleScope handle_scope(node_isolate);
return CallDelegate(v8::False(),
handle(),
const_cast<Menu*>(this)->handle(),
"isCommandIdChecked",
command_id)->BooleanValue();
}
bool Menu::IsCommandIdEnabled(int command_id) const {
v8::HandleScope scope;
v8::HandleScope handle_scope(node_isolate);
return CallDelegate(v8::True(),
handle(),
const_cast<Menu*>(this)->handle(),
"isCommandIdEnabled",
command_id)->BooleanValue();
}
bool Menu::IsCommandIdVisible(int command_id) const {
v8::HandleScope scope;
v8::HandleScope handle_scope(node_isolate);
return CallDelegate(v8::True(),
handle(),
const_cast<Menu*>(this)->handle(),
"isCommandIdVisible",
command_id)->BooleanValue();
}
bool Menu::GetAcceleratorForCommandId(int command_id,
ui::Accelerator* accelerator) {
v8::HandleScope scope;
v8::HandleScope handle_scope(node_isolate);
v8::Handle<v8::Value> shortcut = CallDelegate(v8::Undefined(),
handle(),
"getAcceleratorForCommandId",
@ -90,48 +91,46 @@ bool Menu::GetAcceleratorForCommandId(int command_id,
}
bool Menu::IsItemForCommandIdDynamic(int command_id) const {
v8::HandleScope scope;
v8::HandleScope handle_scope(node_isolate);
return CallDelegate(v8::False(),
handle(),
const_cast<Menu*>(this)->handle(),
"isItemForCommandIdDynamic",
command_id)->BooleanValue();
}
string16 Menu::GetLabelForCommandId(int command_id) const {
v8::HandleScope scope;
v8::HandleScope handle_scope(node_isolate);
return FromV8Value(CallDelegate(v8::False(),
handle(),
const_cast<Menu*>(this)->handle(),
"getLabelForCommandId",
command_id));
}
string16 Menu::GetSublabelForCommandId(int command_id) const {
v8::HandleScope scope;
v8::HandleScope handle_scope(node_isolate);
return FromV8Value(CallDelegate(v8::False(),
handle(),
const_cast<Menu*>(this)->handle(),
"getSubLabelForCommandId",
command_id));
}
void Menu::ExecuteCommand(int command_id, int event_flags) {
v8::HandleScope scope;
v8::HandleScope handle_scope(node_isolate);
CallDelegate(v8::False(), handle(), "executeCommand", command_id);
}
// static
v8::Handle<v8::Value> Menu::New(const v8::Arguments &args) {
v8::HandleScope scope;
void Menu::New(const v8::FunctionCallbackInfo<v8::Value>& args) {
v8::HandleScope handle_scope(args.GetIsolate());
if (!args.IsConstructCall())
return node::ThrowError("Require constructor call");
Menu::Create(args.This());
return args.This();
}
// static
v8::Handle<v8::Value> Menu::InsertItem(const v8::Arguments &args) {
void Menu::InsertItem(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_MEMNU_AND_CHECK;
int index, command_id;
@ -143,12 +142,10 @@ v8::Handle<v8::Value> Menu::InsertItem(const v8::Arguments &args) {
self->model_->AddItem(command_id, label);
else
self->model_->InsertItemAt(index, command_id, label);
return v8::Undefined();
}
// static
v8::Handle<v8::Value> Menu::InsertCheckItem(const v8::Arguments &args) {
void Menu::InsertCheckItem(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_MEMNU_AND_CHECK;
int index, command_id;
@ -160,12 +157,10 @@ v8::Handle<v8::Value> Menu::InsertCheckItem(const v8::Arguments &args) {
self->model_->AddCheckItem(command_id, label);
else
self->model_->InsertCheckItemAt(index, command_id, label);
return v8::Undefined();
}
// static
v8::Handle<v8::Value> Menu::InsertRadioItem(const v8::Arguments &args) {
void Menu::InsertRadioItem(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_MEMNU_AND_CHECK;
int index, command_id, group_id;
@ -177,12 +172,10 @@ v8::Handle<v8::Value> Menu::InsertRadioItem(const v8::Arguments &args) {
self->model_->AddRadioItem(command_id, label, group_id);
else
self->model_->InsertRadioItemAt(index, command_id, label, group_id);
return v8::Undefined();
}
// static
v8::Handle<v8::Value> Menu::InsertSeparator(const v8::Arguments &args) {
void Menu::InsertSeparator(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_MEMNU_AND_CHECK;
int index;
@ -193,12 +186,10 @@ v8::Handle<v8::Value> Menu::InsertSeparator(const v8::Arguments &args) {
self->model_->AddSeparator(ui::NORMAL_SEPARATOR);
else
self->model_->InsertSeparatorAt(index, ui::NORMAL_SEPARATOR);
return v8::Undefined();
}
// static
v8::Handle<v8::Value> Menu::InsertSubMenu(const v8::Arguments &args) {
void Menu::InsertSubMenu(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_MEMNU_AND_CHECK;
int index, command_id;
@ -215,12 +206,10 @@ v8::Handle<v8::Value> Menu::InsertSubMenu(const v8::Arguments &args) {
else
self->model_->InsertSubMenuAt(
index, command_id, label, submenu->model_.get());
return v8::Undefined();
}
// static
v8::Handle<v8::Value> Menu::SetIcon(const v8::Arguments &args) {
void Menu::SetIcon(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_MEMNU_AND_CHECK;
int index;
@ -229,12 +218,10 @@ v8::Handle<v8::Value> Menu::SetIcon(const v8::Arguments &args) {
return node::ThrowTypeError("Bad argument");
// FIXME use webkit_glue's image decoder here.
return v8::Undefined();
}
// static
v8::Handle<v8::Value> Menu::SetSublabel(const v8::Arguments &args) {
void Menu::SetSublabel(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_MEMNU_AND_CHECK;
int index;
@ -243,74 +230,72 @@ v8::Handle<v8::Value> Menu::SetSublabel(const v8::Arguments &args) {
return node::ThrowTypeError("Bad argument");
self->model_->SetSublabel(index, label);
return v8::Undefined();
}
// static
v8::Handle<v8::Value> Menu::Clear(const v8::Arguments &args) {
void Menu::Clear(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_MEMNU_AND_CHECK;
self->model_->Clear();
return v8::Undefined();
}
// static
v8::Handle<v8::Value> Menu::GetIndexOfCommandId(const v8::Arguments &args) {
void Menu::GetIndexOfCommandId(
const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_MEMNU_AND_CHECK;
int index = args[0]->IntegerValue();
return v8::Integer::New(self->model_->GetIndexOfCommandId(index));
int index = FromV8Value(args[0]);
args.GetReturnValue().Set(self->model_->GetIndexOfCommandId(index));
}
// static
v8::Handle<v8::Value> Menu::GetItemCount(const v8::Arguments &args) {
void Menu::GetItemCount(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_MEMNU_AND_CHECK;
return v8::Integer::New(self->model_->GetItemCount());
args.GetReturnValue().Set(self->model_->GetItemCount());
}
// static
v8::Handle<v8::Value> Menu::GetCommandIdAt(const v8::Arguments &args) {
void Menu::GetCommandIdAt(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_MEMNU_AND_CHECK;
int index = args[0]->IntegerValue();
return v8::Integer::New(self->model_->GetCommandIdAt(index));
int index = FromV8Value(args[0]);
args.GetReturnValue().Set(self->model_->GetCommandIdAt(index));
}
// static
v8::Handle<v8::Value> Menu::GetLabelAt(const v8::Arguments &args) {
void Menu::GetLabelAt(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_MEMNU_AND_CHECK;
int index = args[0]->IntegerValue();
return ToV8Value(self->model_->GetLabelAt(index));
int index = FromV8Value(args[0]);
args.GetReturnValue().Set(ToV8Value(self->model_->GetLabelAt(index)));
}
// static
v8::Handle<v8::Value> Menu::GetSublabelAt(const v8::Arguments &args) {
void Menu::GetSublabelAt(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_MEMNU_AND_CHECK;
int index = args[0]->IntegerValue();
return ToV8Value(self->model_->GetSublabelAt(index));
int index = FromV8Value(args[0]);
args.GetReturnValue().Set(ToV8Value(self->model_->GetSublabelAt(index)));
}
// static
v8::Handle<v8::Value> Menu::IsItemCheckedAt(const v8::Arguments &args) {
void Menu::IsItemCheckedAt(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_MEMNU_AND_CHECK;
int index = args[0]->IntegerValue();
return v8::Boolean::New(self->model_->IsItemCheckedAt(index));
int index = FromV8Value(args[0]);
args.GetReturnValue().Set(self->model_->IsItemCheckedAt(index));
}
// static
v8::Handle<v8::Value> Menu::IsEnabledAt(const v8::Arguments &args) {
void Menu::IsEnabledAt(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_MEMNU_AND_CHECK;
return v8::Boolean::New(self->model_->IsEnabledAt(args[0]->IntegerValue()));
int index = FromV8Value(args[0]);
args.GetReturnValue().Set(self->model_->IsEnabledAt(index));
}
// static
v8::Handle<v8::Value> Menu::IsVisibleAt(const v8::Arguments &args) {
void Menu::IsVisibleAt(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_MEMNU_AND_CHECK;
return v8::Boolean::New(self->model_->IsVisibleAt(args[0]->IntegerValue()));
int index = FromV8Value(args[0]);
args.GetReturnValue().Set(self->model_->IsVisibleAt(index));
}
// static
v8::Handle<v8::Value> Menu::Popup(const v8::Arguments &args) {
void Menu::Popup(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_MEMNU_AND_CHECK;
atom::NativeWindow* window;
@ -318,12 +303,11 @@ v8::Handle<v8::Value> Menu::Popup(const v8::Arguments &args) {
return node::ThrowTypeError("Bad argument");
self->Popup(window);
return v8::Undefined();
}
// static
void Menu::Initialize(v8::Handle<v8::Object> target) {
v8::HandleScope scope;
v8::HandleScope handle_scope(node_isolate);
v8::Local<v8::FunctionTemplate> t(v8::FunctionTemplate::New(Menu::New));
t->InstanceTemplate()->SetInternalFieldCount(1);

46
browser/api/atom_api_menu.h
View file

@ -44,36 +44,38 @@ class Menu : public EventEmitter,
scoped_ptr<ui::SimpleMenuModel> model_;
private:
static v8::Handle<v8::Value> New(const v8::Arguments &args);
static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
static v8::Handle<v8::Value> InsertItem(const v8::Arguments &args);
static v8::Handle<v8::Value> InsertCheckItem(const v8::Arguments &args);
static v8::Handle<v8::Value> InsertRadioItem(const v8::Arguments &args);
static v8::Handle<v8::Value> InsertSeparator(const v8::Arguments &args);
static v8::Handle<v8::Value> InsertSubMenu(const v8::Arguments &args);
static void InsertItem(const v8::FunctionCallbackInfo<v8::Value>& args);
static void InsertCheckItem(const v8::FunctionCallbackInfo<v8::Value>& args);
static void InsertRadioItem(const v8::FunctionCallbackInfo<v8::Value>& args);
static void InsertSeparator(const v8::FunctionCallbackInfo<v8::Value>& args);
static void InsertSubMenu(const v8::FunctionCallbackInfo<v8::Value>& args);
static v8::Handle<v8::Value> SetIcon(const v8::Arguments &args);
static v8::Handle<v8::Value> SetSublabel(const v8::Arguments &args);
static void SetIcon(const v8::FunctionCallbackInfo<v8::Value>& args);
static void SetSublabel(const v8::FunctionCallbackInfo<v8::Value>& args);
static v8::Handle<v8::Value> Clear(const v8::Arguments &args);
static void Clear(const v8::FunctionCallbackInfo<v8::Value>& args);
static v8::Handle<v8::Value> GetIndexOfCommandId(const v8::Arguments &args);
static v8::Handle<v8::Value> GetItemCount(const v8::Arguments &args);
static v8::Handle<v8::Value> GetCommandIdAt(const v8::Arguments &args);
static v8::Handle<v8::Value> GetLabelAt(const v8::Arguments &args);
static v8::Handle<v8::Value> GetSublabelAt(const v8::Arguments &args);
static v8::Handle<v8::Value> IsItemCheckedAt(const v8::Arguments &args);
static v8::Handle<v8::Value> IsEnabledAt(const v8::Arguments &args);
static v8::Handle<v8::Value> IsVisibleAt(const v8::Arguments &args);
static void GetIndexOfCommandId(
const v8::FunctionCallbackInfo<v8::Value>& args);
static void GetItemCount(const v8::FunctionCallbackInfo<v8::Value>& args);
static void GetCommandIdAt(const v8::FunctionCallbackInfo<v8::Value>& args);
static void GetLabelAt(const v8::FunctionCallbackInfo<v8::Value>& args);
static void GetSublabelAt(const v8::FunctionCallbackInfo<v8::Value>& args);
static void IsItemCheckedAt(const v8::FunctionCallbackInfo<v8::Value>& args);
static void IsEnabledAt(const v8::FunctionCallbackInfo<v8::Value>& args);
static void IsVisibleAt(const v8::FunctionCallbackInfo<v8::Value>& args);
static v8::Handle<v8::Value> Popup(const v8::Arguments &args);
static void Popup(const v8::FunctionCallbackInfo<v8::Value>& args);
#if defined(OS_WIN)
static v8::Handle<v8::Value> AttachToWindow(const v8::Arguments &args);
static void AttachToWindow(const v8::FunctionCallbackInfo<v8::Value>& args);
#elif defined(OS_MACOSX)
static v8::Handle<v8::Value> SetApplicationMenu(const v8::Arguments &args);
static v8::Handle<v8::Value> SendActionToFirstResponder(
const v8::Arguments &args);
static void SetApplicationMenu(
const v8::FunctionCallbackInfo<v8::Value>& args);
static void SendActionToFirstResponder(
const v8::FunctionCallbackInfo<v8::Value>& args);
#endif
DISALLOW_COPY_AND_ASSIGN(Menu);

2
browser/api/atom_api_menu_mac.h
View file

@ -21,7 +21,7 @@ class MenuMac : public Menu {
protected:
virtual void Popup(NativeWindow* window) OVERRIDE;
scoped_nsobject<AtomMenuController> menu_controller_;
base::scoped_nsobject<AtomMenuController> menu_controller_;
private:
friend class Menu;

26
browser/api/atom_api_menu_mac.mm
View file

@ -4,11 +4,12 @@
#import "browser/api/atom_api_menu_mac.h"
#include "base/message_loop.h"
#include "base/mac/scoped_sending_event.h"
#include "base/message_loop/message_loop.h"
#include "base/strings/sys_string_conversions.h"
#include "browser/native_window.h"
#include "common/v8_conversions.h"
#include "common/v8/node_common.h"
#include "common/v8/native_type_conversions.h"
#include "content/public/browser/web_contents.h"
#include "content/public/browser/web_contents_view.h"
@ -24,7 +25,7 @@ MenuMac::~MenuMac() {
}
void MenuMac::Popup(NativeWindow* native_window) {
scoped_nsobject<AtomMenuController> menu_controller(
base::scoped_nsobject<AtomMenuController> menu_controller(
[[AtomMenuController alloc] initWithModel:model_.get()]);
NSWindow* window = native_window->GetNativeWindow();
@ -46,7 +47,8 @@ void MenuMac::Popup(NativeWindow* native_window) {
{
// Make sure events can be pumped while the menu is up.
MessageLoop::ScopedNestableTaskAllower allow(MessageLoop::current());
base::MessageLoop::ScopedNestableTaskAllower allow(
base::MessageLoop::current());
// One of the events that could be pumped is |window.close()|.
// User-initiated event-tracking loops protect against this by
@ -71,8 +73,8 @@ void MenuMac::SendActionToFirstResponder(const std::string& action) {
}
// static
v8::Handle<v8::Value> Menu::SetApplicationMenu(const v8::Arguments &args) {
v8::HandleScope scope;
void Menu::SetApplicationMenu(const v8::FunctionCallbackInfo<v8::Value>& args) {
v8::HandleScope handle_scope(args.GetIsolate());
if (!args[0]->IsObject())
return node::ThrowTypeError("Bad argument");
@ -81,28 +83,24 @@ v8::Handle<v8::Value> Menu::SetApplicationMenu(const v8::Arguments &args) {
if (!menu)
return node::ThrowError("Menu is destroyed");
scoped_nsobject<AtomMenuController> menu_controller(
base::scoped_nsobject<AtomMenuController> menu_controller(
[[AtomMenuController alloc] initWithModel:menu->model_.get()]);
[NSApp setMainMenu:[menu_controller menu]];
// Ensure the menu_controller_ is destroyed after main menu is set.
menu_controller.swap(menu->menu_controller_);
return v8::Undefined();
}
// static
v8::Handle<v8::Value> Menu::SendActionToFirstResponder(
const v8::Arguments &args) {
v8::HandleScope scope;
void Menu::SendActionToFirstResponder(
const v8::FunctionCallbackInfo<v8::Value>& args) {
v8::HandleScope handle_scope(args.GetIsolate());
std::string action;
if (!FromV8Arguments(args, &action))
return node::ThrowTypeError("Bad argument");
MenuMac::SendActionToFirstResponder(action);
return v8::Undefined();
}
// static

10
browser/api/atom_api_menu_win.cc
View file

@ -6,10 +6,12 @@
#include "browser/native_window_win.h"
#include "browser/ui/win/menu_2.h"
#include "common/v8_conversions.h"
#include "common/v8/native_type_conversions.h"
#include "ui/gfx/point.h"
#include "ui/gfx/screen.h"
#include "common/v8/node_common.h"
namespace atom {
namespace api {
@ -28,8 +30,8 @@ void MenuWin::Popup(NativeWindow* native_window) {
}
// static
v8::Handle<v8::Value> Menu::AttachToWindow(const v8::Arguments& args) {
v8::HandleScope scope;
void Menu::AttachToWindow(const v8::FunctionCallbackInfo<v8::Value>& args) {
v8::HandleScope handle_scope(args.GetIsolate());
Menu* self = ObjectWrap::Unwrap<Menu>(args.This());
if (self == NULL)
@ -40,8 +42,6 @@ v8::Handle<v8::Value> Menu::AttachToWindow(const v8::Arguments& args) {
return node::ThrowTypeError("Bad argument");
static_cast<NativeWindowWin*>(native_window)->SetMenu(self->model_.get());
return v8::Undefined();
}
// static

15
browser/api/atom_api_power_monitor.cc
View file

@ -5,6 +5,9 @@
#include "browser/api/atom_api_power_monitor.h"
#include "base/power_monitor/power_monitor.h"
#include "base/power_monitor/power_monitor_device_source.h"
#include "common/v8/node_common.h"
namespace atom {
@ -35,20 +38,22 @@ void PowerMonitor::OnResume() {
}
// static
v8::Handle<v8::Value> PowerMonitor::New(const v8::Arguments& args) {
v8::HandleScope scope;
void PowerMonitor::New(const v8::FunctionCallbackInfo<v8::Value>& args) {
v8::HandleScope handle_scope(args.GetIsolate());
if (!args.IsConstructCall())
return node::ThrowError("Require constructor call");
new PowerMonitor(args.This());
return args.This();
}
// static
void PowerMonitor::Initialize(v8::Handle<v8::Object> target) {
v8::HandleScope scope;
v8::HandleScope handle_scope(node_isolate);
#if defined(OS_MACOSX)
base::PowerMonitorDeviceSource::AllocateSystemIOPorts();
#endif
v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(
PowerMonitor::New);

2
browser/api/atom_api_power_monitor.h
View file

@ -29,7 +29,7 @@ class PowerMonitor : public EventEmitter,
virtual void OnResume() OVERRIDE;
private:
static v8::Handle<v8::Value> New(const v8::Arguments &args);
static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
DISALLOW_COPY_AND_ASSIGN(PowerMonitor);
};

88
browser/api/atom_api_protocol.cc
View file

@ -9,11 +9,11 @@
#include "browser/net/adapter_request_job.h"
#include "browser/net/atom_url_request_context_getter.h"
#include "browser/net/atom_url_request_job_factory.h"
#include "common/v8_conversions.h"
#include "common/v8/native_type_conversions.h"
#include "content/public/browser/browser_thread.h"
#include "net/url_request/url_request_context.h"
#include "vendor/node/src/node.h"
#include "vendor/node/src/node_internals.h"
#include "common/v8/node_common.h"
namespace atom {
@ -24,10 +24,10 @@ typedef net::URLRequestJobFactory::ProtocolHandler ProtocolHandler;
namespace {
// The protocol module object.
v8::Persistent<v8::Object> g_protocol_object;
ScopedPersistent<v8::Object> g_protocol_object;
// Registered protocol handlers.
typedef std::map<std::string, v8::Persistent<v8::Function>> HandlersMap;
typedef std::map<std::string, RefCountedV8Function> HandlersMap;
static HandlersMap g_handlers;
static const char* kEarlyUseProtocolError = "This method can only be used"
@ -35,25 +35,23 @@ static const char* kEarlyUseProtocolError = "This method can only be used"
// Emit an event for the protocol module.
void EmitEventInUI(const std::string& event, const std::string& parameter) {
v8::HandleScope scope;
v8::HandleScope handle_scope(node_isolate);
v8::Handle<v8::Value> argv[] = {
ToV8Value(event),
ToV8Value(parameter),
ToV8Value(event),
ToV8Value(parameter),
};
node::MakeCallback(g_protocol_object, "emit", arraysize(argv), argv);
node::MakeCallback(g_protocol_object.NewHandle(node_isolate),
"emit", 2, argv);
}
// Convert the URLRequest object to V8 object.
v8::Handle<v8::Object> ConvertURLRequestToV8Object(
const net::URLRequest* request) {
v8::Local<v8::Object> obj = v8::Object::New();
obj->Set(v8::String::New("method"),
v8::String::New(request->method().c_str()));
obj->Set(v8::String::New("url"),
v8::String::New(request->url().spec().c_str()));
obj->Set(v8::String::New("referrer"),
v8::String::New(request->referrer().c_str()));
obj->Set(ToV8Value("method"), ToV8Value(request->method()));
obj->Set(ToV8Value("url"), ToV8Value(request->url().spec()));
obj->Set(ToV8Value("referrer"), ToV8Value(request->referrer()));
return obj;
}
@ -74,13 +72,15 @@ class CustomProtocolRequestJob : public AdapterRequestJob {
virtual void GetJobTypeInUI() OVERRIDE {
DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
v8::HandleScope handle_scope(node_isolate);
// Call the JS handler.
v8::HandleScope scope;
v8::Handle<v8::Value> argv[] = {
ConvertURLRequestToV8Object(request()),
};
v8::Handle<v8::Value> result = g_handlers[request()->url().scheme()]->Call(
v8::Context::GetCurrent()->Global(), arraysize(argv), argv);
RefCountedV8Function callback = g_handlers[request()->url().scheme()];
v8::Handle<v8::Value> result = callback->NewHandle(node_isolate)->Call(
v8::Context::GetCurrent()->Global(), 1, argv);
// Determine the type of the job we are going to create.
if (result->IsString()) {
@ -180,14 +180,15 @@ class CustomProtocolHandler : public ProtocolHandler {
} // namespace
// static
v8::Handle<v8::Value> Protocol::RegisterProtocol(const v8::Arguments& args) {
void Protocol::RegisterProtocol(
const v8::FunctionCallbackInfo<v8::Value>& args) {
std::string scheme;
v8::Persistent<v8::Function> callback;
RefCountedV8Function callback;
if (!FromV8Arguments(args, &scheme, &callback))
return node::ThrowTypeError("Bad argument");
if (g_handlers.find(scheme) != g_handlers.end() ||
net::URLRequest::IsHandledProtocol(scheme))
GetRequestJobFactory()->IsHandledProtocol(scheme))
return node::ThrowError("The scheme is already registered");
if (AtomBrowserContext::Get()->url_request_context_getter() == NULL)
@ -199,12 +200,11 @@ v8::Handle<v8::Value> Protocol::RegisterProtocol(const v8::Arguments& args) {
content::BrowserThread::PostTask(content::BrowserThread::IO,
FROM_HERE,
base::Bind(&RegisterProtocolInIO, scheme));
return v8::Undefined();
}
// static
v8::Handle<v8::Value> Protocol::UnregisterProtocol(const v8::Arguments& args) {
void Protocol::UnregisterProtocol(
const v8::FunctionCallbackInfo<v8::Value>& args) {
std::string scheme;
if (!FromV8Arguments(args, &scheme))
return node::ThrowTypeError("Bad argument");
@ -221,19 +221,23 @@ v8::Handle<v8::Value> Protocol::UnregisterProtocol(const v8::Arguments& args) {
content::BrowserThread::PostTask(content::BrowserThread::IO,
FROM_HERE,
base::Bind(&UnregisterProtocolInIO, scheme));
return v8::Undefined();
}
// static
v8::Handle<v8::Value> Protocol::IsHandledProtocol(const v8::Arguments& args) {
return ToV8Value(net::URLRequest::IsHandledProtocol(FromV8Value(args[0])));
}
// static
v8::Handle<v8::Value> Protocol::InterceptProtocol(const v8::Arguments& args) {
void Protocol::IsHandledProtocol(
const v8::FunctionCallbackInfo<v8::Value>& args) {
std::string scheme;
v8::Persistent<v8::Function> callback;
if (!FromV8Arguments(args, &scheme))
return node::ThrowTypeError("Bad argument");
args.GetReturnValue().Set(GetRequestJobFactory()->IsHandledProtocol(scheme));
}
// static
void Protocol::InterceptProtocol(
const v8::FunctionCallbackInfo<v8::Value>& args) {
std::string scheme;
RefCountedV8Function callback;
if (!FromV8Arguments(args, &scheme, &callback))
return node::ThrowTypeError("Bad argument");
@ -252,11 +256,11 @@ v8::Handle<v8::Value> Protocol::InterceptProtocol(const v8::Arguments& args) {
content::BrowserThread::PostTask(content::BrowserThread::IO,
FROM_HERE,
base::Bind(&InterceptProtocolInIO, scheme));
return v8::Undefined();
}
// static
v8::Handle<v8::Value> Protocol::UninterceptProtocol(const v8::Arguments& args) {
void Protocol::UninterceptProtocol(
const v8::FunctionCallbackInfo<v8::Value>& args) {
std::string scheme;
if (!FromV8Arguments(args, &scheme))
return node::ThrowTypeError("Bad argument");
@ -274,7 +278,6 @@ v8::Handle<v8::Value> Protocol::UninterceptProtocol(const v8::Arguments& args) {
FROM_HERE,
base::Bind(&UninterceptProtocolInIO,
scheme));
return v8::Undefined();
}
// static
@ -361,14 +364,13 @@ void Protocol::UninterceptProtocolInIO(const std::string& scheme) {
// static
void Protocol::Initialize(v8::Handle<v8::Object> target) {
// Remember the protocol object, used for emitting event later.
g_protocol_object = v8::Persistent<v8::Object>::New(
node::node_isolate, target);
g_protocol_object.reset(target);
node::SetMethod(target, "registerProtocol", RegisterProtocol);
node::SetMethod(target, "unregisterProtocol", UnregisterProtocol);
node::SetMethod(target, "isHandledProtocol", IsHandledProtocol);
node::SetMethod(target, "interceptProtocol", InterceptProtocol);
node::SetMethod(target, "uninterceptProtocol", UninterceptProtocol);
NODE_SET_METHOD(target, "registerProtocol", RegisterProtocol);
NODE_SET_METHOD(target, "unregisterProtocol", UnregisterProtocol);
NODE_SET_METHOD(target, "isHandledProtocol", IsHandledProtocol);
NODE_SET_METHOD(target, "interceptProtocol", InterceptProtocol);
NODE_SET_METHOD(target, "uninterceptProtocol", UninterceptProtocol);
}
} // namespace api

14
browser/api/atom_api_protocol.h
View file

@ -20,12 +20,16 @@ class Protocol {
static void Initialize(v8::Handle<v8::Object> target);
private:
static v8::Handle<v8::Value> RegisterProtocol(const v8::Arguments& args);
static v8::Handle<v8::Value> UnregisterProtocol(const v8::Arguments& args);
static v8::Handle<v8::Value> IsHandledProtocol(const v8::Arguments& args);
static void RegisterProtocol(const v8::FunctionCallbackInfo<v8::Value>& args);
static void UnregisterProtocol(
const v8::FunctionCallbackInfo<v8::Value>& args);
static void IsHandledProtocol(
const v8::FunctionCallbackInfo<v8::Value>& args);
static v8::Handle<v8::Value> InterceptProtocol(const v8::Arguments& args);
static v8::Handle<v8::Value> UninterceptProtocol(const v8::Arguments& args);
static void InterceptProtocol(
const v8::FunctionCallbackInfo<v8::Value>& args);
static void UninterceptProtocol(
const v8::FunctionCallbackInfo<v8::Value>& args);
static void RegisterProtocolInIO(const std::string& scheme);
static void UnregisterProtocolInIO(const std::string& scheme);

276
browser/api/atom_api_window.cc
View file

@ -4,14 +4,16 @@
#include "browser/api/atom_api_window.h"
#include "base/process_util.h"
#include "base/process/kill.h"
#include "browser/native_window.h"
#include "common/v8_conversions.h"
#include "common/v8/native_type_conversions.h"
#include "content/public/browser/navigation_entry.h"
#include "content/public/browser/web_contents.h"
#include "content/public/browser/render_process_host.h"
#include "ui/gfx/point.h"
#include "ui/gfx/size.h"
#include "common/v8/node_common.h"
#include "vendor/node/src/node_buffer.h"
using content::NavigationController;
@ -87,23 +89,20 @@ void Window::OnRendererCrashed() {
Emit("crashed");
}
void Window::OnCapturePageDone(v8::Persistent<v8::Function> callback,
void Window::OnCapturePageDone(const RefCountedV8Function& callback,
const std::vector<unsigned char>& data) {
v8::HandleScope scope;
v8::HandleScope handle_scope(node_isolate);
// TODO(zcbenz): Use new Buffer API when we updated to node v0.12.x.
node::Buffer* buffer = node::Buffer::New(
v8::Local<v8::Value> buffer = node::Buffer::New(
reinterpret_cast<const char*>(data.data()),
data.size());
v8::Handle<v8::Value> arg = buffer->handle_;
callback->Call(v8::Context::GetCurrent()->Global(), 1, &arg);
callback.Dispose(v8::Isolate::GetCurrent());
callback->NewHandle(node_isolate)->Call(
v8::Context::GetCurrent()->Global(), 1, &buffer);
}
// static
v8::Handle<v8::Value> Window::New(const v8::Arguments &args) {
v8::HandleScope scope;
void Window::New(const v8::FunctionCallbackInfo<v8::Value>& args) {
v8::HandleScope handle_scope(args.GetIsolate());
if (!args.IsConstructCall())
return node::ThrowError("Require constructor call");
@ -119,12 +118,10 @@ v8::Handle<v8::Value> Window::New(const v8::Arguments &args) {
// Give js code a chance to do initialization.
node::MakeCallback(args.This(), "_init", 0, NULL);
return args.This();
}
// static
v8::Handle<v8::Value> Window::Destroy(const v8::Arguments &args) {
void Window::Destroy(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
base::ProcessHandle handle = self->window_->GetRenderProcessHandle();
@ -135,96 +132,70 @@ v8::Handle<v8::Value> Window::Destroy(const v8::Arguments &args) {
if (!base::WaitForSingleProcess(handle,
base::TimeDelta::FromMilliseconds(500)))
base::KillProcess(handle, 0, true);
return v8::Undefined();
}
// static
v8::Handle<v8::Value> Window::Close(const v8::Arguments &args) {
void Window::Close(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
self->window_->Close();
return v8::Undefined();
}
// static
v8::Handle<v8::Value> Window::Focus(const v8::Arguments &args) {
void Window::Focus(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
self->window_->Focus(args[0]->IsBoolean() ? args[0]->BooleanValue(): true);
return v8::Undefined();
}
// static
v8::Handle<v8::Value> Window::IsFocused(const v8::Arguments &args) {
void Window::IsFocused(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
return ToV8Value(self->window_->IsFocused());
args.GetReturnValue().Set(self->window_->IsFocused());
}
// static
v8::Handle<v8::Value> Window::Show(const v8::Arguments &args) {
void Window::Show(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
self->window_->Show();
return v8::Undefined();
}
// static
v8::Handle<v8::Value> Window::Hide(const v8::Arguments &args) {
void Window::Hide(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
self->window_->Hide();
return v8::Undefined();
}
// static
v8::Handle<v8::Value> Window::IsVisible(const v8::Arguments& args) {
void Window::IsVisible(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
return ToV8Value(self->window_->IsVisible());
return args.GetReturnValue().Set(self->window_->IsVisible());
}
// static
v8::Handle<v8::Value> Window::Maximize(const v8::Arguments &args) {
void Window::Maximize(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
self->window_->Maximize();
return v8::Undefined();
}
// static
v8::Handle<v8::Value> Window::Unmaximize(const v8::Arguments &args) {
void Window::Unmaximize(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
self->window_->Unmaximize();
return v8::Undefined();
}
// static
v8::Handle<v8::Value> Window::Minimize(const v8::Arguments &args) {
void Window::Minimize(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
self->window_->Minimize();
return v8::Undefined();
}
// static
v8::Handle<v8::Value> Window::Restore(const v8::Arguments &args) {
void Window::Restore(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
self->window_->Restore();
return v8::Undefined();
}
// static
v8::Handle<v8::Value> Window::SetFullscreen(const v8::Arguments &args) {
void Window::SetFullscreen(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
bool fs;
@ -232,18 +203,16 @@ v8::Handle<v8::Value> Window::SetFullscreen(const v8::Arguments &args) {
return node::ThrowTypeError("Bad argument");
self->window_->SetFullscreen(fs);
return v8::Undefined();
}
// static
v8::Handle<v8::Value> Window::IsFullscreen(const v8::Arguments &args) {
void Window::IsFullscreen(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
return ToV8Value(self->window_->IsFullscreen());
args.GetReturnValue().Set(self->window_->IsFullscreen());
}
// static
v8::Handle<v8::Value> Window::SetSize(const v8::Arguments &args) {
void Window::SetSize(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
int width, height;
@ -251,11 +220,10 @@ v8::Handle<v8::Value> Window::SetSize(const v8::Arguments &args) {
return node::ThrowTypeError("Bad argument");
self->window_->SetSize(gfx::Size(width, height));
return v8::Undefined();
}
// static
v8::Handle<v8::Value> Window::GetSize(const v8::Arguments &args) {
void Window::GetSize(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
gfx::Size size = self->window_->GetSize();
@ -263,11 +231,11 @@ v8::Handle<v8::Value> Window::GetSize(const v8::Arguments &args) {
ret->Set(0, ToV8Value(size.width()));
ret->Set(1, ToV8Value(size.height()));
return ret;
args.GetReturnValue().Set(ret);
}
// static
v8::Handle<v8::Value> Window::SetMinimumSize(const v8::Arguments &args) {
void Window::SetMinimumSize(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
int width, height;
@ -275,11 +243,10 @@ v8::Handle<v8::Value> Window::SetMinimumSize(const v8::Arguments &args) {
return node::ThrowTypeError("Bad argument");
self->window_->SetMinimumSize(gfx::Size(width, height));
return v8::Undefined();
}
// static
v8::Handle<v8::Value> Window::GetMinimumSize(const v8::Arguments &args) {
void Window::GetMinimumSize(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
gfx::Size size = self->window_->GetMinimumSize();
@ -287,24 +254,22 @@ v8::Handle<v8::Value> Window::GetMinimumSize(const v8::Arguments &args) {
ret->Set(0, ToV8Value(size.width()));
ret->Set(1, ToV8Value(size.height()));
return ret;
args.GetReturnValue().Set(ret);
}
// static
v8::Handle<v8::Value> Window::SetMaximumSize(const v8::Arguments &args) {
void Window::SetMaximumSize(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
int width, height;
if (!FromV8Arguments(args, &width, &height))
return node::ThrowTypeError("Bad argument");
self->window_->SetMaximumSize(gfx::Size(width, height));
return v8::Undefined();
}
// static
v8::Handle<v8::Value> Window::GetMaximumSize(const v8::Arguments &args) {
void Window::GetMaximumSize(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
gfx::Size size = self->window_->GetMaximumSize();
@ -312,11 +277,11 @@ v8::Handle<v8::Value> Window::GetMaximumSize(const v8::Arguments &args) {
ret->Set(0, ToV8Value(size.width()));
ret->Set(1, ToV8Value(size.height()));
return ret;
args.GetReturnValue().Set(ret);
}
// static
v8::Handle<v8::Value> Window::SetResizable(const v8::Arguments &args) {
void Window::SetResizable(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
bool resizable;
@ -324,18 +289,16 @@ v8::Handle<v8::Value> Window::SetResizable(const v8::Arguments &args) {
return node::ThrowTypeError("Bad argument");
self->window_->SetResizable(resizable);
return v8::Undefined();
}
// static
v8::Handle<v8::Value> Window::IsResizable(const v8::Arguments &args) {
void Window::IsResizable(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
return ToV8Value(self->window_->IsResizable());
args.GetReturnValue().Set(self->window_->IsResizable());
}
// static
v8::Handle<v8::Value> Window::SetAlwaysOnTop(const v8::Arguments &args) {
void Window::SetAlwaysOnTop(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
bool top;
@ -343,27 +306,22 @@ v8::Handle<v8::Value> Window::SetAlwaysOnTop(const v8::Arguments &args) {
return node::ThrowTypeError("Bad argument");
self->window_->SetAlwaysOnTop(top);
return v8::Undefined();
}
// static
v8::Handle<v8::Value> Window::IsAlwaysOnTop(const v8::Arguments &args) {
void Window::IsAlwaysOnTop(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
return ToV8Value(self->window_->IsAlwaysOnTop());
args.GetReturnValue().Set(self->window_->IsAlwaysOnTop());
}
// static
v8::Handle<v8::Value> Window::Center(const v8::Arguments &args) {
void Window::Center(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
self->window_->Center();
return v8::Undefined();
}
// static
v8::Handle<v8::Value> Window::SetPosition(const v8::Arguments &args) {
void Window::SetPosition(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
int x, y;
@ -371,11 +329,10 @@ v8::Handle<v8::Value> Window::SetPosition(const v8::Arguments &args) {
return node::ThrowTypeError("Bad argument");
self->window_->SetPosition(gfx::Point(x, y));
return v8::Undefined();
}
// static
v8::Handle<v8::Value> Window::GetPosition(const v8::Arguments &args) {
void Window::GetPosition(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
gfx::Point pos = self->window_->GetPosition();
@ -383,11 +340,11 @@ v8::Handle<v8::Value> Window::GetPosition(const v8::Arguments &args) {
ret->Set(0, ToV8Value(pos.x()));
ret->Set(1, ToV8Value(pos.y()));
return ret;
args.GetReturnValue().Set(ret);
}
// static
v8::Handle<v8::Value> Window::SetTitle(const v8::Arguments &args) {
void Window::SetTitle(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
std::string title;
@ -395,27 +352,23 @@ v8::Handle<v8::Value> Window::SetTitle(const v8::Arguments &args) {
return node::ThrowTypeError("Bad argument");
self->window_->SetTitle(title);
return v8::Undefined();
}
// static
v8::Handle<v8::Value> Window::GetTitle(const v8::Arguments &args) {
void Window::GetTitle(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
return ToV8Value(self->window_->GetTitle());
args.GetReturnValue().Set(ToV8Value(self->window_->GetTitle()));
}
// static
v8::Handle<v8::Value> Window::FlashFrame(const v8::Arguments &args) {
void Window::FlashFrame(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
self->window_->FlashFrame(
args[0]->IsBoolean() ? args[0]->BooleanValue(): true);
return v8::Undefined();
}
// static
v8::Handle<v8::Value> Window::SetKiosk(const v8::Arguments &args) {
void Window::SetKiosk(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
bool kiosk;
@ -423,42 +376,34 @@ v8::Handle<v8::Value> Window::SetKiosk(const v8::Arguments &args) {
return node::ThrowTypeError("Bad argument");
self->window_->SetKiosk(kiosk);
return v8::Undefined();
}
// static
v8::Handle<v8::Value> Window::IsKiosk(const v8::Arguments &args) {
void Window::IsKiosk(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
return ToV8Value(self->window_->IsKiosk());
args.GetReturnValue().Set(self->window_->IsKiosk());
}
// static
v8::Handle<v8::Value> Window::OpenDevTools(const v8::Arguments &args) {
void Window::OpenDevTools(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
self->window_->OpenDevTools();
return v8::Undefined();
}
// static
v8::Handle<v8::Value> Window::CloseDevTools(const v8::Arguments &args) {
void Window::CloseDevTools(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
self->window_->CloseDevTools();
return v8::Undefined();
}
// static
v8::Handle<v8::Value> Window::IsDevToolsOpened(const v8::Arguments& args) {
void Window::IsDevToolsOpened(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
return ToV8Value(self->window_->IsDevToolsOpened());
args.GetReturnValue().Set(self->window_->IsDevToolsOpened());
}
// static
v8::Handle<v8::Value> Window::InspectElement(const v8::Arguments& args) {
void Window::InspectElement(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
int x, y;
@ -466,39 +411,32 @@ v8::Handle<v8::Value> Window::InspectElement(const v8::Arguments& args) {
return node::ThrowTypeError("Bad argument");
self->window_->InspectElement(x, y);
return v8::Undefined();
}
// static
v8::Handle<v8::Value> Window::FocusOnWebView(const v8::Arguments &args) {
void Window::FocusOnWebView(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
self->window_->FocusOnWebView();
return v8::Undefined();
}
// static
v8::Handle<v8::Value> Window::BlurWebView(const v8::Arguments &args) {
void Window::BlurWebView(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
self->window_->BlurWebView();
return v8::Undefined();
}
// static
v8::Handle<v8::Value> Window::IsWebViewFocused(const v8::Arguments& args) {
void Window::IsWebViewFocused(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
return ToV8Value(self->window_->IsWebViewFocused());
args.GetReturnValue().Set(self->window_->IsWebViewFocused());
}
// static
v8::Handle<v8::Value> Window::CapturePage(const v8::Arguments& args) {
void Window::CapturePage(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
gfx::Rect rect;
v8::Persistent<v8::Function> callback;
RefCountedV8Function callback;
if (!FromV8Arguments(args, &rect, &callback) &&
!FromV8Arguments(args, &callback))
return node::ThrowTypeError("Bad argument");
@ -506,64 +444,57 @@ v8::Handle<v8::Value> Window::CapturePage(const v8::Arguments& args) {
self->window_->CapturePage(rect, base::Bind(&Window::OnCapturePageDone,
base::Unretained(self),
callback));
return v8::Undefined();
}
// static
v8::Handle<v8::Value> Window::GetPageTitle(const v8::Arguments &args) {
void Window::GetPageTitle(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
return ToV8Value(self->window_->GetWebContents()->GetTitle());
args.GetReturnValue().Set(ToV8Value(
self->window_->GetWebContents()->GetTitle()));
}
// static
v8::Handle<v8::Value> Window::IsLoading(const v8::Arguments &args) {
void Window::IsLoading(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
return ToV8Value(self->window_->GetWebContents()->IsLoading());
args.GetReturnValue().Set(self->window_->GetWebContents()->IsLoading());
}
// static
v8::Handle<v8::Value> Window::IsWaitingForResponse(const v8::Arguments &args) {
void Window::IsWaitingForResponse(
const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
return ToV8Value(self->window_->GetWebContents()->IsWaitingForResponse());
args.GetReturnValue().Set(
self->window_->GetWebContents()->IsWaitingForResponse());
}
// static
v8::Handle<v8::Value> Window::Stop(const v8::Arguments &args) {
void Window::Stop(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
self->window_->GetWebContents()->Stop();
return v8::Undefined();
}
// static
v8::Handle<v8::Value> Window::GetRoutingID(const v8::Arguments &args) {
void Window::GetRoutingID(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
return ToV8Value(self->window_->GetWebContents()->GetRoutingID());
args.GetReturnValue().Set(self->window_->GetWebContents()->GetRoutingID());
}
// static
v8::Handle<v8::Value> Window::GetProcessID(const v8::Arguments &args) {
void Window::GetProcessID(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
return ToV8Value(
args.GetReturnValue().Set(
self->window_->GetWebContents()->GetRenderProcessHost()->GetID());
}
// static
v8::Handle<v8::Value> Window::IsCrashed(const v8::Arguments &args) {
void Window::IsCrashed(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
return ToV8Value(self->window_->GetWebContents()->IsCrashed());
args.GetReturnValue().Set(self->window_->GetWebContents()->IsCrashed());
}
// static
v8::Handle<v8::Value> Window::LoadURL(const v8::Arguments &args) {
void Window::LoadURL(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
GURL url;
@ -577,12 +508,10 @@ v8::Handle<v8::Value> Window::LoadURL(const v8::Arguments &args) {
params.transition_type = content::PAGE_TRANSITION_TYPED;
params.override_user_agent = content::NavigationController::UA_OVERRIDE_TRUE;
controller.LoadURLWithParams(params);
return v8::Undefined();
}
// static
v8::Handle<v8::Value> Window::GetURL(const v8::Arguments &args) {
void Window::GetURL(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
NavigationController& controller =
@ -591,31 +520,31 @@ v8::Handle<v8::Value> Window::GetURL(const v8::Arguments &args) {
if (controller.GetActiveEntry())
url = controller.GetActiveEntry()->GetVirtualURL();
return ToV8Value(url);
args.GetReturnValue().Set(ToV8Value(url));
}
// static
v8::Handle<v8::Value> Window::CanGoBack(const v8::Arguments &args) {
void Window::CanGoBack(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
NavigationController& controller =
self->window_->GetWebContents()->GetController();
return ToV8Value(controller.CanGoBack());
args.GetReturnValue().Set(controller.CanGoBack());
}
// static
v8::Handle<v8::Value> Window::CanGoForward(const v8::Arguments &args) {
void Window::CanGoForward(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
NavigationController& controller =
self->window_->GetWebContents()->GetController();
return ToV8Value(controller.CanGoForward());
args.GetReturnValue().Set(controller.CanGoForward());
}
// static
v8::Handle<v8::Value> Window::CanGoToOffset(const v8::Arguments &args) {
void Window::CanGoToOffset(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
int offset;
@ -625,33 +554,29 @@ v8::Handle<v8::Value> Window::CanGoToOffset(const v8::Arguments &args) {
NavigationController& controller =
self->window_->GetWebContents()->GetController();
return ToV8Value(controller.CanGoToOffset(offset));
args.GetReturnValue().Set(controller.CanGoToOffset(offset));
}
// static
v8::Handle<v8::Value> Window::GoBack(const v8::Arguments &args) {
void Window::GoBack(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
NavigationController& controller =
self->window_->GetWebContents()->GetController();
controller.GoBack();
return v8::Undefined();
}
// static
v8::Handle<v8::Value> Window::GoForward(const v8::Arguments &args) {
void Window::GoForward(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
NavigationController& controller =
self->window_->GetWebContents()->GetController();
controller.GoForward();
return v8::Undefined();
}
// static
v8::Handle<v8::Value> Window::GoToIndex(const v8::Arguments &args) {
void Window::GoToIndex(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
int index;
@ -661,12 +586,10 @@ v8::Handle<v8::Value> Window::GoToIndex(const v8::Arguments &args) {
NavigationController& controller =
self->window_->GetWebContents()->GetController();
controller.GoToIndex(index);
return v8::Undefined();
}
// static
v8::Handle<v8::Value> Window::GoToOffset(const v8::Arguments &args) {
void Window::GoToOffset(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
int offset;
@ -676,36 +599,31 @@ v8::Handle<v8::Value> Window::GoToOffset(const v8::Arguments &args) {
NavigationController& controller =
self->window_->GetWebContents()->GetController();
controller.GoToOffset(offset);
return v8::Undefined();
}
// static
v8::Handle<v8::Value> Window::Reload(const v8::Arguments &args) {
void Window::Reload(const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
NavigationController& controller =
self->window_->GetWebContents()->GetController();
controller.Reload(args[0]->IsBoolean() ? args[0]->BooleanValue(): false);
return v8::Undefined();
}
// static
v8::Handle<v8::Value> Window::ReloadIgnoringCache(const v8::Arguments &args) {
void Window::ReloadIgnoringCache(
const v8::FunctionCallbackInfo<v8::Value>& args) {
UNWRAP_WINDOW_AND_CHECK;
NavigationController& controller =
self->window_->GetWebContents()->GetController();
controller.ReloadIgnoringCache(
args[0]->IsBoolean() ? args[0]->BooleanValue(): false);
return v8::Undefined();
}
// static
void Window::Initialize(v8::Handle<v8::Object> target) {
v8::HandleScope scope;
v8::HandleScope handle_scope(node_isolate);
v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(Window::New);
t->InstanceTemplate()->SetInternalFieldCount(1);

121
browser/api/atom_api_window.h
View file

@ -10,6 +10,7 @@
#include "base/memory/scoped_ptr.h"
#include "browser/api/atom_api_event_emitter.h"
#include "browser/native_window_observer.h"
#include "common/v8/scoped_persistent.h"
namespace base {
class DictionaryValue;
@ -47,73 +48,75 @@ class Window : public EventEmitter,
virtual void OnRendererCrashed() OVERRIDE;
private:
static v8::Handle<v8::Value> New(const v8::Arguments &args);
static v8::Handle<v8::Value> Destroy(const v8::Arguments &args);
static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
static void Destroy(const v8::FunctionCallbackInfo<v8::Value>& args);
// APIs for NativeWindow.
static v8::Handle<v8::Value> Close(const v8::Arguments &args);
static v8::Handle<v8::Value> Focus(const v8::Arguments &args);
static v8::Handle<v8::Value> IsFocused(const v8::Arguments &args);
static v8::Handle<v8::Value> Show(const v8::Arguments &args);
static v8::Handle<v8::Value> Hide(const v8::Arguments &args);
static v8::Handle<v8::Value> IsVisible(const v8::Arguments &args);
static v8::Handle<v8::Value> Maximize(const v8::Arguments &args);
static v8::Handle<v8::Value> Unmaximize(const v8::Arguments &args);
static v8::Handle<v8::Value> Minimize(const v8::Arguments &args);
static v8::Handle<v8::Value> Restore(const v8::Arguments &args);
static v8::Handle<v8::Value> SetFullscreen(const v8::Arguments &args);
static v8::Handle<v8::Value> IsFullscreen(const v8::Arguments &args);
static v8::Handle<v8::Value> SetSize(const v8::Arguments &args);
static v8::Handle<v8::Value> GetSize(const v8::Arguments &args);
static v8::Handle<v8::Value> SetMinimumSize(const v8::Arguments &args);
static v8::Handle<v8::Value> GetMinimumSize(const v8::Arguments &args);
static v8::Handle<v8::Value> SetMaximumSize(const v8::Arguments &args);
static v8::Handle<v8::Value> GetMaximumSize(const v8::Arguments &args);
static v8::Handle<v8::Value> SetResizable(const v8::Arguments &args);
static v8::Handle<v8::Value> IsResizable(const v8::Arguments &args);
static v8::Handle<v8::Value> SetAlwaysOnTop(const v8::Arguments &args);
static v8::Handle<v8::Value> IsAlwaysOnTop(const v8::Arguments &args);
static v8::Handle<v8::Value> Center(const v8::Arguments &args);
static v8::Handle<v8::Value> SetPosition(const v8::Arguments &args);
static v8::Handle<v8::Value> GetPosition(const v8::Arguments &args);
static v8::Handle<v8::Value> SetTitle(const v8::Arguments &args);
static v8::Handle<v8::Value> GetTitle(const v8::Arguments &args);
static v8::Handle<v8::Value> FlashFrame(const v8::Arguments &args);
static v8::Handle<v8::Value> SetKiosk(const v8::Arguments &args);
static v8::Handle<v8::Value> IsKiosk(const v8::Arguments &args);
static v8::Handle<v8::Value> OpenDevTools(const v8::Arguments &args);
static v8::Handle<v8::Value> CloseDevTools(const v8::Arguments &args);
static v8::Handle<v8::Value> IsDevToolsOpened(const v8::Arguments &args);
static v8::Handle<v8::Value> InspectElement(const v8::Arguments &args);
static v8::Handle<v8::Value> FocusOnWebView(const v8::Arguments &args);
static v8::Handle<v8::Value> BlurWebView(const v8::Arguments &args);
static v8::Handle<v8::Value> IsWebViewFocused(const v8::Arguments& args);
static v8::Handle<v8::Value> CapturePage(const v8::Arguments& args);
static void Close(const v8::FunctionCallbackInfo<v8::Value>& args);
static void Focus(const v8::FunctionCallbackInfo<v8::Value>& args);
static void IsFocused(const v8::FunctionCallbackInfo<v8::Value>& args);
static void Show(const v8::FunctionCallbackInfo<v8::Value>& args);
static void Hide(const v8::FunctionCallbackInfo<v8::Value>& args);
static void IsVisible(const v8::FunctionCallbackInfo<v8::Value>& args);
static void Maximize(const v8::FunctionCallbackInfo<v8::Value>& args);
static void Unmaximize(const v8::FunctionCallbackInfo<v8::Value>& args);
static void Minimize(const v8::FunctionCallbackInfo<v8::Value>& args);
static void Restore(const v8::FunctionCallbackInfo<v8::Value>& args);
static void SetFullscreen(const v8::FunctionCallbackInfo<v8::Value>& args);
static void IsFullscreen(const v8::FunctionCallbackInfo<v8::Value>& args);
static void SetSize(const v8::FunctionCallbackInfo<v8::Value>& args);
static void GetSize(const v8::FunctionCallbackInfo<v8::Value>& args);
static void SetMinimumSize(const v8::FunctionCallbackInfo<v8::Value>& args);
static void GetMinimumSize(const v8::FunctionCallbackInfo<v8::Value>& args);
static void SetMaximumSize(const v8::FunctionCallbackInfo<v8::Value>& args);
static void GetMaximumSize(const v8::FunctionCallbackInfo<v8::Value>& args);
static void SetResizable(const v8::FunctionCallbackInfo<v8::Value>& args);
static void IsResizable(const v8::FunctionCallbackInfo<v8::Value>& args);
static void SetAlwaysOnTop(const v8::FunctionCallbackInfo<v8::Value>& args);
static void IsAlwaysOnTop(const v8::FunctionCallbackInfo<v8::Value>& args);
static void Center(const v8::FunctionCallbackInfo<v8::Value>& args);
static void SetPosition(const v8::FunctionCallbackInfo<v8::Value>& args);
static void GetPosition(const v8::FunctionCallbackInfo<v8::Value>& args);
static void SetTitle(const v8::FunctionCallbackInfo<v8::Value>& args);
static void GetTitle(const v8::FunctionCallbackInfo<v8::Value>& args);
static void FlashFrame(const v8::FunctionCallbackInfo<v8::Value>& args);
static void SetKiosk(const v8::FunctionCallbackInfo<v8::Value>& args);
static void IsKiosk(const v8::FunctionCallbackInfo<v8::Value>& args);
static void OpenDevTools(const v8::FunctionCallbackInfo<v8::Value>& args);
static void CloseDevTools(const v8::FunctionCallbackInfo<v8::Value>& args);
static void IsDevToolsOpened(const v8::FunctionCallbackInfo<v8::Value>& args);
static void InspectElement(const v8::FunctionCallbackInfo<v8::Value>& args);
static void FocusOnWebView(const v8::FunctionCallbackInfo<v8::Value>& args);
static void BlurWebView(const v8::FunctionCallbackInfo<v8::Value>& args);
static void IsWebViewFocused(const v8::FunctionCallbackInfo<v8::Value>& args);
static void CapturePage(const v8::FunctionCallbackInfo<v8::Value>& args);
// APIs for WebContents.
static v8::Handle<v8::Value> GetPageTitle(const v8::Arguments &args);
static v8::Handle<v8::Value> IsLoading(const v8::Arguments &args);
static v8::Handle<v8::Value> IsWaitingForResponse(const v8::Arguments &args);
static v8::Handle<v8::Value> Stop(const v8::Arguments &args);
static v8::Handle<v8::Value> GetRoutingID(const v8::Arguments &args);
static v8::Handle<v8::Value> GetProcessID(const v8::Arguments &args);
static v8::Handle<v8::Value> IsCrashed(const v8::Arguments &args);
static void GetPageTitle(const v8::FunctionCallbackInfo<v8::Value>& args);
static void IsLoading(const v8::FunctionCallbackInfo<v8::Value>& args);
static void IsWaitingForResponse(
const v8::FunctionCallbackInfo<v8::Value>& args);
static void Stop(const v8::FunctionCallbackInfo<v8::Value>& args);
static void GetRoutingID(const v8::FunctionCallbackInfo<v8::Value>& args);
static void GetProcessID(const v8::FunctionCallbackInfo<v8::Value>& args);
static void IsCrashed(const v8::FunctionCallbackInfo<v8::Value>& args);
// APIs for NavigationController.
static v8::Handle<v8::Value> LoadURL(const v8::Arguments &args);
static v8::Handle<v8::Value> GetURL(const v8::Arguments &args);
static v8::Handle<v8::Value> CanGoBack(const v8::Arguments &args);
static v8::Handle<v8::Value> CanGoForward(const v8::Arguments &args);
static v8::Handle<v8::Value> CanGoToOffset(const v8::Arguments &args);
static v8::Handle<v8::Value> GoBack(const v8::Arguments &args);
static v8::Handle<v8::Value> GoForward(const v8::Arguments &args);
static v8::Handle<v8::Value> GoToIndex(const v8::Arguments &args);
static v8::Handle<v8::Value> GoToOffset(const v8::Arguments &args);
static v8::Handle<v8::Value> Reload(const v8::Arguments &args);
static v8::Handle<v8::Value> ReloadIgnoringCache(const v8::Arguments &args);
static void LoadURL(const v8::FunctionCallbackInfo<v8::Value>& args);
static void GetURL(const v8::FunctionCallbackInfo<v8::Value>& args);
static void CanGoBack(const v8::FunctionCallbackInfo<v8::Value>& args);
static void CanGoForward(const v8::FunctionCallbackInfo<v8::Value>& args);
static void CanGoToOffset(const v8::FunctionCallbackInfo<v8::Value>& args);
static void GoBack(const v8::FunctionCallbackInfo<v8::Value>& args);
static void GoForward(const v8::FunctionCallbackInfo<v8::Value>& args);
static void GoToIndex(const v8::FunctionCallbackInfo<v8::Value>& args);
static void GoToOffset(const v8::FunctionCallbackInfo<v8::Value>& args);
static void Reload(const v8::FunctionCallbackInfo<v8::Value>& args);
static void ReloadIgnoringCache(
const v8::FunctionCallbackInfo<v8::Value>& args);
// Called when capturePage is done.
void OnCapturePageDone(v8::Persistent<v8::Function> callback,
void OnCapturePageDone(const RefCountedV8Function& callback,
const std::vector<unsigned char>& data);
scoped_ptr<NativeWindow> window_;

53
browser/api/atom_browser_bindings.cc
View file

@ -8,13 +8,10 @@
#include "base/logging.h"
#include "browser/api/atom_api_event.h"
#include "common/v8_conversions.h"
#include "common/v8/native_type_conversions.h"
#include "content/public/browser/browser_thread.h"
#include "vendor/node/src/node.h"
#include "vendor/node/src/node_internals.h"
using content::V8ValueConverter;
using node::node_isolate;
#include "common/v8/node_common.h"
namespace atom {
@ -24,31 +21,13 @@ AtomBrowserBindings::AtomBrowserBindings() {
AtomBrowserBindings::~AtomBrowserBindings() {
}
void AtomBrowserBindings::AfterLoad() {
DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
v8::HandleScope scope;
v8::Handle<v8::Object> global = node::g_context->Global();
v8::Handle<v8::Object> atom =
global->Get(v8::String::New("__atom"))->ToObject();
DCHECK(!atom.IsEmpty());
browser_main_parts_ = v8::Persistent<v8::Object>::New(
node_isolate,
atom->Get(v8::String::New("browserMainParts"))->ToObject());
DCHECK(!browser_main_parts_.IsEmpty());
}
void AtomBrowserBindings::OnRendererMessage(int process_id,
int routing_id,
const string16& channel,
const base::ListValue& args) {
v8::HandleScope scope;
v8::HandleScope handle_scope(node_isolate);
v8::Handle<v8::Context> context = v8::Context::GetCurrent();
scoped_ptr<V8ValueConverter> converter(new V8ValueConverterImpl());
scoped_ptr<V8ValueConverter> converter(new V8ValueConverter);
// process.emit(channel, 'message', process_id, routing_id);
std::vector<v8::Handle<v8::Value>> arguments;
@ -56,17 +35,20 @@ void AtomBrowserBindings::OnRendererMessage(int process_id,
arguments.push_back(ToV8Value(channel));
const base::Value* value;
if (args.Get(0, &value))
arguments.push_back(converter->ToV8Value(value, context));
arguments.push_back(converter->ToV8Value(value, global_env->context()));
arguments.push_back(v8::Integer::New(process_id));
arguments.push_back(v8::Integer::New(routing_id));
for (size_t i = 1; i < args.GetSize(); i++) {
const base::Value* value;
if (args.Get(i, &value))
arguments.push_back(converter->ToV8Value(value, context));
arguments.push_back(converter->ToV8Value(value, global_env->context()));
}
node::MakeCallback(node::process, "emit", arguments.size(), &arguments[0]);
node::MakeCallback(global_env->process_object(),
"emit",
arguments.size(),
&arguments[0]);
}
void AtomBrowserBindings::OnRendererMessageSync(
@ -76,11 +58,9 @@ void AtomBrowserBindings::OnRendererMessageSync(
const base::ListValue& args,
NativeWindow* sender,
IPC::Message* message) {
v8::HandleScope scope;
v8::HandleScope handle_scope(node_isolate);
v8::Handle<v8::Context> context = v8::Context::GetCurrent();
scoped_ptr<V8ValueConverter> converter(new V8ValueConverterImpl());
scoped_ptr<V8ValueConverter> converter(new V8ValueConverter);
// Create the event object.
v8::Handle<v8::Object> event = api::Event::CreateV8Object();
@ -92,7 +72,7 @@ void AtomBrowserBindings::OnRendererMessageSync(
arguments.push_back(ToV8Value(channel));
const base::Value* value;
if (args.Get(0, &value))
arguments.push_back(converter->ToV8Value(value, context));
arguments.push_back(converter->ToV8Value(value, global_env->context()));
arguments.push_back(event);
arguments.push_back(v8::Integer::New(process_id));
arguments.push_back(v8::Integer::New(routing_id));
@ -100,10 +80,13 @@ void AtomBrowserBindings::OnRendererMessageSync(
for (size_t i = 1; i < args.GetSize(); i++) {
const base::Value* value;
if (args.Get(i, &value))
arguments.push_back(converter->ToV8Value(value, context));
arguments.push_back(converter->ToV8Value(value, global_env->context()));
}
node::MakeCallback(node::process, "emit", arguments.size(), &arguments[0]);
node::MakeCallback(global_env->process_object(),
"emit",
arguments.size(),
&arguments[0]);
}
} // namespace atom

13
browser/api/atom_browser_bindings.h
View file

@ -5,8 +5,9 @@
#ifndef ATOM_BROWSER_API_ATOM_BROWSER_BINDINGS_
#define ATOM_BROWSER_API_ATOM_BROWSER_BINDINGS_
#include "base/string16.h"
#include "base/strings/string16.h"
#include "common/api/atom_bindings.h"
#include "common/v8/scoped_persistent.h"
namespace base {
class ListValue;
@ -25,9 +26,6 @@ class AtomBrowserBindings : public AtomBindings {
AtomBrowserBindings();
virtual ~AtomBrowserBindings();
// Called when the node.js main script has been loaded.
virtual void AfterLoad();
// Called when received a message from renderer.
void OnRendererMessage(int process_id,
int routing_id,
@ -42,14 +40,7 @@ class AtomBrowserBindings : public AtomBindings {
NativeWindow* sender,
IPC::Message* message);
// The require('atom').browserMainParts object.
v8::Handle<v8::Object> browser_main_parts() {
return browser_main_parts_;
}
private:
v8::Persistent<v8::Object> browser_main_parts_;
DISALLOW_COPY_AND_ASSIGN(AtomBrowserBindings);
};

12
browser/api/lib/app.coffee
View file

@ -1,6 +1,8 @@
bindings = process.atomBinding 'app'
BrowserWindow = require 'browser-window'
EventEmitter = require('events').EventEmitter
bindings = process.atomBinding 'app'
Application = bindings.Application
Application::__proto__ = EventEmitter.prototype
@ -9,9 +11,6 @@ app = new Application
app.getHomeDir = ->
process.env[if process.platform is 'win32' then 'USERPROFILE' else 'HOME']
app.getBrowserWindows = ->
require('../../atom/objects-registry.js').getAllWindows()
app.setApplicationMenu = (menu) ->
require('menu').setApplicationMenu menu
@ -24,10 +23,13 @@ app.commandLine =
if process.platform is 'darwin'
app.dock =
bounce: (type = 'informational') -> bindings.dockBounce type
bounce: (type='informational') -> bindings.dockBounce type
cancelBounce: bindings.dockCancelBounce
setBadge: bindings.dockSetBadgeText
getBadge: bindings.dockGetBadgeText
# Support old event name.
app.once 'ready', -> app.emit 'finish-launching'
# Only one App object pemitted.
module.exports = app

1
browser/api/lib/atom-delegate.coffee
View file

@ -1 +0,0 @@
module.exports = global.__atom

21
browser/api/lib/browser-window.coffee
View file

@ -1,16 +1,27 @@
EventEmitter = require('events').EventEmitter
IDWeakMap = require 'id-weak-map'
app = require 'app'
v8Util = process.atomBinding 'v8_util'
BrowserWindow = process.atomBinding('window').BrowserWindow
BrowserWindow::__proto__ = EventEmitter.prototype
# Store all created windows in the weak map.
BrowserWindow.windows = new IDWeakMap
BrowserWindow::_init = ->
# Simulate the application menu on platforms other than OS X.
if process.platform isnt 'darwin'
menu = app.getApplicationMenu()
@setMenu menu if menu?
# Remember the window.
id = BrowserWindow.windows.add this
# Remove the window from weak map immediately when it's destroyed, since we
# could be iterating windows before GC happended.
@once 'destroyed', ->
BrowserWindow.windows.remove id if BrowserWindow.windows.has id
# Tell the rpc server that a render view has been deleted and we need to
# release all objects owned by it.
@on 'render-view-deleted', (event, processId, routingId) ->
@ -30,12 +41,16 @@ BrowserWindow::setMenu = (menu) ->
@menu = menu # Keep a reference of menu in case of GC.
@menu.attachToWindow this
BrowserWindow.getAllWindows = ->
windows = BrowserWindow.windows
windows.get key for key in windows.keys()
BrowserWindow.getFocusedWindow = ->
windows = app.getBrowserWindows()
windows = BrowserWindow.getAllWindows()
return window for window in windows when window.isFocused()
BrowserWindow.fromProcessIdAndRoutingId = (processId, routingId) ->
windows = app.getBrowserWindows()
windows = BrowserWindow.getAllWindows()
return window for window in windows when window.getProcessId() == processId and
window.getRoutingId() == routingId

4
browser/api/lib/menu.coffee
View file

@ -1,9 +1,7 @@
BrowserWindow = require 'browser-window'
EventEmitter = require('events').EventEmitter
IDWeakMap = require 'id-weak-map'
MenuItem = require 'menu-item'
app = require 'app'
bindings = process.atomBinding 'menu'
Menu = bindings.Menu
@ -52,7 +50,7 @@ Menu.setApplicationMenu = (menu) ->
if process.platform is 'darwin'
bindings.setApplicationMenu menu
else
windows = app.getBrowserWindows()
windows = BrowserWindow.getAllWindows()
w.setMenu menu for w in windows
Menu.getApplicationMenu = -> applicationMenu

73
browser/atom/atom.coffee
View file

@ -1,73 +0,0 @@
fs = require 'fs'
path = require 'path'
if process.platform is 'win32'
# Redirect node's console to use our own implementations, since node can not
# handle output when running as GUI program.
console.log = console.error = console.warn = process.log
process.stdout.write = process.stderr.write = process.log
# Always returns EOF for stdin stream.
Readable = require('stream').Readable
stdin = new Readable
stdin.push null
process.__defineGetter__ 'stdin', -> stdin
# Provide default Content API implementations.
atom = {}
atom.browserMainParts =
preMainMessageLoopRun: ->
# This is the start of the whole application, usually we should initialize
# the main window here.
# Store atom object in global scope, apps can just override methods of it to
# implement various logics.
global.__atom = atom
# Add browser/api/lib to require's search paths,
# which contains javascript part of Atom's built-in libraries.
globalPaths = require('module').globalPaths
globalPaths.push path.join process.resourcesPath, 'browser', 'api', 'lib'
# And also common/api/lib
globalPaths.push path.join process.resourcesPath, 'common', 'api', 'lib'
# Don't quit on fatal error.
process.on 'uncaughtException', (error) ->
# Show error in GUI.
message = error.stack ? "#{error.name}: #{error.message}"
require('dialog').showMessageBox
type: 'warning'
title: 'An javascript error occured in the browser'
message: 'uncaughtException'
detail: message
buttons: ['OK']
# Load the RPC server.
require './rpc-server.js'
# Now we try to load app's package.json.
packageJson = null
packagePath = path.join process.resourcesPath, 'app'
try
# First we try to load process.resourcesPath/app
packageJson = JSON.parse(fs.readFileSync(path.join(packagePath, 'package.json')))
catch error
# If not found then we load browser/default_app
packagePath = path.join process.resourcesPath, 'browser', 'default_app'
packageJson = JSON.parse(fs.readFileSync(path.join(packagePath, 'package.json')))
# Set application's version.
app = require 'app'
app.setVersion packageJson.version if packageJson.version?
# Set application's name.
if packageJson.productName?
app.setName packageJson.productName
else if packageJson.name?
app.setName packageJson.name
# Finally load app's main.js and transfer control to C++.
require path.join(packagePath, packageJson.main)

2
browser/atom_browser_client.cc
View file

@ -7,7 +7,7 @@
#include "browser/atom_browser_context.h"
#include "browser/atom_browser_main_parts.h"
#include "browser/net/atom_url_request_context_getter.h"
#include "webkit/glue/webpreferences.h"
#include "webkit/common/webpreferences.h"
namespace atom {

8
browser/atom_browser_context.cc
View file

@ -33,6 +33,14 @@ class AtomResourceContext : public content::ResourceContext {
return getter_->GetURLRequestContext();
}
virtual bool AllowMicAccess(const GURL& origin) OVERRIDE {
return true;
}
virtual bool AllowCameraAccess(const GURL& origin) OVERRIDE {
return true;
}
private:
AtomURLRequestContextGetter* getter_;

55
browser/atom_browser_main_parts.cc
View file

@ -4,15 +4,18 @@
#include "browser/atom_browser_main_parts.h"
#include "base/power_monitor/power_monitor.h"
#include "browser/api/atom_browser_bindings.h"
#include "browser/atom_browser_client.h"
#include "browser/atom_browser_context.h"
#include "browser/browser.h"
#include "common/node_bindings.h"
#include "net/proxy/proxy_resolver_v8.h"
#include "vendor/node/src/node.h"
#include "vendor/node/src/node_internals.h"
#if defined(OS_WIN)
#include "ui/gfx/win/dpi.h"
#endif
#include "common/v8/node_common.h"
namespace atom {
@ -43,37 +46,28 @@ brightray::BrowserContext* AtomBrowserMainParts::CreateBrowserContext() {
void AtomBrowserMainParts::PostEarlyInitialization() {
brightray::BrowserMainParts::PostEarlyInitialization();
#if defined(OS_MACOSX)
base::PowerMonitor::AllocateSystemIOPorts();
#endif
node_bindings_->Initialize();
v8::V8::Initialize();
// Create context.
v8::HandleScope handle_scope(node_isolate);
v8::Local<v8::Context> context = v8::Context::New(node_isolate);
// Create the global environment.
global_env = node_bindings_->CreateEnvironment(context);
// Wrap whole process in one global context.
node::g_context->Enter();
context->Enter();
atom_bindings_->BindTo(node::process);
node_bindings_->Load();
atom_bindings_->AfterLoad();
// Add atom-shell extended APIs.
atom_bindings_->BindTo(global_env->process_object());
}
void AtomBrowserMainParts::PreMainMessageLoopRun() {
node_bindings_->PrepareMessageLoop();
brightray::BrowserMainParts::PreMainMessageLoopRun();
{
v8::HandleScope scope;
v8::Context::Scope context_scope(node::g_context);
v8::Handle<v8::Value> args;
node::MakeCallback(atom_bindings_->browser_main_parts(),
"preMainMessageLoopRun",
0, &args);
}
node_bindings_->PrepareMessageLoop();
node_bindings_->RunMessageLoop();
// Make sure the url request job factory is created before the
@ -89,8 +83,17 @@ void AtomBrowserMainParts::PreMainMessageLoopRun() {
}
int AtomBrowserMainParts::PreCreateThreads() {
// TODO(zcbenz): Calling CreateIsolate() on Windows when updated to Chrome30.
// Note that we are overriding the PreCreateThreads of brightray, since we
// are integrating node in browser, we can just be sure that an V8 instance
// would be prepared, while the ProxyResolverV8::CreateIsolate() would
// try to create a V8 isolate, which messed everything on Windows, so we
// have to override and call RememberDefaultIsolate on Windows instead.
net::ProxyResolverV8::RememberDefaultIsolate();
#if defined(OS_WIN)
gfx::EnableHighDPISupport();
#endif
return 0;
}

2
browser/atom_javascript_dialog_manager.cc
View file

@ -4,7 +4,7 @@
#include "browser/atom_javascript_dialog_manager.h"
#include "base/utf_string_conversions.h"
#include "base/strings/utf_string_conversions.h"
namespace atom {

4
browser/atom_javascript_dialog_manager.h
View file

@ -26,7 +26,9 @@ class AtomJavaScriptDialogManager : public content::JavaScriptDialogManager {
const string16& message_text,
bool is_reload,
const DialogClosedCallback& callback) OVERRIDE;
virtual void ResetJavaScriptState(
virtual void CancelActiveAndPendingDialogs(
content::WebContents* web_contents) OVERRIDE {}
virtual void WebContentsDestroyed(
content::WebContents* web_contents) OVERRIDE {}
};

3
browser/default_app/default_app.js
View file

@ -1,6 +1,5 @@
var app = require('app');
var dialog = require('dialog');
var delegate = require('atom-delegate');
var ipc = require('ipc');
var Menu = require('menu');
var MenuItem = require('menu-item');
@ -18,7 +17,7 @@ app.on('open-url', function(event, url) {
dialog.showMessageBox({message: url, buttons: ['OK']});
});
app.on('finish-launching', function() {
app.on('ready', function() {
app.commandLine.appendSwitch('js-flags', '--harmony_collections');
mainWindow = new BrowserWindow({ width: 800, height: 600 });

72
browser/lib/init.coffee Normal file
View file

@ -0,0 +1,72 @@
fs = require 'fs'
path = require 'path'
# Expose information of current process.
process.__atom_type = 'browser'
process.resourcesPath = path.resolve process.argv[1], '..', '..', '..'
# We modified the original process.argv to let node.js load the atom.js,
# we need to restore it here.
process.argv.splice 1, 1
if process.platform is 'win32'
# Redirect node's console to use our own implementations, since node can not
# handle output when running as GUI program.
console.log = console.error = console.warn = process.log
process.stdout.write = process.stderr.write = process.log
# Always returns EOF for stdin stream.
Readable = require('stream').Readable
stdin = new Readable
stdin.push null
process.__defineGetter__ 'stdin', -> stdin
# Add browser/api/lib to require's search paths,
# which contains javascript part of Atom's built-in libraries.
globalPaths = require('module').globalPaths
globalPaths.push path.join process.resourcesPath, 'browser', 'api', 'lib'
# And also common/api/lib
globalPaths.push path.join process.resourcesPath, 'common', 'api', 'lib'
# Do loading in next tick since we still need some initialize work before
# native bindings can work.
setImmediate ->
# Don't quit on fatal error.
process.on 'uncaughtException', (error) ->
# Show error in GUI.
message = error.stack ? "#{error.name}: #{error.message}"
require('dialog').showMessageBox
type: 'warning'
title: 'An javascript error occured in the browser'
message: 'uncaughtException'
detail: message
buttons: ['OK']
# Load the RPC server.
require './rpc-server.js'
# Now we try to load app's package.json.
packageJson = null
packagePath = path.join process.resourcesPath, 'app'
try
# First we try to load process.resourcesPath/app
packageJson = JSON.parse(fs.readFileSync(path.join(packagePath, 'package.json')))
catch error
# If not found then we load browser/default_app
packagePath = path.join process.resourcesPath, 'browser', 'default_app'
packageJson = JSON.parse(fs.readFileSync(path.join(packagePath, 'package.json')))
# Set application's version.
app = require 'app'
app.setVersion packageJson.version if packageJson.version?
# Set application's name.
if packageJson.productName?
app.setName packageJson.productName
else if packageJson.name?
app.setName packageJson.name
# Finally load app's main.js and transfer control to C++.
require path.join(packagePath, packageJson.main)

15
browser/atom/objects-registry.coffee → browser/lib/objects-registry.coffee
View file

@ -1,4 +1,3 @@
BrowserWindow = require 'browser-window'
EventEmitter = require('events').EventEmitter
IDWeakMap = require 'id-weak-map'
v8Util = process.atomBinding 'v8_util'
@ -41,6 +40,8 @@ class ObjectsStore
class ObjectsRegistry extends EventEmitter
constructor: ->
@setMaxListeners Number.MAX_VALUE
# Objects in weak map will be not referenced (so we won't leak memory), and
# every object created in browser will have a unique id in weak map.
@objectsWeakMap = new IDWeakMap
@ -49,13 +50,6 @@ class ObjectsRegistry extends EventEmitter
v8Util.setHiddenValue obj, 'atomId', id
id
# Remember all windows in the weak map.
@windowsWeakMap = new IDWeakMap
process.on 'ATOM_BROWSER_INTERNAL_NEW', (obj) =>
if obj.constructor is BrowserWindow
id = @windowsWeakMap.add obj
obj.on 'destroyed', => @windowsWeakMap.remove id
# Register a new object, the object would be kept referenced until you release
# it explicitly.
add: (processId, routingId, obj) ->
@ -87,9 +81,4 @@ class ObjectsRegistry extends EventEmitter
@emit "release-renderer-view-#{processId}-#{routingId}"
ObjectsStore.releaseForRenderView processId, routingId
# Return an array of all browser windows.
getAllWindows: ->
keys = @windowsWeakMap.keys()
@windowsWeakMap.get key for key in keys
module.exports = new ObjectsRegistry

0
browser/atom/rpc-server.coffee → browser/lib/rpc-server.coffee
View file

41
browser/native_window.cc
View file

@ -7,9 +7,9 @@
#include <string>
#include "base/file_util.h"
#include "base/message_loop.h"
#include "base/stringprintf.h"
#include "base/utf_string_conversions.h"
#include "base/message_loop/message_loop.h"
#include "base/strings/stringprintf.h"
#include "base/strings/utf_string_conversions.h"
#include "base/values.h"
#include "brightray/browser/inspectable_web_contents.h"
#include "brightray/browser/inspectable_web_contents_view.h"
@ -37,8 +37,7 @@
#include "ui/gfx/point.h"
#include "ui/gfx/rect.h"
#include "ui/gfx/size.h"
#include "webkit/glue/image_decoder.h"
#include "webkit/user_agent/user_agent_util.h"
#include "webkit/common/user_agent/user_agent_util.h"
using content::NavigationEntry;
@ -165,7 +164,7 @@ void NativeWindow::CloseDevTools() {
}
bool NativeWindow::IsDevToolsOpened() {
return inspectable_web_contents()->IsDevToolsOpened();
return inspectable_web_contents()->IsDevToolsViewShowing();
}
void NativeWindow::InspectElement(int x, int y) {
@ -193,15 +192,14 @@ bool NativeWindow::SetIcon(const std::string& str_path) {
// Read the file from disk.
std::string file_contents;
if (path.empty() || !file_util::ReadFileToString(path, &file_contents))
if (path.empty() || !base::ReadFileToString(path, &file_contents))
return false;
// Decode the bitmap using WebKit's image decoder.
const unsigned char* data =
reinterpret_cast<const unsigned char*>(file_contents.data());
webkit_glue::ImageDecoder decoder;
scoped_ptr<SkBitmap> decoded(new SkBitmap());
*decoded = decoder.Decode(data, file_contents.length());
gfx::PNGCodec::Decode(data, file_contents.length(), decoded.get());
if (decoded->empty())
return false; // Unable to decode.
@ -383,6 +381,21 @@ void NativeWindow::RendererResponsive(content::WebContents* source) {
FOR_EACH_OBSERVER(NativeWindowObserver, observers_, OnRendererResponsive());
}
void NativeWindow::RenderViewDeleted(content::RenderViewHost* rvh) {
FOR_EACH_OBSERVER(NativeWindowObserver, observers_,
OnRenderViewDeleted(rvh->GetProcess()->GetID(),
rvh->GetRoutingID()));
}
void NativeWindow::RenderProcessGone(base::TerminationStatus status) {
FOR_EACH_OBSERVER(NativeWindowObserver, observers_, OnRendererCrashed());
}
void NativeWindow::BeforeUnloadFired(const base::TimeTicks& proceed_time) {
// Do nothing, we override this method just to avoid compilation error since
// there are two virtual functions named BeforeUnloadFired.
}
bool NativeWindow::OnMessageReceived(const IPC::Message& message) {
bool handled = true;
IPC_BEGIN_MESSAGE_MAP(NativeWindow, message)
@ -397,16 +410,6 @@ bool NativeWindow::OnMessageReceived(const IPC::Message& message) {
return handled;
}
void NativeWindow::RenderViewDeleted(content::RenderViewHost* rvh) {
FOR_EACH_OBSERVER(NativeWindowObserver, observers_,
OnRenderViewDeleted(rvh->GetProcess()->GetID(),
rvh->GetRoutingID()));
}
void NativeWindow::RenderViewGone(base::TerminationStatus status) {
FOR_EACH_OBSERVER(NativeWindowObserver, observers_, OnRendererCrashed());
}
void NativeWindow::Observe(int type,
const content::NotificationSource& source,
const content::NotificationDetails& details) {

3
browser/native_window.h
View file

@ -184,7 +184,8 @@ class NativeWindow : public brightray::DefaultWebContentsDelegate,
// Implementations of content::WebContentsObserver.
virtual void RenderViewDeleted(content::RenderViewHost*) OVERRIDE;
virtual void RenderViewGone(base::TerminationStatus status) OVERRIDE;
virtual void RenderProcessGone(base::TerminationStatus status) OVERRIDE;
virtual void BeforeUnloadFired(const base::TimeTicks& proceed_time) OVERRIDE;
virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
// Implementations of content::NotificationObserver

5
browser/native_window_mac.mm
View file

@ -11,6 +11,7 @@
#define BASE_MAC_FOUNDATION_UTIL_H_
#include "base/mac/mac_util.h"
#include "base/mac/scoped_nsobject.h"
#include "base/strings/sys_string_conversions.h"
#include "base/values.h"
#import "browser/ui/atom_event_processing_window.h"
@ -490,7 +491,7 @@ void NativeWindowMac::InstallDraggableRegionViews() {
// Note that [webView subviews] returns the view's mutable internal array and
// it should be copied to avoid mutating the original array while enumerating
// it.
scoped_nsobject<NSArray> subviews([[webView subviews] copy]);
base::scoped_nsobject<NSArray> subviews([[webView subviews] copy]);
for (NSView* subview in subviews.get())
if ([subview isKindOfClass:[ControlRegionView class]])
[subview removeFromSuperview];
@ -501,7 +502,7 @@ void NativeWindowMac::InstallDraggableRegionViews() {
system_drag_exclude_areas_.begin();
iter != system_drag_exclude_areas_.end();
++iter) {
scoped_nsobject<NSView> controlRegion(
base::scoped_nsobject<NSView> controlRegion(
[[ControlRegionView alloc] initWithShellWindow:this]);
[controlRegion setFrame:NSMakeRect(iter->x(),
webViewHeight - iter->bottom(),

7
browser/native_window_win.cc
View file

@ -439,10 +439,9 @@ void NativeWindowWin::Layout() {
OnViewWasResized();
}
void NativeWindowWin::ViewHierarchyChanged(bool is_add,
views::View* parent,
views::View* child) {
if (is_add && child == this)
void NativeWindowWin::ViewHierarchyChanged(
const ViewHierarchyChangedDetails& details) {
if (details.is_add && details.child == this)
AddChildView(web_view_);
}

7
browser/native_window_win.h
View file

@ -5,7 +5,7 @@
#ifndef ATOM_BROWSER_NATIVE_WINDOW_WIN_H_
#define ATOM_BROWSER_NATIVE_WINDOW_WIN_H_
#include "base/string16.h"
#include "base/strings/string16.h"
#include "base/memory/scoped_ptr.h"
#include "browser/native_window.h"
@ -87,9 +87,8 @@ class NativeWindowWin : public NativeWindow,
// Overridden from views::View:
virtual void Layout() OVERRIDE;
virtual void ViewHierarchyChanged(bool is_add,
views::View* parent,
views::View* child) OVERRIDE;
virtual void ViewHierarchyChanged(
const ViewHierarchyChangedDetails& details) OVERRIDE;
virtual bool AcceleratorPressed(const ui::Accelerator& accelerator) OVERRIDE;
// Overridden from views::WidgetDelegate:

9
browser/net/adapter_request_job.cc
View file

@ -4,6 +4,7 @@
#include "browser/net/adapter_request_job.h"
#include "base/threading/sequenced_worker_pool.h"
#include "browser/net/url_request_string_job.h"
#include "content/public/browser/browser_thread.h"
#include "net/base/net_errors.h"
@ -87,7 +88,13 @@ void AdapterRequestJob::CreateStringJobAndStart(const std::string& mime_type,
void AdapterRequestJob::CreateFileJobAndStart(const base::FilePath& path) {
DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
real_job_ = new net::URLRequestFileJob(request(), network_delegate(), path);
real_job_ = new net::URLRequestFileJob(
request(),
network_delegate(),
path,
content::BrowserThread::GetBlockingPool()->
GetTaskRunnerWithShutdownBehavior(
base::SequencedWorkerPool::SKIP_ON_SHUTDOWN));
real_job_->Start();
}

19
browser/net/atom_url_request_context_getter.cc
View file

@ -4,7 +4,8 @@
#include "browser/net/atom_url_request_context_getter.h"
#include "base/string_util.h"
#include "base/strings/string_util.h"
#include "base/threading/sequenced_worker_pool.h"
#include "base/threading/worker_pool.h"
#include "browser/net/atom_url_request_job_factory.h"
#include "content/public/browser/browser_thread.h"
@ -36,8 +37,8 @@ using content::BrowserThread;
AtomURLRequestContextGetter::AtomURLRequestContextGetter(
const base::FilePath& base_path,
MessageLoop* io_loop,
MessageLoop* file_loop,
base::MessageLoop* io_loop,
base::MessageLoop* file_loop,
scoped_ptr<brightray::NetworkDelegate> network_delegate,
content::ProtocolHandlerMap* protocol_handlers)
: base_path_(base_path),
@ -74,6 +75,7 @@ net::URLRequestContext* AtomURLRequestContextGetter::GetURLRequestContext() {
base_path_.Append(FILE_PATH_LITERAL("Cookies")),
false,
nullptr,
nullptr,
nullptr));
storage_->set_server_bound_cert_service(new net::ServerBoundCertService(
new net::DefaultServerBoundCertStore(NULL),
@ -98,7 +100,9 @@ net::URLRequestContext* AtomURLRequestContextGetter::GetURLRequestContext() {
storage_->set_ssl_config_service(new net::SSLConfigServiceDefaults);
storage_->set_http_auth_handler_factory(
net::HttpAuthHandlerFactory::CreateDefault(host_resolver.get()));
storage_->set_http_server_properties(new net::HttpServerPropertiesImpl);
scoped_ptr<net::HttpServerProperties> server_properties(
new net::HttpServerPropertiesImpl);
storage_->set_http_server_properties(server_properties.Pass());
base::FilePath cache_path = base_path_.Append(FILE_PATH_LITERAL("Cache"));
net::HttpCache::DefaultBackend* main_backend =
@ -147,10 +151,15 @@ net::URLRequestContext* AtomURLRequestContextGetter::GetURLRequestContext() {
}
protocol_handlers_.clear();
scoped_ptr<net::FileProtocolHandler> file_protocol_handler(
new net::FileProtocolHandler(
content::BrowserThread::GetBlockingPool()->
GetTaskRunnerWithShutdownBehavior(
base::SequencedWorkerPool::SKIP_ON_SHUTDOWN)));
job_factory_->SetProtocolHandler(chrome::kDataScheme,
new net::DataProtocolHandler);
job_factory_->SetProtocolHandler(chrome::kFileScheme,
new net::FileProtocolHandler);
file_protocol_handler.release());
storage_->set_job_factory(job_factory_);
}

6
browser/net/atom_url_request_job_factory.cc
View file

@ -6,7 +6,6 @@
#include "browser/net/atom_url_request_job_factory.h"
#include "base/stl_util.h"
#include "googleurl/src/gurl.h"
#include "net/base/load_flags.h"
#include "net/url_request/url_request.h"
@ -102,4 +101,9 @@ bool AtomURLRequestJobFactory::IsHandledURL(const GURL& url) const {
return IsHandledProtocol(url.scheme());
}
bool AtomURLRequestJobFactory::IsSafeRedirectTarget(
const GURL& location) const {
return IsHandledURL(location);
}
} // namespace atom

1
browser/net/atom_url_request_job_factory.h
View file

@ -45,6 +45,7 @@ class AtomURLRequestJobFactory : public net::URLRequestJobFactory {
net::NetworkDelegate* network_delegate) const OVERRIDE;
virtual bool IsHandledProtocol(const std::string& scheme) const OVERRIDE;
virtual bool IsHandledURL(const GURL& url) const OVERRIDE;
virtual bool IsSafeRedirectTarget(const GURL& location) const OVERRIDE;
private:
typedef std::map<std::string, ProtocolHandler*> ProtocolHandlerMap;

2
browser/ui/accelerator_util.cc
View file

@ -8,7 +8,7 @@
#include <string>
#include "base/string_util.h"
#include "base/strings/string_util.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_split.h"
#include "ui/base/accelerators/accelerator.h"

2
browser/ui/accelerator_util_mac.mm
View file

@ -6,7 +6,7 @@
#include "ui/base/accelerators/accelerator.h"
#import "ui/base/accelerators/platform_accelerator_cocoa.h"
#import "ui/base/keycodes/keyboard_code_conversion_mac.h"
#import "ui/events/keycodes/keyboard_code_conversion_mac.h"
namespace accelerator_util {

2
browser/ui/atom_event_processing_window.h
View file

@ -7,8 +7,6 @@
#import <Cocoa/Cocoa.h>
#include "base/memory/scoped_nsobject.h"
// Override NSWindow to access unhandled keyboard events (for command
// processing); subclassing NSWindow is the only method to do
// this.

6
browser/ui/atom_menu_controller_mac.h
View file

@ -8,8 +8,8 @@
#import <Cocoa/Cocoa.h>
#include "base/memory/scoped_nsobject.h"
#include "base/string16.h"
#include "base/mac/scoped_nsobject.h"
#include "base/strings/string16.h"
namespace ui {
class MenuModel;
@ -24,7 +24,7 @@ class MenuModel;
@interface AtomMenuController : NSObject<NSMenuDelegate> {
@protected
ui::MenuModel* model_; // weak
scoped_nsobject<NSMenu> menu_;
base::scoped_nsobject<NSMenu> menu_;
BOOL isMenuOpen_;
}

2
browser/ui/atom_menu_controller_mac.mm
View file

@ -133,7 +133,7 @@ int EventFlagsFromNSEvent(NSEvent* event) {
fromModel:(ui::MenuModel*)model {
string16 label16 = model->GetLabelAt(index);
NSString* label = l10n_util::FixUpWindowsStyleLabel(label16);
scoped_nsobject<NSMenuItem> item(
base::scoped_nsobject<NSMenuItem> item(
[[NSMenuItem alloc] initWithTitle:label
action:@selector(itemSelected:)
keyEquivalent:@""]);

2
browser/ui/file_dialog_mac.mm
View file

@ -24,7 +24,7 @@ void SetupDialog(NSSavePanel* dialog,
NSString* default_dir = nil;
NSString* default_filename = nil;
if (!default_path.empty()) {
if (file_util::DirectoryExists(default_path)) {
if (base::DirectoryExists(default_path)) {
default_dir = base::SysUTF8ToNSString(default_path.value());
} else {
default_dir = base::SysUTF8ToNSString(default_path.DirName().value());

4
browser/ui/file_dialog_win.cc
View file

@ -11,9 +11,9 @@
#include "base/file_util.h"
#include "base/i18n/case_conversion.h"
#include "base/string_util.h"
#include "base/strings/string_util.h"
#include "base/strings/string_split.h"
#include "base/utf_string_conversions.h"
#include "base/strings/utf_string_conversions.h"
#include "base/win/registry.h"
#include "browser/native_window.h"
#include "third_party/wtl/include/atlapp.h"

6
browser/ui/message_box_win.cc
View file

@ -5,10 +5,10 @@
#include "browser/ui/message_box.h"
#include "base/callback.h"
#include "base/message_loop.h"
#include "base/message_loop/message_loop.h"
#include "base/run_loop.h"
#include "base/string_util.h"
#include "base/utf_string_conversions.h"
#include "base/strings/string_util.h"
#include "base/strings/utf_string_conversions.h"
#include "browser/native_window.h"
#include "skia/ext/skia_utils_win.h"
#include "ui/views/controls/button/label_button.h"

14
browser/ui/win/native_menu_win.cc
View file

@ -8,22 +8,22 @@
#include "base/bind.h"
#include "base/logging.h"
#include "base/message_loop.h"
#include "base/message_loop/message_loop.h"
#include "base/stl_util.h"
#include "base/string_util.h"
#include "base/strings/string_util.h"
#include "base/win/wrapped_window_proc.h"
#include "browser/ui/win/menu_2.h"
#include "ui/base/accelerators/accelerator.h"
#include "ui/base/keycodes/keyboard_codes.h"
#include "ui/events/keycodes/keyboard_codes.h"
#include "ui/base/l10n/l10n_util.h"
#include "ui/base/l10n/l10n_util_win.h"
#include "ui/base/models/menu_model.h"
#include "ui/base/win/hwnd_util.h"
#include "ui/gfx/canvas.h"
#include "ui/gfx/font.h"
#include "ui/gfx/image/image.h"
#include "ui/gfx/image/image_skia.h"
#include "ui/gfx/rect.h"
#include "ui/gfx/win/hwnd_util.h"
#include "ui/native_theme/native_theme.h"
#include "ui/native_theme/native_theme_win.h"
#include "ui/views/controls/menu/menu_config.h"
@ -84,8 +84,8 @@ class NativeMenuWin::MenuHostWindow {
RegisterClass();
hwnd_ = CreateWindowEx(l10n_util::GetExtendedStyles(), kWindowClassName,
L"", 0, 0, 0, 0, 0, HWND_MESSAGE, NULL, NULL, NULL);
ui::CheckWindowCreated(hwnd_);
ui::SetWindowUserData(hwnd_, this);
gfx::CheckWindowCreated(hwnd_);
gfx::SetWindowUserData(hwnd_, this);
}
~MenuHostWindow() {
@ -353,7 +353,7 @@ class NativeMenuWin::MenuHostWindow {
WPARAM w_param,
LPARAM l_param) {
MenuHostWindow* host =
reinterpret_cast<MenuHostWindow*>(ui::GetWindowUserData(window));
reinterpret_cast<MenuHostWindow*>(gfx::GetWindowUserData(window));
// host is null during initial construction.
LRESULT l_result = 0;
if (!host || !host->ProcessWindowMessage(window, message, w_param, l_param,

2
browser/ui/win/native_menu_win.h
View file

@ -13,7 +13,7 @@
#include "base/memory/scoped_ptr.h"
#include "base/memory/weak_ptr.h"
#include "base/observer_list.h"
#include "base/string16.h"
#include "base/strings/string16.h"
namespace gfx {
class Point;

11
common.gypi
View file

@ -13,6 +13,7 @@
}],
],
# Reflects node's config.gypi.
'component%': 'static_library',
'python': 'python',
'node_install_npm': 'false',
'node_prefix': '',
@ -29,11 +30,12 @@
'node_use_openssl': 'true',
'node_use_perfctr': 'false',
'node_use_systemtap': 'false',
'v8_postmortem_support': 'false',
},
# Settings to compile node under Windows.
'target_defaults': {
'target_conditions': [
['_target_name in ["libuv", "http_parser", "cares", "openssl", "node", "zlib"]', {
['_target_name in ["libuv", "http_parser", "cares", "openssl", "node_lib", "zlib"]', {
'msvs_disabled_warnings': [
4013, # 'free' undefined; assuming extern returning int
4054, #
@ -41,6 +43,7 @@
4189, #
4131, # uses old-style declarator
4133, # incompatible types
4146, # unary minus operator applied to unsigned type, result still unsigned
4152, # function/data pointer conversion in expression
4206, # translation unit is empty
4204, # non-constant aggregate initializer
@ -51,6 +54,7 @@
4505, # unreferenced local function has been removed
4701, # potentially uninitialized local variable 'sizew' used
4706, # assignment within conditional expression
4804, # unsafe use of type 'bool' in operation
4996, #
],
'msvs_settings': {
@ -72,6 +76,11 @@
],
},
}],
['_target_name in ["node_lib", "atom_lib"]', {
'include_dirs': [
'vendor/brightray/vendor/download/libchromiumcontent/src/v8/include',
],
}],
['_target_name=="libuv"', {
'conditions': [
['OS=="win"', {

2
common/api/api_messages.h
View file

@ -4,7 +4,7 @@
// Multiply-included file, no traditional include guard.
#include "base/string16.h"
#include "base/strings/string16.h"
#include "base/values.h"
#include "common/draggable_region.h"
#include "content/public/common/common_param_traits.h"

67
common/api/atom_api_clipboard.cc
View file

@ -6,92 +6,81 @@
#include <string>
#include "common/v8/native_type_conversions.h"
#include "ui/base/clipboard/clipboard.h"
#include "vendor/node/src/node.h"
#include "common/v8/node_common.h"
namespace atom {
namespace api {
// static
v8::Handle<v8::Value> Clipboard::Has(const v8::Arguments &args) {
v8::HandleScope scope;
if (!args[0]->IsString())
void Clipboard::Has(const v8::FunctionCallbackInfo<v8::Value>& args) {
std::string format_string;
if (!FromV8Arguments(args, &format_string))
return node::ThrowTypeError("Bad argument");
ui::Clipboard* clipboard = ui::Clipboard::GetForCurrentThread();
std::string format_string(*v8::String::Utf8Value(args[0]));
ui::Clipboard::FormatType format(ui::Clipboard::GetFormatType(format_string));
return scope.Close(v8::Boolean::New(
clipboard->IsFormatAvailable(format, ui::Clipboard::BUFFER_STANDARD)));
args.GetReturnValue().Set(
clipboard->IsFormatAvailable(format, ui::Clipboard::BUFFER_STANDARD));
}
// static
v8::Handle<v8::Value> Clipboard::Read(const v8::Arguments &args) {
v8::HandleScope scope;
if (!args[0]->IsString())
void Clipboard::Read(const v8::FunctionCallbackInfo<v8::Value>& args) {
std::string format_string;
if (!FromV8Arguments(args, &format_string))
return node::ThrowTypeError("Bad argument");
ui::Clipboard* clipboard = ui::Clipboard::GetForCurrentThread();
std::string format_string(*v8::String::Utf8Value(args[0]));
ui::Clipboard::FormatType format(ui::Clipboard::GetFormatType(format_string));
std::string data;
clipboard->ReadData(format, &data);
return scope.Close(v8::String::New(data.c_str(), data.size()));
args.GetReturnValue().Set(ToV8Value(data));
}
// static
v8::Handle<v8::Value> Clipboard::ReadText(const v8::Arguments &args) {
v8::HandleScope scope;
void Clipboard::ReadText(const v8::FunctionCallbackInfo<v8::Value>& args) {
ui::Clipboard* clipboard = ui::Clipboard::GetForCurrentThread();
std::string data;
clipboard->ReadAsciiText(ui::Clipboard::BUFFER_STANDARD, &data);
return scope.Close(v8::String::New(data.c_str(), data.size()));
args.GetReturnValue().Set(ToV8Value(data));
}
// static
v8::Handle<v8::Value> Clipboard::WriteText(const v8::Arguments &args) {
v8::HandleScope scope;
if (!args[0]->IsString())
void Clipboard::WriteText(const v8::FunctionCallbackInfo<v8::Value>& args) {
std::string text;
if (!FromV8Arguments(args, &text))
return node::ThrowTypeError("Bad argument");
ui::Clipboard* clipboard = ui::Clipboard::GetForCurrentThread();
std::string text(*v8::String::Utf8Value(args[0]));
ui::Clipboard::ObjectMap object_map;
object_map[ui::Clipboard::CBF_TEXT].push_back(
std::vector<char>(text.begin(), text.end()));
clipboard->WriteObjects(ui::Clipboard::BUFFER_STANDARD, object_map, NULL);
return v8::Undefined();
ui::Clipboard* clipboard = ui::Clipboard::GetForCurrentThread();
clipboard->WriteObjects(ui::Clipboard::BUFFER_STANDARD, object_map);
}
// static
v8::Handle<v8::Value> Clipboard::Clear(const v8::Arguments &args) {
ui::Clipboard* clipboard = ui::Clipboard::GetForCurrentThread();
clipboard->Clear(ui::Clipboard::BUFFER_STANDARD);
return v8::Undefined();
void Clipboard::Clear(const v8::FunctionCallbackInfo<v8::Value>& args) {
ui::Clipboard::GetForCurrentThread()->Clear(ui::Clipboard::BUFFER_STANDARD);
}
// static
void Clipboard::Initialize(v8::Handle<v8::Object> target) {
node::SetMethod(target, "has", Has);
node::SetMethod(target, "read", Read);
node::SetMethod(target, "readText", ReadText);
node::SetMethod(target, "writeText", WriteText);
node::SetMethod(target, "clear", Clear);
v8::HandleScope handle_scope(node_isolate);
NODE_SET_METHOD(target, "has", Has);
NODE_SET_METHOD(target, "read", Read);
NODE_SET_METHOD(target, "readText", ReadText);
NODE_SET_METHOD(target, "writeText", WriteText);
NODE_SET_METHOD(target, "clear", Clear);
}
} // namespace api

10
common/api/atom_api_clipboard.h
View file

@ -17,11 +17,11 @@ class Clipboard {
static void Initialize(v8::Handle<v8::Object> target);
private:
static v8::Handle<v8::Value> Has(const v8::Arguments &args);
static v8::Handle<v8::Value> Read(const v8::Arguments &args);
static v8::Handle<v8::Value> ReadText(const v8::Arguments &args);
static v8::Handle<v8::Value> WriteText(const v8::Arguments &args);
static v8::Handle<v8::Value> Clear(const v8::Arguments &args);
static void Has(const v8::FunctionCallbackInfo<v8::Value>& args);
static void Read(const v8::FunctionCallbackInfo<v8::Value>& args);
static void ReadText(const v8::FunctionCallbackInfo<v8::Value>& args);
static void WriteText(const v8::FunctionCallbackInfo<v8::Value>& args);
static void Clear(const v8::FunctionCallbackInfo<v8::Value>& args);
DISALLOW_IMPLICIT_CONSTRUCTORS(Clipboard);
};

12
common/api/atom_api_crash_reporter.cc
View file

@ -5,16 +5,16 @@
#include "common/api/atom_api_crash_reporter.h"
#include "common/crash_reporter/crash_reporter.h"
#include "common/v8_conversions.h"
#include "vendor/node/src/node.h"
#include "vendor/node/src/node_internals.h"
#include "common/v8/native_type_conversions.h"
#include "common/v8/node_common.h"
namespace atom {
namespace api {
// static
v8::Handle<v8::Value> CrashReporter::Start(const v8::Arguments& args) {
void CrashReporter::Start(const v8::FunctionCallbackInfo<v8::Value>& args) {
std::string product_name, company_name, submit_url;
bool auto_submit, skip_system;
std::map<std::string, std::string> dict;
@ -24,13 +24,11 @@ v8::Handle<v8::Value> CrashReporter::Start(const v8::Arguments& args) {
crash_reporter::CrashReporter::GetInstance()->Start(
product_name, company_name, submit_url, auto_submit, skip_system, dict);
return v8::Undefined();
}
// static
void CrashReporter::Initialize(v8::Handle<v8::Object> target) {
node::SetMethod(target, "start", Start);
NODE_SET_METHOD(target, "start", Start);
}
} // namespace api

2
common/api/atom_api_crash_reporter.h
View file

@ -17,7 +17,7 @@ class CrashReporter {
static void Initialize(v8::Handle<v8::Object> target);
private:
static v8::Handle<v8::Value> Start(const v8::Arguments& args);
static void Start(const v8::FunctionCallbackInfo<v8::Value>& args);
DISALLOW_IMPLICIT_CONSTRUCTORS(CrashReporter);
};

118
common/api/atom_api_id_weak_map.cc
View file

@ -5,7 +5,11 @@
#include "common/api/atom_api_id_weak_map.h"
#include <algorithm>
#include "base/logging.h"
#include "common/v8/native_type_conversions.h"
#include "common/v8/node_common.h"
namespace atom {
@ -16,29 +20,17 @@ IDWeakMap::IDWeakMap()
}
IDWeakMap::~IDWeakMap() {
v8::Isolate* isolate = v8::Isolate::GetCurrent();
auto copied_map = map_;
for (auto el = copied_map.begin(); el != copied_map.end(); ++el)
Erase(isolate, el->first);
}
bool IDWeakMap::Has(int key) const {
return map_.find(key) != map_.end();
}
void IDWeakMap::Erase(v8::Isolate* isolate, int key) {
if (!Has(key)) {
void IDWeakMap::Erase(int key) {
if (Has(key))
map_.erase(key);
else
LOG(WARNING) << "Object with key " << key << " is being GCed for twice.";
return;
}
v8::Persistent<v8::Value> value = map_[key];
value.ClearWeak(isolate);
value.Dispose(isolate);
value.Clear();
map_.erase(key);
}
int IDWeakMap::GetNextID() {
@ -47,104 +39,92 @@ int IDWeakMap::GetNextID() {
// static
void IDWeakMap::WeakCallback(v8::Isolate* isolate,
v8::Persistent<v8::Value> value,
void *data) {
v8::HandleScope scope;
IDWeakMap* obj = static_cast<IDWeakMap*>(data);
int key = value->ToObject()->GetHiddenValue(
v8::String::New("IDWeakMapKey"))->IntegerValue();
obj->Erase(isolate, key);
v8::Persistent<v8::Object>* value,
IDWeakMap* self) {
v8::HandleScope handle_scope(isolate);
v8::Local<v8::Object> local = v8::Local<v8::Object>::New(isolate, *value);
self->Erase(
FromV8Value(local->GetHiddenValue(v8::String::New("IDWeakMapKey"))));
}
// static
v8::Handle<v8::Value> IDWeakMap::New(const v8::Arguments& args) {
IDWeakMap* obj = new IDWeakMap();
obj->Wrap(args.This());
return args.This();
void IDWeakMap::New(const v8::FunctionCallbackInfo<v8::Value>& args) {
(new IDWeakMap)->Wrap(args.This());
}
// static
v8::Handle<v8::Value> IDWeakMap::Add(const v8::Arguments& args) {
void IDWeakMap::Add(const v8::FunctionCallbackInfo<v8::Value>& args) {
if (!args[0]->IsObject())
return node::ThrowTypeError("Bad argument");
v8::Isolate* isolate = v8::Isolate::GetCurrent();
IDWeakMap* obj = ObjectWrap::Unwrap<IDWeakMap>(args.This());
int key = obj->GetNextID();
IDWeakMap* self = Unwrap<IDWeakMap>(args.This());
v8::Handle<v8::Value> v8_key = v8::Integer::New(key);
v8::Persistent<v8::Value> value =
v8::Persistent<v8::Value>::New(isolate, args[0]);
int key = self->GetNextID();
v8::Local<v8::Object> v8_value = args[0]->ToObject();
v8_value->SetHiddenValue(v8::String::New("IDWeakMapKey"), ToV8Value(key));
value->ToObject()->SetHiddenValue(v8::String::New("IDWeakMapKey"), v8_key);
value.MakeWeak(isolate, obj, WeakCallback);
obj->map_[key] = value;
self->map_[key] = new RefCountedPersistent<v8::Object>(v8_value);
self->map_[key]->MakeWeak(self, WeakCallback);
return v8_key;
args.GetReturnValue().Set(key);
}
// static
v8::Handle<v8::Value> IDWeakMap::Get(const v8::Arguments& args) {
if (!args[0]->IsNumber())
void IDWeakMap::Get(const v8::FunctionCallbackInfo<v8::Value>& args) {
int key;
if (!FromV8Arguments(args, &key))
return node::ThrowTypeError("Bad argument");
IDWeakMap* obj = ObjectWrap::Unwrap<IDWeakMap>(args.This());
int key = args[0]->IntegerValue();
if (!obj->Has(key))
IDWeakMap* self = Unwrap<IDWeakMap>(args.This());
if (!self->Has(key))
return node::ThrowError("Invalid key");
return obj->map_[key];
args.GetReturnValue().Set(self->map_[key]->NewHandle());
}
// static
v8::Handle<v8::Value> IDWeakMap::Has(const v8::Arguments& args) {
if (!args[0]->IsNumber())
void IDWeakMap::Has(const v8::FunctionCallbackInfo<v8::Value>& args) {
int key;
if (!FromV8Arguments(args, &key))
return node::ThrowTypeError("Bad argument");
IDWeakMap* obj = ObjectWrap::Unwrap<IDWeakMap>(args.This());
int key = args[0]->IntegerValue();
return v8::Boolean::New(obj->Has(key));
IDWeakMap* self = Unwrap<IDWeakMap>(args.This());
args.GetReturnValue().Set(self->Has(key));
}
// static
v8::Handle<v8::Value> IDWeakMap::Keys(const v8::Arguments& args) {
IDWeakMap* obj = ObjectWrap::Unwrap<IDWeakMap>(args.This());
void IDWeakMap::Keys(const v8::FunctionCallbackInfo<v8::Value>& args) {
IDWeakMap* self = Unwrap<IDWeakMap>(args.This());
v8::Handle<v8::Array> keys = v8::Array::New(obj->map_.size());
v8::Local<v8::Array> keys = v8::Array::New(self->map_.size());
int i = 0;
for (auto el = obj->map_.begin(); el != obj->map_.end(); ++el) {
keys->Set(i, v8::Integer::New(el->first));
for (auto el = self->map_.begin(); el != self->map_.end(); ++el) {
keys->Set(i, ToV8Value(el->first));
++i;
}
return keys;
args.GetReturnValue().Set(keys);
}
// static
v8::Handle<v8::Value> IDWeakMap::Remove(const v8::Arguments& args) {
if (!args[0]->IsNumber())
void IDWeakMap::Remove(const v8::FunctionCallbackInfo<v8::Value>& args) {
int key;
if (!FromV8Arguments(args, &key))
return node::ThrowTypeError("Bad argument");
IDWeakMap* obj = ObjectWrap::Unwrap<IDWeakMap>(args.This());
int key = args[0]->IntegerValue();
if (!obj->Has(key))
IDWeakMap* self = Unwrap<IDWeakMap>(args.This());
if (!self->Has(key))
return node::ThrowError("Invalid key");
obj->Erase(v8::Isolate::GetCurrent(), key);
return v8::Undefined();
self->Erase(key);
}
// static
void IDWeakMap::Initialize(v8::Handle<v8::Object> target) {
v8::HandleScope scope;
v8::HandleScope handle_scope(node_isolate);
v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(IDWeakMap::New);
v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(New);
t->InstanceTemplate()->SetInternalFieldCount(1);
t->SetClassName(v8::String::NewSymbol("IDWeakMap"));

22
common/api/atom_api_id_weak_map.h
View file

@ -9,6 +9,7 @@
#include <map>
#include "base/basictypes.h"
#include "common/v8/scoped_persistent.h"
#include "vendor/node/src/node_object_wrap.h"
namespace atom {
@ -24,23 +25,22 @@ class IDWeakMap : public node::ObjectWrap {
virtual ~IDWeakMap();
bool Has(int key) const;
void Erase(v8::Isolate* isolate, int key);
void Erase(int key);
int GetNextID();
static void WeakCallback(v8::Isolate* isolate,
v8::Persistent<v8::Value> value,
void *data);
v8::Persistent<v8::Object>* value,
IDWeakMap* self);
static v8::Handle<v8::Value> New(const v8::Arguments& args);
static v8::Handle<v8::Value> Add(const v8::Arguments& args);
static v8::Handle<v8::Value> Get(const v8::Arguments& args);
static v8::Handle<v8::Value> Has(const v8::Arguments& args);
static v8::Handle<v8::Value> Keys(const v8::Arguments& args);
static v8::Handle<v8::Value> Remove(const v8::Arguments& args);
static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
static void Add(const v8::FunctionCallbackInfo<v8::Value>& args);
static void Get(const v8::FunctionCallbackInfo<v8::Value>& args);
static void Has(const v8::FunctionCallbackInfo<v8::Value>& args);
static void Keys(const v8::FunctionCallbackInfo<v8::Value>& args);
static void Remove(const v8::FunctionCallbackInfo<v8::Value>& args);
int next_id_;
std::map<int, v8::Persistent<v8::Value>> map_;
std::map<int, RefCountedV8Object> map_;
DISALLOW_COPY_AND_ASSIGN(IDWeakMap);
};

70
common/api/atom_api_shell.cc
View file

@ -8,91 +8,65 @@
#include "base/files/file_path.h"
#include "common/platform_util.h"
#include "googleurl/src/gurl.h"
#include "vendor/node/src/node.h"
#include "common/v8/native_type_conversions.h"
#include "url/gurl.h"
#include "common/v8/node_common.h"
namespace atom {
namespace api {
namespace {
bool V8ValueToFilePath(v8::Handle<v8::Value> value, base::FilePath* path) {
if (!value->IsString())
return false;
std::string file_path_string(*v8::String::Utf8Value(value));
base::FilePath file_path = base::FilePath::FromUTF8Unsafe(file_path_string);
if (file_path.empty())
return false;
*path = file_path;
return true;
}
} // namespace
// static
v8::Handle<v8::Value> Shell::ShowItemInFolder(const v8::Arguments &args) {
v8::HandleScope scope;
void Shell::ShowItemInFolder(const v8::FunctionCallbackInfo<v8::Value>& args) {
base::FilePath file_path;
if (!V8ValueToFilePath(args[0], &file_path))
if (!FromV8Arguments(args, &file_path))
return node::ThrowTypeError("Bad argument");
platform_util::ShowItemInFolder(file_path);
return v8::Undefined();
}
// static
v8::Handle<v8::Value> Shell::OpenItem(const v8::Arguments &args) {
v8::HandleScope scope;
void Shell::OpenItem(const v8::FunctionCallbackInfo<v8::Value>& args) {
base::FilePath file_path;
if (!V8ValueToFilePath(args[0], &file_path))
if (!FromV8Arguments(args, &file_path))
return node::ThrowTypeError("Bad argument");
platform_util::OpenItem(file_path);
return v8::Undefined();
}
// static
v8::Handle<v8::Value> Shell::OpenExternal(const v8::Arguments &args) {
v8::HandleScope scope;
if (!args[0]->IsString())
void Shell::OpenExternal(const v8::FunctionCallbackInfo<v8::Value>& args) {
GURL url;
if (!FromV8Arguments(args, &url))
return node::ThrowTypeError("Bad argument");
platform_util::OpenExternal(GURL(*v8::String::Utf8Value(args[0])));
return v8::Undefined();
platform_util::OpenExternal(url);
}
// static
v8::Handle<v8::Value> Shell::MoveItemToTrash(const v8::Arguments &args) {
v8::HandleScope scope;
void Shell::MoveItemToTrash(const v8::FunctionCallbackInfo<v8::Value>& args) {
base::FilePath file_path;
if (!V8ValueToFilePath(args[0], &file_path))
if (!FromV8Arguments(args, &file_path))
return node::ThrowTypeError("Bad argument");
platform_util::MoveItemToTrash(file_path);
return v8::Undefined();
}
// static
v8::Handle<v8::Value> Shell::Beep(const v8::Arguments &args) {
void Shell::Beep(const v8::FunctionCallbackInfo<v8::Value>& args) {
platform_util::Beep();
return v8::Undefined();
}
// static
void Shell::Initialize(v8::Handle<v8::Object> target) {
node::SetMethod(target, "showItemInFolder", ShowItemInFolder);
node::SetMethod(target, "openItem", OpenItem);
node::SetMethod(target, "openExternal", OpenExternal);
node::SetMethod(target, "moveItemToTrash", MoveItemToTrash);
node::SetMethod(target, "beep", Beep);
v8::HandleScope handle_scope(node_isolate);
NODE_SET_METHOD(target, "showItemInFolder", ShowItemInFolder);
NODE_SET_METHOD(target, "openItem", OpenItem);
NODE_SET_METHOD(target, "openExternal", OpenExternal);
NODE_SET_METHOD(target, "moveItemToTrash", MoveItemToTrash);
NODE_SET_METHOD(target, "beep", Beep);
}
} // namespace api

10
common/api/atom_api_shell.h
View file

@ -17,11 +17,11 @@ class Shell {
static void Initialize(v8::Handle<v8::Object> target);
private:
static v8::Handle<v8::Value> ShowItemInFolder(const v8::Arguments &args);
static v8::Handle<v8::Value> OpenItem(const v8::Arguments &args);
static v8::Handle<v8::Value> OpenExternal(const v8::Arguments &args);
static v8::Handle<v8::Value> MoveItemToTrash(const v8::Arguments &args);
static v8::Handle<v8::Value> Beep(const v8::Arguments &args);
static void ShowItemInFolder(const v8::FunctionCallbackInfo<v8::Value>& args);
static void OpenItem(const v8::FunctionCallbackInfo<v8::Value>& args);
static void OpenExternal(const v8::FunctionCallbackInfo<v8::Value>& args);
static void MoveItemToTrash(const v8::FunctionCallbackInfo<v8::Value>& args);
static void Beep(const v8::FunctionCallbackInfo<v8::Value>& args);
DISALLOW_IMPLICIT_CONSTRUCTORS(Shell);
};

41
common/api/atom_api_v8_util.cc
View file

@ -3,9 +3,11 @@
// found in the LICENSE file.
#include "common/api/object_life_monitor.h"
#include "common/v8/native_type_conversions.h"
#include "v8/include/v8-profiler.h"
#include "vendor/node/src/node.h"
#include "vendor/node/src/node_internals.h"
#include "common/v8/node_common.h"
namespace atom {
@ -13,48 +15,39 @@ namespace api {
namespace {
v8::Handle<v8::Value> DummyNew(const v8::Arguments& args) {
return args.This();
}
v8::Handle<v8::Value> CreateObjectWithName(const v8::Arguments& args) {
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(DummyNew);
void CreateObjectWithName(const v8::FunctionCallbackInfo<v8::Value>& args) {
v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New();
t->SetClassName(args[0]->ToString());
return scope.Close(t->GetFunction()->NewInstance());
args.GetReturnValue().Set(t->GetFunction()->NewInstance());
}
v8::Handle<v8::Value> GetHiddenValue(const v8::Arguments& args) {
return args[0]->ToObject()->GetHiddenValue(args[1]->ToString());
void GetHiddenValue(const v8::FunctionCallbackInfo<v8::Value>& args) {
args.GetReturnValue().Set(
args[0]->ToObject()->GetHiddenValue(args[1]->ToString()));
}
v8::Handle<v8::Value> SetHiddenValue(const v8::Arguments& args) {
void SetHiddenValue(const v8::FunctionCallbackInfo<v8::Value>& args) {
args[0]->ToObject()->SetHiddenValue(args[1]->ToString(), args[2]);
return v8::Undefined();
}
v8::Handle<v8::Value> GetObjectHash(const v8::Arguments& args) {
v8::HandleScope handle_scope;
return handle_scope.Close(v8::Integer::New(
args[0]->ToObject()->GetIdentityHash()));
void GetObjectHash(const v8::FunctionCallbackInfo<v8::Value>& args) {
args.GetReturnValue().Set(args[0]->ToObject()->GetIdentityHash());
}
v8::Handle<v8::Value> SetDestructor(const v8::Arguments& args) {
void SetDestructor(const v8::FunctionCallbackInfo<v8::Value>& args) {
ObjectLifeMonitor::BindTo(args[0]->ToObject(), args[1]);
return v8::Undefined();
}
v8::Handle<v8::Value> TakeHeapSnapshot(const v8::Arguments& args) {
void TakeHeapSnapshot(const v8::FunctionCallbackInfo<v8::Value>& args) {
node::node_isolate->GetHeapProfiler()->TakeHeapSnapshot(
v8::String::New("test"));
return v8::Undefined();
}
} // namespace
void InitializeV8Util(v8::Handle<v8::Object> target) {
v8::HandleScope handle_scope(node_isolate);
NODE_SET_METHOD(target, "createObjectWithName", CreateObjectWithName);
NODE_SET_METHOD(target, "getHiddenValue", GetHiddenValue);
NODE_SET_METHOD(target, "setHiddenValue", SetHiddenValue);

46
common/api/atom_bindings.cc
View file

@ -6,8 +6,9 @@
#include "base/logging.h"
#include "common/atom_version.h"
#include "common/v8_conversions.h"
#include "vendor/node/src/node.h"
#include "common/v8/native_type_conversions.h"
#include "common/v8/node_common.h"
namespace atom {
@ -50,22 +51,20 @@ AtomBindings::~AtomBindings() {
}
void AtomBindings::BindTo(v8::Handle<v8::Object> process) {
v8::HandleScope scope;
v8::HandleScope handle_scope(node_isolate);
node::SetMethod(process, "atomBinding", Binding);
node::SetMethod(process, "crash", Crash);
node::SetMethod(process, "activateUvLoop", ActivateUVLoop);
node::SetMethod(process, "log", Log);
node::SetMethod(process, "getCurrentStackTrace", GetCurrentStackTrace);
NODE_SET_METHOD(process, "atomBinding", Binding);
NODE_SET_METHOD(process, "crash", Crash);
NODE_SET_METHOD(process, "activateUvLoop", ActivateUVLoop);
NODE_SET_METHOD(process, "log", Log);
NODE_SET_METHOD(process, "getCurrentStackTrace", GetCurrentStackTrace);
process->Get(v8::String::New("versions"))->ToObject()->
Set(v8::String::New("atom-shell"), v8::String::New(ATOM_VERSION_STRING));
}
// static
v8::Handle<v8::Value> AtomBindings::Binding(const v8::Arguments& args) {
v8::HandleScope scope;
void AtomBindings::Binding(const v8::FunctionCallbackInfo<v8::Value>& args) {
v8::Local<v8::String> module = args[0]->ToString();
v8::String::Utf8Value module_v(module);
node::node_module_struct* modp;
@ -93,7 +92,7 @@ v8::Handle<v8::Value> AtomBindings::Binding(const v8::Arguments& args) {
if (binding_cache->Has(module)) {
exports = binding_cache->Get(module)->ToObject();
return scope.Close(exports);
return args.GetReturnValue().Set(exports);
}
if ((modp = GetBuiltinModule(*module_v, is_browser)) != NULL) {
@ -102,39 +101,36 @@ v8::Handle<v8::Value> AtomBindings::Binding(const v8::Arguments& args) {
// only exports.
modp->register_func(exports, v8::Undefined());
binding_cache->Set(module, exports);
return scope.Close(exports);
return args.GetReturnValue().Set(exports);
}
return v8::ThrowException(v8::Exception::Error(
v8::String::New("No such module")));
return node::ThrowError("No such module");
}
// static
v8::Handle<v8::Value> AtomBindings::Crash(const v8::Arguments& args) {
void AtomBindings::Crash(const v8::FunctionCallbackInfo<v8::Value>& args) {
static_cast<DummyClass*>(NULL)->crash = true;
return v8::Undefined();
}
// static
v8::Handle<v8::Value> AtomBindings::ActivateUVLoop(const v8::Arguments& args) {
void AtomBindings::ActivateUVLoop(
const v8::FunctionCallbackInfo<v8::Value>& args) {
uv_async_send(&dummy_uv_handle);
return v8::Undefined();
}
// static
v8::Handle<v8::Value> AtomBindings::Log(const v8::Arguments& args) {
void AtomBindings::Log(const v8::FunctionCallbackInfo<v8::Value>& args) {
std::string message;
for (int i = 0; i < args.Length(); ++i)
message += *v8::String::Utf8Value(args[i]);
logging::LogMessage("CONSOLE", 0, 0).stream() << message;
return v8::Undefined();
}
// static
v8::Handle<v8::Value> AtomBindings::GetCurrentStackTrace(
const v8::Arguments& args) {
v8::HandleScope scope;
void AtomBindings::GetCurrentStackTrace(
const v8::FunctionCallbackInfo<v8::Value>& args) {
v8::HandleScope handle_scope(args.GetIsolate());
int stack_limit = kMaxCallStackSize;
FromV8Arguments(args, &stack_limit);
@ -147,7 +143,7 @@ v8::Handle<v8::Value> AtomBindings::GetCurrentStackTrace(
for (int i = 0; i < frame_count; ++i)
result->Set(i, DumpStackFrame(stack_trace->GetFrame(i)));
return scope.Close(result);
args.GetReturnValue().Set(result);
}
} // namespace atom

11
common/api/atom_bindings.h
View file

@ -20,11 +20,12 @@ class AtomBindings {
virtual void BindTo(v8::Handle<v8::Object> process);
private:
static v8::Handle<v8::Value> Binding(const v8::Arguments& args);
static v8::Handle<v8::Value> Crash(const v8::Arguments& args);
static v8::Handle<v8::Value> ActivateUVLoop(const v8::Arguments& args);
static v8::Handle<v8::Value> Log(const v8::Arguments& args);
static v8::Handle<v8::Value> GetCurrentStackTrace(const v8::Arguments& args);
static void Binding(const v8::FunctionCallbackInfo<v8::Value>& args);
static void Crash(const v8::FunctionCallbackInfo<v8::Value>& args);
static void ActivateUVLoop(const v8::FunctionCallbackInfo<v8::Value>& args);
static void Log(const v8::FunctionCallbackInfo<v8::Value>& args);
static void GetCurrentStackTrace(
const v8::FunctionCallbackInfo<v8::Value>& args);
DISALLOW_COPY_AND_ASSIGN(AtomBindings);
};

5
common/api/atom_extensions.cc
View file

@ -5,10 +5,11 @@
#include <string.h>
#include <stdio.h>
#include "base/string_util.h"
#include "vendor/node/src/node.h"
#include "base/strings/string_util.h"
#include "vendor/node/src/node_version.h"
#include "common/v8/node_common.h"
namespace atom {
#undef NODE_EXT_LIST_START

29
common/api/object_life_monitor.cc
View file

@ -10,42 +10,29 @@ namespace atom {
// static
void ObjectLifeMonitor::BindTo(v8::Handle<v8::Object> target,
v8::Handle<v8::Value> destructor) {
v8::Isolate* isolate = v8::Isolate::GetCurrent();
target->SetHiddenValue(v8::String::New("destructor"), destructor);
ObjectLifeMonitor* olm = new ObjectLifeMonitor();
olm->handle_ = v8::Persistent<v8::Object>::New(isolate, target);
olm->handle_.MakeWeak(isolate, olm, WeakCallback);
olm->handle_.reset(target);
olm->handle_.MakeWeak(olm, WeakCallback);
}
ObjectLifeMonitor::ObjectLifeMonitor() {
}
ObjectLifeMonitor::~ObjectLifeMonitor() {
if (!handle_.IsEmpty()) {
v8::Isolate* isolate = v8::Isolate::GetCurrent();
handle_.ClearWeak(isolate);
handle_.Dispose(isolate);
handle_.Clear();
}
}
// static
void ObjectLifeMonitor::WeakCallback(v8::Isolate* isolate,
v8::Persistent<v8::Value> value,
void *data) {
v8::Persistent<v8::Object>* value,
ObjectLifeMonitor* self) {
// destructor.call(object, object);
{
v8::HandleScope scope;
v8::Local<v8::Object> obj = value->ToObject();
v8::Local<v8::Value> args[] = { obj };
v8::HandleScope handle_scope(isolate);
v8::Local<v8::Object> obj = self->handle_.NewHandle();
v8::Local<v8::Function>::Cast(obj->GetHiddenValue(
v8::String::New("destructor")))->Call(obj, 1, args);
v8::String::New("destructor")))->Call(obj, 0, NULL);
}
ObjectLifeMonitor* obj = static_cast<ObjectLifeMonitor*>(data);
delete obj;
delete self;
}
} // namespace atom

9
common/api/object_life_monitor.h
View file

@ -7,7 +7,7 @@
#define ATOM_COMMON_API_OBJECT_LIFE_MONITOR_H_
#include "base/basictypes.h"
#include "v8/include/v8.h"
#include "common/v8/scoped_persistent.h"
namespace atom {
@ -18,13 +18,12 @@ class ObjectLifeMonitor {
private:
ObjectLifeMonitor();
virtual ~ObjectLifeMonitor();
static void WeakCallback(v8::Isolate* isolate,
v8::Persistent<v8::Value> value,
void *data);
v8::Persistent<v8::Object>* value,
ObjectLifeMonitor* self);
v8::Persistent<v8::Object> handle_;
ScopedPersistent<v8::Object> handle_;
DISALLOW_COPY_AND_ASSIGN(ObjectLifeMonitor);
};

6
common/atom_version.h
View file

@ -6,10 +6,10 @@
#define ATOM_VERSION_H
#define ATOM_MAJOR_VERSION 0
#define ATOM_MINOR_VERSION 7
#define ATOM_PATCH_VERSION 6
#define ATOM_MINOR_VERSION 8
#define ATOM_PATCH_VERSION 0
#define ATOM_VERSION_IS_RELEASE 1
#define ATOM_VERSION_IS_RELEASE 0
#ifndef ATOM_TAG
# define ATOM_TAG ""

4
common/crash_reporter/crash_reporter_win.cc
View file

@ -7,8 +7,8 @@
#include "base/file_util.h"
#include "base/logging.h"
#include "base/memory/singleton.h"
#include "base/string_util.h"
#include "base/utf_string_conversions.h"
#include "base/strings/string_util.h"
#include "base/strings/utf_string_conversions.h"
namespace crash_reporter {

2
common/crash_reporter/win/crash_service.cc
View file

@ -350,7 +350,7 @@ void CrashService::OnClientDumpRequest(void* context,
file_util::CreateDirectoryW(alternate_dump_location);
alternate_dump_location = alternate_dump_location.Append(
dump_location.BaseName());
file_util::Move(dump_location, alternate_dump_location);
base::Move(dump_location, alternate_dump_location);
dump_location = alternate_dump_location;
}

20
common/crash_reporter/win/crash_service_main.cc
View file

@ -8,7 +8,7 @@
#include "base/command_line.h"
#include "base/file_util.h"
#include "base/logging.h"
#include "base/string_util.h"
#include "base/strings/string_util.h"
#include "common/crash_reporter/win/crash_service.h"
namespace crash_service {
@ -26,7 +26,7 @@ bool GetCrashServiceDirectory(const std::wstring& application_name,
if (!file_util::GetTempDir(&temp_dir))
return false;
temp_dir = temp_dir.Append(application_name + L" Crashes");
if (!file_util::PathExists(temp_dir)) {
if (!base::PathExists(temp_dir)) {
if (!file_util::CreateDirectory(temp_dir))
return false;
}
@ -56,14 +56,14 @@ int Main(const wchar_t* cmd) {
GetCrashServiceDirectory(application_name, &operating_dir);
base::FilePath log_file = operating_dir.Append(kStandardLogFile);
// Logging out to a file.
logging::InitLogging(
log_file.value().c_str(),
logging::LOG_TO_BOTH_FILE_AND_SYSTEM_DEBUG_LOG ,
logging::LOCK_LOG_FILE,
logging::DELETE_OLD_LOG_FILE,
logging::DISABLE_DCHECK_FOR_NON_OFFICIAL_RELEASE_BUILDS);
logging::SetLogItems(true, false, true, false);
// Logging to stderr (to help with debugging failures on the
// buildbots) and to a file.
logging::LoggingSettings settings;
settings.logging_dest = logging::LOG_TO_ALL;
settings.log_file = log_file.value().c_str();
logging::InitLogging(settings);
// Logging with pid, tid and timestamp.
logging::SetLogItems(true, true, true, false);
VLOG(1) << "Session start. cmdline is [" << cmd << "]";

182
common/node_bindings.cc
View file

@ -5,32 +5,62 @@
#include "common/node_bindings.h"
#include "base/command_line.h"
#include "base/logging.h"
#include "base/message_loop.h"
#include "common/v8_conversions.h"
#include "base/message_loop/message_loop.h"
#include "base/base_paths.h"
#include "base/path_service.h"
#include "common/v8/native_type_conversions.h"
#include "content/public/browser/browser_thread.h"
#include "net/base/escape.h"
#include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
#include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
#include "vendor/node/src/node.h"
#include "vendor/node/src/node_internals.h"
#include "vendor/node/src/node_javascript.h"
#if defined(OS_WIN)
#include "base/strings/utf_string_conversions.h"
#endif
#include "common/v8/node_common.h"
using content::BrowserThread;
// Forward declaration of internal node functions.
namespace node {
void Init(int*, const char**, int*, const char***);
void Load(Environment* env);
void SetupProcessObject(Environment*, int, const char* const*, int,
const char* const*);
}
namespace atom {
namespace {
// Empty callback for async handle.
void UvNoOp(uv_async_t* handle, int status) {
}
// Convert the given vector to an array of C-strings. The strings in the
// returned vector are only guaranteed valid so long as the vector of strings
// is not modified.
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)
array[i] = vector[i].c_str();
return array.Pass();
}
#if defined(OS_WIN)
std::vector<std::string> String16VectorToStringVector(
const std::vector<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(UTF16ToUTF8(vector[i]));
return utf8_vector;
}
#endif
} // namespace
node::Environment* global_env = NULL;
NodeBindings::NodeBindings(bool is_browser)
: is_browser_(is_browser),
message_loop_(NULL),
@ -54,84 +84,88 @@ NodeBindings::~NodeBindings() {
}
void NodeBindings::Initialize() {
CommandLine::StringVector str_argv = CommandLine::ForCurrentProcess()->argv();
#if defined(OS_WIN)
std::vector<std::string> utf8_str_argv;
utf8_str_argv.reserve(str_argv.size());
#endif
// Convert string vector to char* array.
std::vector<char*> argv(str_argv.size(), NULL);
for (size_t i = 0; i < str_argv.size(); ++i) {
#if defined(OS_WIN)
utf8_str_argv.push_back(UTF16ToUTF8(str_argv[i]));
argv[i] = const_cast<char*>(utf8_str_argv[i].c_str());
#else
argv[i] = const_cast<char*>(str_argv[i].c_str());
#endif
// Init idle GC for browser.
if (is_browser_) {
uv_timer_init(uv_default_loop(), &idle_timer_);
uv_timer_start(&idle_timer_, IdleCallback, 5000, 5000);
}
// Init idle GC.
uv_timer_init(uv_default_loop(), &idle_timer_);
uv_timer_start(&idle_timer_, IdleCallback, 5000, 5000);
// Open node's error reporting system for browser process.
node::g_standalone_mode = is_browser_;
node::g_upstream_node_mode = false;
// Init node.
node::Init(argv.size(), &argv[0]);
v8::V8::Initialize();
// Load node.js.
v8::HandleScope scope;
node::g_context = v8::Persistent<v8::Context>::New(
node::node_isolate, v8::Context::New(node::node_isolate));
{
v8::Context::Scope context_scope(node::g_context);
v8::Handle<v8::Object> process = node::SetupProcessObject(
argv.size(), &argv[0]);
// Tell node.js we are in browser or renderer.
v8::Handle<v8::String> type =
is_browser_ ? v8::String::New("browser") : v8::String::New("renderer");
process->Set(v8::String::New("__atom_type"), type);
}
// (we assume it would not node::Init would not modify the parameters under
// embedded mode).
node::Init(NULL, NULL, NULL, NULL);
}
void NodeBindings::Load() {
v8::HandleScope scope;
v8::Context::Scope context_scope(node::g_context);
node::Load(node::process);
}
node::Environment* NodeBindings::CreateEnvironment(
v8::Handle<v8::Context> context) {
std::vector<std::string> args =
#if defined(OS_WIN)
String16VectorToStringVector(CommandLine::ForCurrentProcess()->argv());
#else
CommandLine::ForCurrentProcess()->argv();
#endif
void NodeBindings::BindTo(WebKit::WebFrame* frame) {
v8::HandleScope handle_scope;
// Feed node the path to initialization script.
base::FilePath exec_path(CommandLine::ForCurrentProcess()->argv()[0]);
PathService::Get(base::FILE_EXE, &exec_path);
base::FilePath resources_path =
#if defined(OS_MACOSX)
is_browser_ ? exec_path.DirName().DirName().Append("Resources") :
exec_path.DirName().DirName().DirName().DirName().DirName()
.Append("Resources");
#else
exec_path.DirName().AppendASCII("resources");
#endif
base::FilePath script_path =
resources_path.AppendASCII(is_browser_ ? "browser" : "renderer")
.AppendASCII("lib")
.AppendASCII("init.js");
std::string script_path_str = script_path.AsUTF8Unsafe();
args.insert(args.begin() + 1, script_path_str.c_str());
v8::Handle<v8::Context> context = frame->mainWorldScriptContext();
if (context.IsEmpty())
return;
// Convert string vector to const char* array.
scoped_ptr<const char*[]> c_argv = StringVectorToArgArray(args);
v8::Context::Scope scope(context);
// Construct the parameters that passed to node::CreateEnvironment:
v8::Isolate* isolate = context->GetIsolate();
int argc = args.size();
const char** argv = c_argv.get();
int exec_argc = 0;
const char** exec_argv = NULL;
// Erase security token.
context->SetSecurityToken(node::g_context->GetSecurityToken());
using namespace v8; // NOLINT
using namespace node; // NOLINT
// Evaluate cefode.js.
v8::Handle<v8::Script> script = node::CompileCefodeMainSource();
v8::Local<v8::Value> result = script->Run();
// Following code are stripped from node::CreateEnvironment in node.cc:
HandleScope handle_scope(isolate);
Context::Scope context_scope(context);
// Run the script of cefode.js.
std::string script_path(GURL(frame->document().url()).path());
script_path = net::UnescapeURLComponent(
script_path,
net::UnescapeRule::SPACES | net::UnescapeRule::URL_SPECIAL_CHARS);
v8::Handle<v8::Value> args[2] = {
v8::Local<v8::Value>::New(node::process),
ToV8Value(script_path),
};
v8::Local<v8::Function>::Cast(result)->Call(context->Global(), 2, args);
Environment* env = Environment::New(context);
uv_check_init(env->event_loop(), env->immediate_check_handle());
uv_unref(
reinterpret_cast<uv_handle_t*>(env->immediate_check_handle()));
uv_idle_init(env->event_loop(), env->immediate_idle_handle());
uv_prepare_init(env->event_loop(), env->idle_prepare_handle());
uv_check_init(env->event_loop(), env->idle_check_handle());
uv_unref(reinterpret_cast<uv_handle_t*>(env->idle_prepare_handle()));
uv_unref(reinterpret_cast<uv_handle_t*>(env->idle_check_handle()));
Local<FunctionTemplate> process_template = FunctionTemplate::New();
process_template->SetClassName(FIXED_ONE_BYTE_STRING(isolate, "process"));
Local<Object> process_object = process_template->GetFunction()->NewInstance();
env->set_process_object(process_object);
SetupProcessObject(env, argc, argv, exec_argc, exec_argv);
Load(env);
return env;
}
void NodeBindings::PrepareMessageLoop() {
@ -160,8 +194,8 @@ void NodeBindings::UvRunOnce() {
DCHECK(!is_browser_ || BrowserThread::CurrentlyOn(BrowserThread::UI));
// Enter node context while dealing with uv events.
v8::HandleScope scope;
v8::Context::Scope context_scope(node::g_context);
v8::HandleScope handle_scope(node_isolate);
v8::Context::Scope context_scope(global_env->context());
// Deal with uv events.
int r = uv_run(uv_loop_, (uv_run_mode)(UV_RUN_ONCE | UV_RUN_NOWAIT));

24
common/node_bindings.h
View file

@ -2,20 +2,21 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef RAVE_COMMON_NODE_BINDINGS_
#define RAVE_COMMON_NODE_BINDINGS_
#ifndef ATOM_COMMON_NODE_BINDINGS_H_
#define ATOM_COMMON_NODE_BINDINGS_H_
#include "base/basictypes.h"
#include "v8/include/v8.h"
#include "vendor/node/deps/uv/include/uv.h"
namespace WebKit {
class WebFrame;
}
namespace base {
class MessageLoop;
}
namespace node {
class Environment;
}
namespace atom {
class NodeBindings {
@ -24,14 +25,11 @@ class NodeBindings {
virtual ~NodeBindings();
// Setup V8, libuv and the process object.
// Setup V8, libuv.
virtual void Initialize();
// Load node.js main script.
virtual void Load();
// Load cefode.js script under web frame.
virtual void BindTo(WebKit::WebFrame* frame);
// Create the environment and load node.js.
virtual node::Environment* CreateEnvironment(v8::Handle<v8::Context> context);
// Prepare for message loop integration.
virtual void PrepareMessageLoop();
@ -90,4 +88,4 @@ class NodeBindings {
} // namespace atom
#endif // RAVE_COMMON_NODE_BINDINGS_
#endif // ATOM_COMMON_NODE_BINDINGS_H_

20
common/node_bindings_mac.cc
View file

@ -9,8 +9,7 @@
#include <sys/time.h>
#include <sys/types.h>
#include "vendor/node/src/node.h"
#include "vendor/node/src/node_internals.h"
#include "common/v8/node_common.h"
namespace atom {
@ -27,23 +26,6 @@ NodeBindingsMac::NodeBindingsMac(bool is_browser)
NodeBindingsMac::~NodeBindingsMac() {
}
void NodeBindingsMac::RunMessageLoop() {
// Get notified when libuv's watcher queue changes.
uv_loop_->data = this;
uv_loop_->on_watcher_queue_updated = OnWatcherQueueChanged;
NodeBindings::RunMessageLoop();
}
// static
void NodeBindingsMac::OnWatcherQueueChanged(uv_loop_t* loop) {
NodeBindingsMac* self = static_cast<NodeBindingsMac*>(loop->data);
// We need to break the io polling in the kqueue thread when loop's watcher
// queue changes, otherwise new events cannot be notified.
self->WakeupEmbedThread();
}
void NodeBindingsMac::PollEvents() {
struct timespec spec;
int timeout = uv_backend_timeout(uv_loop_);

5
common/node_bindings_mac.h
View file

@ -15,12 +15,7 @@ class NodeBindingsMac : public NodeBindings {
explicit NodeBindingsMac(bool is_browser);
virtual ~NodeBindingsMac();
virtual void RunMessageLoop() OVERRIDE;
private:
// Called when uv's watcher queue changes.
static void OnWatcherQueueChanged(uv_loop_t* loop);
virtual void PollEvents() OVERRIDE;
// Kqueue to poll for uv's backend fd.

3
common/node_bindings_win.cc
View file

@ -9,7 +9,6 @@
#include "base/logging.h"
extern "C" {
#include "vendor/node/deps/uv/include/uv-private/ngx-queue.h"
#include "vendor/node/deps/uv/src/win/internal.h"
}
@ -32,7 +31,7 @@ void NodeBindingsWin::PollEvents() {
uv_loop_->endgame_handles == NULL &&
!uv_loop_->stop_flag &&
(uv_loop_->active_handles > 0 ||
!ngx_queue_empty(&uv_loop_->active_reqs));
!QUEUE_EMPTY(&uv_loop_->active_reqs));
// When there is no other types of events, we block on the IOCP.
if (block) {

2
common/platform_util_mac.mm
View file

@ -12,7 +12,7 @@
#include "base/mac/mac_logging.h"
#include "base/mac/scoped_aedesc.h"
#include "base/strings/sys_string_conversions.h"
#include "googleurl/src/gurl.h"
#include "url/gurl.h"
namespace platform_util {

6
common/platform_util_win.cc
View file

@ -14,13 +14,13 @@
#include "base/bind_helpers.h"
#include "base/files/file_path.h"
#include "base/logging.h"
#include "base/string_util.h"
#include "base/utf_string_conversions.h"
#include "base/strings/string_util.h"
#include "base/strings/utf_string_conversions.h"
#include "base/win/registry.h"
#include "base/win/scoped_co_mem.h"
#include "base/win/scoped_comptr.h"
#include "base/win/windows_version.h"
#include "googleurl/src/gurl.h"
#include "url/gurl.h"
#include "ui/base/win/shell.h"
namespace {

48
common/v8_conversions.h → common/v8/native_type_conversions.h
View file

@ -2,24 +2,24 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef COMMON_V8_CONVERSIONS_H_
#define COMMON_V8_CONVERSIONS_H_
#ifndef ATOM_COMMON_V8_NATIVE_TYPE_CONVERSIONS_H_
#define ATOM_COMMON_V8_NATIVE_TYPE_CONVERSIONS_H_
#include <map>
#include <string>
#include <vector>
#include "base/files/file_path.h"
#include "base/string16.h"
#include "base/strings/string16.h"
#include "base/template_util.h"
#include "base/values.h"
#include "browser/api/atom_api_window.h"
#include "common/swap_or_assign.h"
#include "common/v8_value_converter_impl.h"
#include "common/v8/scoped_persistent.h"
#include "common/v8/v8_value_converter.h"
#include "content/public/renderer/v8_value_converter.h"
#include "googleurl/src/gurl.h"
#include "ui/gfx/rect.h"
#include "v8/include/v8.h"
#include "url/gurl.h"
// Convert V8 value to arbitrary supported types.
struct FromV8Value {
@ -66,8 +66,7 @@ struct FromV8Value {
}
operator scoped_ptr<base::Value>() {
scoped_ptr<content::V8ValueConverter> converter(
new atom::V8ValueConverterImpl);
scoped_ptr<atom::V8ValueConverter> converter(new atom::V8ValueConverter);
return scoped_ptr<base::Value>(
converter->FromV8Value(value_, v8::Context::GetCurrent()));
}
@ -104,10 +103,10 @@ struct FromV8Value {
return NULL;
}
operator v8::Persistent<v8::Function>() {
return v8::Persistent<v8::Function>::New(
node::node_isolate,
v8::Handle<v8::Function>::Cast(value_));
operator atom::RefCountedV8Function() {
v8::Handle<v8::Function> func = v8::Handle<v8::Function>::Cast(value_);
return atom::RefCountedV8Function(
new atom::RefCountedPersistent<v8::Function>(func));
}
v8::Handle<v8::Value> value_;
@ -226,14 +225,16 @@ bool V8ValueCanBeConvertedTo<atom::NativeWindow*>(v8::Handle<v8::Value> value) {
}
template<> inline
bool V8ValueCanBeConvertedTo<v8::Persistent<v8::Function>>(
bool V8ValueCanBeConvertedTo<atom::RefCountedV8Function>(
v8::Handle<v8::Value> value) {
return value->IsFunction();
}
// Check and convert V8's Arguments to native types.
template<typename T1> inline
bool FromV8Arguments(const v8::Arguments& args, T1* value, int index = 0) {
bool FromV8Arguments(const v8::FunctionCallbackInfo<v8::Value>& args,
T1* value,
int index = 0) {
if (!V8ValueCanBeConvertedTo<T1>(args[index]))
return false;
internal::SwapOrAssign(*value,
@ -242,18 +243,23 @@ bool FromV8Arguments(const v8::Arguments& args, T1* value, int index = 0) {
}
template<typename T1, typename T2> inline
bool FromV8Arguments(const v8::Arguments& args, T1* a1, T2* a2) {
bool FromV8Arguments(const v8::FunctionCallbackInfo<v8::Value>& args,
T1* a1,
T2* a2) {
return FromV8Arguments<T1>(args, a1) && FromV8Arguments<T2>(args, a2, 1);
}
template<typename T1, typename T2, typename T3> inline
bool FromV8Arguments(const v8::Arguments& args, T1* a1, T2* a2, T3* a3) {
bool FromV8Arguments(const v8::FunctionCallbackInfo<v8::Value>& args,
T1* a1,
T2* a2,
T3* a3) {
return FromV8Arguments<T1, T2>(args, a1, a2) &&
FromV8Arguments<T3>(args, a3, 2);
}
template<typename T1, typename T2, typename T3, typename T4> inline
bool FromV8Arguments(const v8::Arguments& args,
bool FromV8Arguments(const v8::FunctionCallbackInfo<v8::Value>& args,
T1* a1,
T2* a2,
T3* a3,
@ -263,7 +269,7 @@ bool FromV8Arguments(const v8::Arguments& args,
}
template<typename T1, typename T2, typename T3, typename T4, typename T5> inline
bool FromV8Arguments(const v8::Arguments& args,
bool FromV8Arguments(const v8::FunctionCallbackInfo<v8::Value>& args,
T1* a1,
T2* a2,
T3* a3,
@ -275,7 +281,7 @@ bool FromV8Arguments(const v8::Arguments& args,
template<typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6> inline
bool FromV8Arguments(const v8::Arguments& args,
bool FromV8Arguments(const v8::FunctionCallbackInfo<v8::Value>& args,
T1* a1,
T2* a2,
T3* a3,
@ -288,7 +294,7 @@ bool FromV8Arguments(const v8::Arguments& args,
template<typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7> inline
bool FromV8Arguments(const v8::Arguments& args,
bool FromV8Arguments(const v8::FunctionCallbackInfo<v8::Value>& args,
T1* a1,
T2* a2,
T3* a3,
@ -301,4 +307,4 @@ bool FromV8Arguments(const v8::Arguments& args,
FromV8Arguments<T7>(args, a7, 6);
}
#endif // COMMON_V8_CONVERSIONS_H_
#endif // ATOM_COMMON_V8_NATIVE_TYPE_CONVERSIONS_H_

25
common/v8/node_common.h Normal file
View file

@ -0,0 +1,25 @@
// Copyright (c) 2013 GitHub, Inc. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef ATOM_COMMON_V8_NODE_COMMON_H_
#define ATOM_COMMON_V8_NODE_COMMON_H_
// Include common headers for using node APIs.
#undef CHECK
#undef DISALLOW_COPY_AND_ASSIGN
#include "vendor/node/src/env.h"
#include "vendor/node/src/env-inl.h"
#include "vendor/node/src/node.h"
#include "vendor/node/src/node_internals.h"
using node::node_isolate;
namespace atom {
// Defined in node_bindings.cc.
// For renderer it's created in atom_renderer_client.cc.
// For browser it's created in atom_browser_main_parts.cc.
extern node::Environment* global_env;
}
#endif // ATOM_COMMON_V8_NODE_COMMON_H_

115
common/v8/scoped_persistent.h Normal file
View file

@ -0,0 +1,115 @@
// Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef ATOM_COMMON_SCOPED_PERSISTENT_H_
#define ATOM_COMMON_SCOPED_PERSISTENT_H_
#include "base/logging.h"
#include "base/memory/ref_counted.h"
#include "v8/include/v8.h"
namespace atom {
// A v8::Persistent handle to a V8 value which destroys and clears the
// underlying handle on destruction.
template <typename T>
class ScopedPersistent {
public:
ScopedPersistent() {
}
explicit ScopedPersistent(v8::Handle<T> handle) {
reset(handle);
}
~ScopedPersistent() {
reset();
}
void reset(v8::Handle<T> handle) {
if (!handle.IsEmpty())
handle_.Reset(GetIsolate(handle), handle);
else
reset();
}
void reset() {
handle_.Reset();
}
bool IsEmpty() const {
return handle_.IsEmpty();
}
v8::Handle<T> NewHandle() const {
if (handle_.IsEmpty())
return v8::Local<T>();
return v8::Local<T>::New(GetIsolate(handle_), handle_);
}
v8::Handle<T> NewHandle(v8::Isolate* isolate) const {
if (handle_.IsEmpty())
return v8::Local<T>();
return v8::Local<T>::New(isolate, handle_);
}
template <typename P>
void MakeWeak(P* parameters,
typename v8::WeakReferenceCallbacks<T, P>::Revivable callback) {
handle_.MakeWeak(parameters, callback);
}
private:
template <typename U>
static v8::Isolate* GetIsolate(v8::Handle<U> object_handle) {
// Only works for v8::Object and its subclasses. Add specialisations for
// anything else.
if (!object_handle.IsEmpty())
return GetIsolate(object_handle->CreationContext());
return v8::Isolate::GetCurrent();
}
static v8::Isolate* GetIsolate(v8::Handle<v8::Context> context_handle) {
if (!context_handle.IsEmpty())
return context_handle->GetIsolate();
return v8::Isolate::GetCurrent();
}
static v8::Isolate* GetIsolate(
v8::Handle<v8::ObjectTemplate> template_handle) {
return v8::Isolate::GetCurrent();
}
template <typename U>
static v8::Isolate* GetIsolate(const U& any_handle) {
return v8::Isolate::GetCurrent();
}
v8::Persistent<T> handle_;
DISALLOW_COPY_AND_ASSIGN(ScopedPersistent);
};
template <typename T>
class RefCountedPersistent : public ScopedPersistent<T>,
public base::RefCounted<RefCountedPersistent<T>> {
public:
RefCountedPersistent() {}
explicit RefCountedPersistent(v8::Handle<T> handle)
: ScopedPersistent<T>(handle) {
}
protected:
friend class base::RefCounted<RefCountedPersistent<T>>;
~RefCountedPersistent() {}
private:
DISALLOW_COPY_AND_ASSIGN(RefCountedPersistent);
};
typedef scoped_refptr<RefCountedPersistent<v8::Function>> RefCountedV8Function;
typedef scoped_refptr<RefCountedPersistent<v8::Object>> RefCountedV8Object;
} // namespace atom
#endif // ATOM_COMMON_SCOPED_PERSISTENT_H_

35
common/v8_value_converter_impl.cc → common/v8/v8_value_converter.cc
View file

@ -2,57 +2,56 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "common/v8_value_converter_impl.h"
#include "common/v8/v8_value_converter.h"
#include <string>
#include "base/logging.h"
#include "base/memory/scoped_ptr.h"
#include "base/values.h"
#include "v8/include/v8.h"
namespace atom {
V8ValueConverterImpl::V8ValueConverterImpl()
V8ValueConverter::V8ValueConverter()
: date_allowed_(false),
reg_exp_allowed_(false),
function_allowed_(false),
strip_null_from_objects_(false),
avoid_identity_hash_for_testing_(false) {}
void V8ValueConverterImpl::SetDateAllowed(bool val) {
void V8ValueConverter::SetDateAllowed(bool val) {
date_allowed_ = val;
}
void V8ValueConverterImpl::SetRegExpAllowed(bool val) {
void V8ValueConverter::SetRegExpAllowed(bool val) {
reg_exp_allowed_ = val;
}
void V8ValueConverterImpl::SetFunctionAllowed(bool val) {
void V8ValueConverter::SetFunctionAllowed(bool val) {
function_allowed_ = val;
}
void V8ValueConverterImpl::SetStripNullFromObjects(bool val) {
void V8ValueConverter::SetStripNullFromObjects(bool val) {
strip_null_from_objects_ = val;
}
v8::Handle<v8::Value> V8ValueConverterImpl::ToV8Value(
v8::Handle<v8::Value> V8ValueConverter::ToV8Value(
const base::Value* value, v8::Handle<v8::Context> context) const {
v8::Context::Scope context_scope(context);
v8::HandleScope handle_scope;
v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
return handle_scope.Close(ToV8ValueImpl(value));
}
Value* V8ValueConverterImpl::FromV8Value(
Value* V8ValueConverter::FromV8Value(
v8::Handle<v8::Value> val,
v8::Handle<v8::Context> context) const {
v8::Context::Scope context_scope(context);
v8::HandleScope handle_scope;
v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
HashToHandleMap unique_map;
return FromV8ValueImpl(val, &unique_map);
}
v8::Handle<v8::Value> V8ValueConverterImpl::ToV8ValueImpl(
v8::Handle<v8::Value> V8ValueConverter::ToV8ValueImpl(
const base::Value* value) const {
CHECK(value);
switch (value->GetType()) {
@ -95,7 +94,7 @@ v8::Handle<v8::Value> V8ValueConverterImpl::ToV8ValueImpl(
}
}
v8::Handle<v8::Value> V8ValueConverterImpl::ToV8Array(
v8::Handle<v8::Value> V8ValueConverter::ToV8Array(
const base::ListValue* val) const {
v8::Handle<v8::Array> result(v8::Array::New(val->GetSize()));
@ -115,7 +114,7 @@ v8::Handle<v8::Value> V8ValueConverterImpl::ToV8Array(
return result;
}
v8::Handle<v8::Value> V8ValueConverterImpl::ToV8Object(
v8::Handle<v8::Value> V8ValueConverter::ToV8Object(
const base::DictionaryValue* val) const {
v8::Handle<v8::Object> result(v8::Object::New());
@ -136,7 +135,7 @@ v8::Handle<v8::Value> V8ValueConverterImpl::ToV8Object(
return result;
}
Value* V8ValueConverterImpl::FromV8ValueImpl(v8::Handle<v8::Value> val,
Value* V8ValueConverter::FromV8ValueImpl(v8::Handle<v8::Value> val,
HashToHandleMap* unique_map) const {
CHECK(!val.IsEmpty());
@ -196,7 +195,7 @@ Value* V8ValueConverterImpl::FromV8ValueImpl(v8::Handle<v8::Value> val,
return NULL;
}
Value* V8ValueConverterImpl::FromV8Array(v8::Handle<v8::Array> val,
Value* V8ValueConverter::FromV8Array(v8::Handle<v8::Array> val,
HashToHandleMap* unique_map) const {
if (!UpdateAndCheckUniqueness(unique_map, val))
return base::Value::CreateNullValue();
@ -233,7 +232,7 @@ Value* V8ValueConverterImpl::FromV8Array(v8::Handle<v8::Array> val,
return result;
}
Value* V8ValueConverterImpl::FromV8Object(
Value* V8ValueConverter::FromV8Object(
v8::Handle<v8::Object> val,
HashToHandleMap* unique_map) const {
if (!UpdateAndCheckUniqueness(unique_map, val))
@ -310,7 +309,7 @@ Value* V8ValueConverterImpl::FromV8Object(
return result.release();
}
bool V8ValueConverterImpl::UpdateAndCheckUniqueness(
bool V8ValueConverter::UpdateAndCheckUniqueness(
HashToHandleMap* map,
v8::Handle<v8::Object> handle) const {
typedef HashToHandleMap::const_iterator Iterator;

36
common/v8_value_converter_impl.h → common/v8/v8_value_converter.h
View file

@ -2,14 +2,14 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef ATOM_COMMON_V8_VALUE_CONVERTER_IMPL_H_
#define ATOM_COMMON_V8_VALUE_CONVERTER_IMPL_H_
#ifndef ATOM_COMMON_V8_V8_VALUE_CONVERTER_H_
#define ATOM_COMMON_V8_V8_VALUE_CONVERTER_H_
#include <map>
#include "base/basictypes.h"
#include "base/compiler_specific.h"
#include "content/public/renderer/v8_value_converter.h"
#include "v8/include/v8.h"
namespace base {
class BinaryValue;
@ -20,26 +20,20 @@ class Value;
namespace atom {
// The content::V8ValueConverter depends on WebKit, we get rid of the WebKit
// dependency by removing support of binary data.
class V8ValueConverterImpl : public content::V8ValueConverter {
class V8ValueConverter {
public:
V8ValueConverterImpl();
V8ValueConverter();
// V8ValueConverter implementation.
virtual void SetDateAllowed(bool val) OVERRIDE;
virtual void SetRegExpAllowed(bool val) OVERRIDE;
virtual void SetFunctionAllowed(bool val) OVERRIDE;
virtual void SetStripNullFromObjects(bool val) OVERRIDE;
virtual v8::Handle<v8::Value> ToV8Value(
const base::Value* value,
v8::Handle<v8::Context> context) const OVERRIDE;
virtual base::Value* FromV8Value(
v8::Handle<v8::Value> value,
v8::Handle<v8::Context> context) const OVERRIDE;
void SetDateAllowed(bool val);
void SetRegExpAllowed(bool val);
void SetFunctionAllowed(bool val);
void SetStripNullFromObjects(bool val);
v8::Handle<v8::Value> ToV8Value(const base::Value* value,
v8::Handle<v8::Context> context) const;
base::Value* FromV8Value(v8::Handle<v8::Value> value,
v8::Handle<v8::Context> context) const;
private:
friend class ScopedAvoidIdentityHashForTesting;
typedef std::multimap<int, v8::Handle<v8::Object> > HashToHandleMap;
v8::Handle<v8::Value> ToV8ValueImpl(const base::Value* value) const;
@ -78,9 +72,9 @@ class V8ValueConverterImpl : public content::V8ValueConverter {
bool avoid_identity_hash_for_testing_;
DISALLOW_COPY_AND_ASSIGN(V8ValueConverterImpl);
DISALLOW_COPY_AND_ASSIGN(V8ValueConverter);
};
} // namespace atom
#endif // ATOM_COMMON_V8_VALUE_CONVERTER_IMPL_H_
#endif // ATOM_COMMON_V8_V8_VALUE_CONVERTER_H_

1
docs/README.md
View file

@ -22,7 +22,6 @@ Renderer side modules:
Browser side modules:
* [app](api/browser/app.md)
* [atom-delegate](api/browser/atom-delegate.md)
* [auto-updater](api/browser/auto-updater.md)
* [browser-window](api/browser/browser-window.md)
* [dialog](api/browser/dialog.md)

16
docs/api/browser/app.md
View file

@ -13,11 +13,17 @@ app.on('window-all-closed', function() {
## Event: will-finish-launching
Setup crash reporter and auto updater here.
Emitted when application has done basic startup. On Windows and Linux it is the
same with `ready` event, on OS X this event represents the
`applicationWillFinishLaunching` message of `NSApplication`, usually you would
setup listeners to `open-file` and `open-url` events here, and start the crash
reporter and auto updater.
## Event: finish-launching
Under most cases you should just do everything in `ready` event.
Do final startup like creating browser window here.
## Event: ready
Emitted when atom-shell has done everything initializaiton.
## Event: window-all-closed
@ -91,10 +97,6 @@ to the spec of npm modules. So usually you should also specify a `productName`
field, which is your application's full capitalized name, and it will be
preferred over `name` by atom-shell.
## app.getBrowserWindows()
Returns an array of all browser windows.
## app.commandLine.appendSwitch(switch, [value])
Append a switch [with optional value] to Chromium's command line.

31
docs/api/browser/atom-delegate.md
View file

@ -1,31 +0,0 @@
# atom-delegate
The `atom-delegate` returns the delegate object for Chrome Content API. The
atom-shell would call methods of the delegate object when the corresponding
C++ code is called. Developers can override methods of it to control the
underlying behaviour of the browser.
An example of creating a new window when the browser is initialized:
```javascript
var delegate = require('atom-delegate'); // Delegate of Content API.
var BrowserWindow = require('browser-window'); // Module to create native 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;
// This method will be called when atom-shell has done everything
// initialization and ready for creating browser windows.
delegate.browserMainParts.preMainMessageLoopRun = function() {
// Create the browser window,
mainWindow = new BrowserWindow({ width: 800, height: 600 });
// and load the index.html of the app.
mainWindow.loadUrl('file://' + __dirname + '/index.html');
}
```
## atom-delegate.browserMainParts.preMainMessageLoopRun()
Called when atom-shell has done everything initialization and ready for
creating browser windows.

4
docs/api/browser/browser-window.md
View file

@ -99,6 +99,10 @@ shouldn't!).
Emitted when the memory taken by the native window is released. Usually you
should dereference the javascript object when received this event.
### Class Method: BrowserWindow.getAllWindows()
Returns an array of all opened browser windows.
### Class Method: BrowserWindow.getFocusedWindow()
Returns the window that is focused in this application.

5
docs/quick-start.md
View file

@ -53,7 +53,6 @@ every piece of the app. An example of `main.js` is:
```javascript
var app = require('app'); // Module to control application life.
var delegate = require('atom_delegate'); // Delegate of Content API.
var Window = require('window'); // Module to create native browser window.
// Keep a global reference of the window object, if you don't, the window will
@ -67,7 +66,7 @@ app.on('window-all-closed', function() {
// This method will be called when atom-shell has done everything
// initialization and ready for creating browser windows.
delegate.browserMainParts.preMainMessageLoopRun = function() {
app.on('ready', function() {
// Create the browser window,
mainWindow = new Window({ width: 800, height: 600 });
// and load the index.html of the app.
@ -89,7 +88,7 @@ delegate.browserMainParts.preMainMessageLoopRun = function() {
// when you should delete the corresponding element.
mainWindow = null;
});
}
});
```
Finally the `index.html` is the web page you want to show, in fact you

Some files were not shown because too many files have changed in this diff Show more