auto command_line = base::CommandLine::ForCurrentProcess();
mate::Dictionary dict(isolate, exports);
+ dict.Set("App", atom::api::App::GetConstructor(isolate)->GetFunction());
dict.Set("app", atom::api::App::Create(isolate));
dict.SetMethod("appendSwitch", &AppendSwitch);
dict.SetMethod("appendArgument",
namespace {
+using atom::api::AutoUpdater;
+
void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
v8::Local<v8::Context> context, void* priv) {
v8::Isolate* isolate = context->GetIsolate();
mate::Dictionary dict(isolate, exports);
- dict.Set("autoUpdater", atom::api::AutoUpdater::Create(isolate));
+ dict.Set("autoUpdater", AutoUpdater::Create(isolate));
+ dict.Set("AutoUpdater", AutoUpdater::GetConstructor(isolate)->GetFunction());
}
} // namespace
namespace api {
-namespace {
-
-// The wrapDebugger funtion which is implemented in JavaScript.
-using WrapDebuggerCallback = base::Callback<void(v8::Local<v8::Value>)>;
-WrapDebuggerCallback g_wrap_debugger;
-
-} // namespace
-
Debugger::Debugger(v8::Isolate* isolate, content::WebContents* web_contents)
: web_contents_(web_contents),
previous_request_id_(0) {
mate::Handle<Debugger> Debugger::Create(
v8::Isolate* isolate,
content::WebContents* web_contents) {
- auto handle = mate::CreateHandle(
- isolate, new Debugger(isolate, web_contents));
- g_wrap_debugger.Run(handle.ToV8());
- return handle;
+ return mate::CreateHandle(isolate, new Debugger(isolate, web_contents));
}
// static
.SetMethod("sendCommand", &Debugger::SendCommand);
}
-void SetWrapDebugger(const WrapDebuggerCallback& callback) {
- g_wrap_debugger = callback;
-}
-
} // namespace api
} // namespace atom
namespace {
+using atom::api::Debugger;
+
void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
v8::Local<v8::Context> context, void* priv) {
v8::Isolate* isolate = context->GetIsolate();
- mate::Dictionary dict(isolate, exports);
- dict.SetMethod("_setWrapDebugger", &atom::api::SetWrapDebugger);
+ mate::Dictionary(isolate, exports)
+ .Set("Debugger", Debugger::GetConstructor(isolate)->GetFunction());
}
} // namespace
namespace {
-// The wrapDownloadItem funtion which is implemented in JavaScript
-using WrapDownloadItemCallback = base::Callback<void(v8::Local<v8::Value>)>;
-WrapDownloadItemCallback g_wrap_download_item;
-
std::map<uint32_t, v8::Global<v8::Object>> g_download_item_objects;
} // namespace
return mate::CreateHandle(isolate, static_cast<DownloadItem*>(existing));
auto handle = mate::CreateHandle(isolate, new DownloadItem(isolate, item));
- g_wrap_download_item.Run(handle.ToV8());
// Reference this object in case it got garbage collected.
g_download_item_objects[handle->weak_map_id()] =
return handle;
}
-void SetWrapDownloadItem(const WrapDownloadItemCallback& callback) {
- g_wrap_download_item = callback;
-}
-
} // namespace api
} // namespace atom
void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
v8::Local<v8::Context> context, void* priv) {
v8::Isolate* isolate = context->GetIsolate();
- mate::Dictionary dict(isolate, exports);
- dict.SetMethod("_setWrapDownloadItem", &atom::api::SetWrapDownloadItem);
+ mate::Dictionary(isolate, exports)
+ .Set("DownloadItem",
+ atom::api::DownloadItem::GetConstructor(isolate)->GetFunction());
}
} // namespace
namespace {
+using atom::api::PowerMonitor;
+
void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
v8::Local<v8::Context> context, void* priv) {
#if defined(OS_MACOSX)
base::PowerMonitorDeviceSource::AllocateSystemIOPorts();
#endif
- using atom::api::PowerMonitor;
v8::Isolate* isolate = context->GetIsolate();
mate::Dictionary dict(isolate, exports);
dict.Set("powerMonitor", PowerMonitor::Create(isolate));
+ dict.Set("PowerMonitor",
+ PowerMonitor::GetConstructor(isolate)->GetFunction());
}
} // namespace
namespace {
+using atom::api::Screen;
+
void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
v8::Local<v8::Context> context, void* priv) {
- mate::Dictionary dict(context->GetIsolate(), exports);
- dict.Set("screen", atom::api::Screen::Create(context->GetIsolate()));
+ v8::Isolate* isolate = context->GetIsolate();
+ mate::Dictionary dict(isolate, exports);
+ dict.Set("screen", Screen::Create(isolate));
+ dict.Set("Screen", Screen::GetConstructor(isolate)->GetFunction());
}
} // namespace
const char kPersistPrefix[] = "persist:";
-// The wrapSession funtion which is implemented in JavaScript
-using WrapSessionCallback = base::Callback<void(v8::Local<v8::Value>)>;
-WrapSessionCallback g_wrap_session;
-
// Referenced session objects.
std::map<uint32_t, v8::Global<v8::Object>> g_sessions;
auto handle = mate::CreateHandle(
isolate, new Session(isolate, browser_context));
- g_wrap_session.Run(handle.ToV8());
// The Sessions should never be garbage collected, since the common pattern is
// to use partition strings, instead of using the Session object directly.
.SetProperty("webRequest", &Session::WebRequest);
}
-void SetWrapSession(const WrapSessionCallback& callback) {
- g_wrap_session = callback;
-}
-
} // namespace api
} // namespace atom
namespace {
+using atom::api::Session;
+
v8::Local<v8::Value> FromPartition(
const std::string& partition, mate::Arguments* args) {
if (!atom::Browser::Get()->is_ready()) {
}
base::DictionaryValue options;
args->GetNext(&options);
- return atom::api::Session::FromPartition(
- args->isolate(), partition, options).ToV8();
+ return Session::FromPartition(args->isolate(), partition, options).ToV8();
}
void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
v8::Local<v8::Context> context, void* priv) {
v8::Isolate* isolate = context->GetIsolate();
mate::Dictionary dict(isolate, exports);
+ dict.Set("Session", Session::GetConstructor(isolate)->GetFunction());
dict.SetMethod("fromPartition", &FromPartition);
- dict.SetMethod("_setWrapSession", &atom::api::SetWrapSession);
}
} // namespace
namespace {
+using atom::api::SystemPreferences;
+
void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
v8::Local<v8::Context> context, void* priv) {
v8::Isolate* isolate = context->GetIsolate();
mate::Dictionary dict(isolate, exports);
- dict.Set("systemPreferences", atom::api::SystemPreferences::Create(isolate));
+ dict.Set("systemPreferences", SystemPreferences::Create(isolate));
+ dict.Set("SystemPreferences",
+ SystemPreferences::GetConstructor(isolate)->GetFunction());
}
} // namespace
namespace {
-// The wrapWebContents function which is implemented in JavaScript
-using WrapWebContentsCallback = base::Callback<void(v8::Local<v8::Value>)>;
-WrapWebContentsCallback g_wrap_web_contents;
-
content::ServiceWorkerContext* GetServiceWorkerContext(
const content::WebContents* web_contents) {
auto context = web_contents->GetBrowserContext();
return mate::CreateHandle(isolate, static_cast<WebContents*>(existing));
// Otherwise create a new WebContents wrapper object.
- auto handle = mate::CreateHandle(
- isolate, new WebContents(isolate, web_contents));
- g_wrap_web_contents.Run(handle.ToV8());
- return handle;
+ return mate::CreateHandle(isolate, new WebContents(isolate, web_contents));
}
// static
mate::Handle<WebContents> WebContents::Create(
v8::Isolate* isolate, const mate::Dictionary& options) {
- auto handle = mate::CreateHandle(isolate, new WebContents(isolate, options));
- g_wrap_web_contents.Run(handle.ToV8());
- return handle;
-}
-
-void SetWrapWebContents(const WrapWebContentsCallback& callback) {
- g_wrap_web_contents = callback;
+ return mate::CreateHandle(isolate, new WebContents(isolate, options));
}
} // namespace api
} // namespace atom
-
namespace {
+using atom::api::WebContents;
+
void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
v8::Local<v8::Context> context, void* priv) {
v8::Isolate* isolate = context->GetIsolate();
mate::Dictionary dict(isolate, exports);
- dict.SetMethod("create", &atom::api::WebContents::Create);
- dict.SetMethod("_setWrapWebContents", &atom::api::SetWrapWebContents);
- dict.SetMethod("fromId",
- &mate::TrackableObject<atom::api::WebContents>::FromWeakMapID);
+ dict.Set("WebContents", WebContents::GetConstructor(isolate)->GetFunction());
+ dict.SetMethod("create", &WebContents::Create);
+ dict.SetMethod("fromId", &mate::TrackableObject<WebContents>::FromWeakMapID);
dict.SetMethod("getAllWebContents",
- &mate::TrackableObject<atom::api::WebContents>::GetAll);
+ &mate::TrackableObject<WebContents>::GetAll);
}
} // namespace
namespace {
-// The prototype of Node's EventEmitter.
-v8::Persistent<v8::Object> g_event_emitter_prototype;
-
v8::Persistent<v8::ObjectTemplate> event_template;
void PreventDefault(mate::Arguments* args) {
return obj.GetHandle();
}
-void InheritFromEventEmitter(v8::Isolate* isolate,
- v8::Local<v8::FunctionTemplate> constructor) {
-}
-
-void SetEventEmitterPrototype(v8::Isolate* isolate,
- v8::Local<v8::Object> prototype) {
- g_event_emitter_prototype.Reset(isolate, prototype);
-}
-
} // namespace internal
} // namespace mate
-
-
-namespace {
-
-void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
- v8::Local<v8::Context> context, void* priv) {
- mate::Dictionary(context->GetIsolate(), exports)
- .SetMethod("setEventEmitterPrototype",
- &mate::internal::SetEventEmitterPrototype);
-}
-
-} // namespace
-
-NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_event_emitter, Initialize)
v8::Local<v8::Object> event);
v8::Local<v8::Object> CreateEventFromFlags(v8::Isolate* isolate, int flags);
-void InheritFromEventEmitter(v8::Isolate* isolate,
- v8::Local<v8::FunctionTemplate> constructor);
-
} // namespace internal
// Provide helperers to emit event in JavaScript.
protected:
EventEmitter() {}
- static void InheritFromEventEmitter(
- v8::Isolate* isolate, v8::Local<v8::FunctionTemplate> constructor) {
- internal::InheritFromEventEmitter(isolate, constructor);
- }
-
private:
// this.emit(name, event, args...);
template<typename... Args>
'use strict'
const bindings = process.atomBinding('app')
-const {app} = bindings
+const {app, App} = bindings
// Only one app object permitted.
module.exports = app
const {deprecate, Menu} = electron
const {EventEmitter} = require('events')
-Object.setPrototypeOf(app.__proto__, EventEmitter.prototype)
+Object.setPrototypeOf(App.prototype, EventEmitter.prototype)
let appPath = null
}
// Wrappers for native classes.
-process.atomBinding('download_item')._setWrapDownloadItem((downloadItem) => {
- // downloadItem is an EventEmitter.
- Object.setPrototypeOf(downloadItem.__proto__, EventEmitter.prototype)
-})
+const {DownloadItem} = process.atomBinding('download_item')
+Object.setPrototypeOf(DownloadItem.prototype, EventEmitter.prototype)
const EventEmitter = require('events').EventEmitter
-const autoUpdater = process.atomBinding('auto_updater').autoUpdater
+const {autoUpdater, AutoUpdater} = process.atomBinding('auto_updater')
-Object.setPrototypeOf(autoUpdater.__proto__, EventEmitter.prototype)
+Object.setPrototypeOf(AutoUpdater.prototype, EventEmitter.prototype)
module.exports = autoUpdater
const {EventEmitter} = require('events')
-const {powerMonitor} = process.atomBinding('power_monitor')
+const {powerMonitor, PowerMonitor} = process.atomBinding('power_monitor')
-Object.setPrototypeOf(powerMonitor.__proto__, EventEmitter.prototype)
+Object.setPrototypeOf(PowerMonitor.prototype, EventEmitter.prototype)
module.exports = powerMonitor
const {EventEmitter} = require('events')
-const {screen} = process.atomBinding('screen')
+const {screen, Screen} = process.atomBinding('screen')
-Object.setPrototypeOf(screen.__proto__, EventEmitter.prototype)
+Object.setPrototypeOf(Screen.prototype, EventEmitter.prototype)
module.exports = screen
const {EventEmitter} = require('events')
const {app} = require('electron')
-const {fromPartition, _setWrapSession} = process.atomBinding('session')
+const {fromPartition, Session} = process.atomBinding('session')
// Public API.
Object.defineProperties(exports, {
}
})
-// Wraps native Session class.
-_setWrapSession(function (session) {
- // Session is an EventEmitter.
- Object.setPrototypeOf(session.__proto__, EventEmitter.prototype)
- app.emit('session-created', session)
-})
+Object.setPrototypeOf(Session.prototype, EventEmitter.prototype)
+
+Session.prototype._init = function () {
+ app.emit('session-created', this)
+}
const {EventEmitter} = require('events')
-const {systemPreferences} = process.atomBinding('system_preferences')
+const {systemPreferences, SystemPreferences} = process.atomBinding('system_preferences')
-Object.setPrototypeOf(systemPreferences.__proto__, EventEmitter.prototype)
+Object.setPrototypeOf(SystemPreferences.prototype, EventEmitter.prototype)
module.exports = systemPreferences
// before the webContents module.
session
-const binding = process.atomBinding('web_contents')
-const debuggerBinding = process.atomBinding('debugger')
-
let nextId = 0
const getNextId = function () {
return ++nextId
shouldPrintSelectionOnly: false
}
+const binding = process.atomBinding('web_contents')
+const {WebContents} = binding
+
+Object.setPrototypeOf(WebContents.prototype, EventEmitter.prototype)
+
// Following methods are mapped to webFrame.
const webFrameMethods = [
'insertText',
]
// Add JavaScript wrappers for WebContents class.
-const wrapWebContents = function (webContents) {
- // webContents is an EventEmitter.
- Object.setPrototypeOf(webContents.__proto__, EventEmitter.prototype)
-
+WebContents.prototype._init = function () {
// Every remote callback from renderer process would add a listenter to the
// render-view-deleted event, so ignore the listenters warning.
- webContents.setMaxListeners(0)
+ this.setMaxListeners(0)
// WebContents::send(channel, args..)
// WebContents::sendToAll(channel, args..)
if (channel == null) {
throw new Error('Missing required channel argument')
}
- return webContents._send(allFrames, channel, args)
+ return this._send(allFrames, channel, args)
}
- webContents.send = sendWrapper.bind(null, false)
- webContents.sendToAll = sendWrapper.bind(null, true)
+ this.send = sendWrapper.bind(null, false)
+ this.sendToAll = sendWrapper.bind(null, true)
// The navigation controller.
- const controller = new NavigationController(webContents)
+ const controller = new NavigationController(this)
for (const name in NavigationController.prototype) {
const method = NavigationController.prototype[name]
if (method instanceof Function) {
- webContents[name] = function () {
+ this[name] = function () {
return method.apply(controller, arguments)
}
}
// Mapping webFrame methods.
for (const method of webFrameMethods) {
- webContents[method] = function (...args) {
+ this[method] = function (...args) {
this.send('ELECTRON_INTERNAL_RENDERER_WEB_FRAME_METHOD', method, args)
}
}
for (const method of webFrameMethodsWithResult) {
- webContents[method] = function (...args) {
+ this[method] = function (...args) {
const callback = args[args.length - 1]
const actualArgs = args.slice(0, args.length - 2)
syncWebFrameMethods.call(this, getNextId(), method, callback, ...actualArgs)
// Make sure webContents.executeJavaScript would run the code only when the
// webContents has been loaded.
- webContents.executeJavaScript = function (code, hasUserGesture, callback) {
+ this.executeJavaScript = function (code, hasUserGesture, callback) {
const requestId = getNextId()
if (typeof hasUserGesture === 'function') {
callback = hasUserGesture
}
// Dispatch IPC messages to the ipc module.
- webContents.on('ipc-message', function (event, [channel, ...args]) {
+ this.on('ipc-message', function (event, [channel, ...args]) {
ipcMain.emit(channel, event, ...args)
})
- webContents.on('ipc-message-sync', function (event, [channel, ...args]) {
+ this.on('ipc-message-sync', function (event, [channel, ...args]) {
Object.defineProperty(event, 'returnValue', {
set: function (value) {
return event.sendReply(JSON.stringify(value))
})
// Handle context menu action request from pepper plugin.
- webContents.on('pepper-context-menu', function (event, params) {
+ this.on('pepper-context-menu', function (event, params) {
const menu = Menu.buildFromTemplate(params.menu)
menu.popup(params.x, params.y)
})
// The devtools requests the webContents to reload.
- webContents.on('devtools-reload-page', function () {
- webContents.reload()
+ this.on('devtools-reload-page', function () {
+ this.reload()
})
// Delays the page-title-updated event to next tick.
- webContents.on('-page-title-updated', function (...args) {
+ this.on('-page-title-updated', function (...args) {
setImmediate(() => {
this.emit.apply(this, ['page-title-updated'].concat(args))
})
})
- webContents.printToPDF = function (options, callback) {
+ this.printToPDF = function (options, callback) {
const printingSetting = Object.assign({}, defaultPrintingSetting)
if (options.landscape) {
printingSetting.landscape = options.landscape
this._printToPDF(printingSetting, callback)
}
- app.emit('web-contents-created', {}, webContents)
+ app.emit('web-contents-created', {}, this)
}
-binding._setWrapWebContents(wrapWebContents)
-
-// Add JavaScript wrappers for Debugger class.
-const wrapDebugger = function (webContentsDebugger) {
- // debugger is an EventEmitter.
- Object.setPrototypeOf(webContentsDebugger.__proto__, EventEmitter.prototype)
-}
+const {Debugger} = process.atomBinding('debugger')
-debuggerBinding._setWrapDebugger(wrapDebugger)
+Object.setPrototypeOf(Debugger.prototype, EventEmitter.prototype)
+// Public APIs.
module.exports = {
create (options = {}) {
return binding.create(options)
const Module = require('module')
const v8 = require('v8')
-// Save the prototype of EventEmitter, must be called before using native API.
-const {setEventEmitterPrototype} = process.binding('atom_browser_event_emitter')
-setEventEmitterPrototype(require('events').EventEmitter)
-
// 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)
projects / platform / framework / web / crosswalk-tizen.git / commitdiff