return scope.Close(v8_event);
}
+// static
+std::string Event::GetReturnValue(v8::Handle<v8::Object> event) {
+ v8::HandleScope scope;
+ v8::Local<v8::Value> json = event->Get(v8::String::New("returnValue"));
+ return *v8::String::Utf8Value(json);
+}
+
v8::Handle<v8::Value> Event::New(const v8::Arguments &args) {
Event* event = new Event;
event->Wrap(args.This());
#ifndef ATOM_BROWSER_ATOM_API_EVENT_H_
#define ATOM_BROWSER_ATOM_API_EVENT_H_
+#include <string>
+
#include "base/basictypes.h"
#include "vendor/node/src/node_object_wrap.h"
// Create a V8 Event object.
static v8::Handle<v8::Object> CreateV8Object();
+ // Get JSON string of the event.returnValue from a Event object.
+ static std::string GetReturnValue(v8::Handle<v8::Object> event);
+
// Accessor to return handle_, this follows Google C++ Style.
v8::Persistent<v8::Object>& handle() { return handle_; }
#include "base/logging.h"
#include "base/values.h"
+#include "browser/api/atom_api_event.h"
#include "common/v8_value_converter_impl.h"
#include "content/public/browser/browser_thread.h"
#include "vendor/node/src/node.h"
int routing_id,
const std::string& channel,
const base::ListValue& args,
- base::DictionaryValue* result) {
+ std::string* result) {
v8::HandleScope scope;
v8::Handle<v8::Context> context = v8::Context::GetCurrent();
}
node::MakeCallback(node::process, "emit", arguments.size(), &arguments[0]);
-
- scoped_ptr<base::Value> base_event(converter->FromV8Value(event, context));
- DCHECK(base_event && base_event->IsType(base::Value::TYPE_DICTIONARY));
-
- result->Swap(static_cast<base::DictionaryValue*>(base_event.get()));
+ *result = api::Event::GetReturnValue(event);
}
} // namespace atom
#include "common/api/atom_bindings.h"
namespace base {
-class DictionaryValue;
class ListValue;
}
int routing_id,
const std::string& channel,
const base::ListValue& args,
- base::DictionaryValue* result);
+ std::string* result);
// The require('atom').browserMainParts object.
v8::Handle<v8::Object> browser_main_parts() {
constructor: ->
process.on 'ATOM_INTERNAL_MESSAGE', (args...) =>
@emit(args...)
- process.on 'ATOM_INTERNAL_MESSAGE_SYNC', (args...) =>
- @emit(args...)
+ process.on 'ATOM_INTERNAL_MESSAGE_SYNC', (channel, event, args...) =>
+ returnValue = 'null'
+ get = -> returnValue
+ set = (value) -> returnValue = JSON.stringify(value)
+
+ Object.defineProperty event, 'returnValue', {get, set}
+ Object.defineProperty event, 'result', {get, set}
+
+ @emit(channel, event, args...)
send: (processId, routingId, args...) ->
@sendChannel(processId, routingId, 'message', args...)
bool handled = true;
IPC_BEGIN_MESSAGE_MAP(NativeWindow, message)
IPC_MESSAGE_HANDLER(AtomViewHostMsg_Message, OnRendererMessage)
- IPC_MESSAGE_HANDLER(AtomViewHostMsg_Message_Sync, OnRendererMessageSync)
+ IPC_MESSAGE_HANDLER_DELAY_REPLY(AtomViewHostMsg_Message_Sync,
+ OnRendererMessageSync)
IPC_MESSAGE_HANDLER(AtomViewHostMsg_UpdateDraggableRegions,
UpdateDraggableRegions)
IPC_MESSAGE_UNHANDLED(handled = false)
void NativeWindow::OnRendererMessageSync(const std::string& channel,
const base::ListValue& args,
- base::DictionaryValue* result) {
+ IPC::Message* reply_msg) {
+ std::string json;
AtomBrowserMainParts::Get()->atom_bindings()->OnRendererMessageSync(
GetWebContents()->GetRenderProcessHost()->GetID(),
GetWebContents()->GetRoutingID(),
channel,
args,
- result);
+ &json);
+
+ AtomViewHostMsg_Message_Sync::WriteReplyParams(reply_msg, json);
+ Send(reply_msg);
}
} // namespace atom
class Size;
}
+namespace IPC {
+class Message;
+}
+
namespace atom {
class AtomJavaScriptDialogManager;
void OnRendererMessageSync(const std::string& channel,
const base::ListValue& args,
- base::DictionaryValue* result);
+ IPC::Message* reply_msg);
// Notification manager.
content::NotificationRegistrar registrar_;
IPC_SYNC_MESSAGE_ROUTED2_1(AtomViewHostMsg_Message_Sync,
std::string /* channel */,
ListValue /* arguments */,
- DictionaryValue /* result */)
+ std::string /* result (in JSON) */)
IPC_MESSAGE_ROUTED2(AtomViewMsg_Message,
std::string /* channel */,
RenderView* render_view = GetCurrentRenderView();
- base::DictionaryValue result;
+ std::string json;
IPC::SyncMessage* message = new AtomViewHostMsg_Message_Sync(
render_view->GetRoutingID(),
channel,
*static_cast<base::ListValue*>(arguments.get()),
- &result);
+ &json);
// Enable the UI thread in browser to receive messages.
message->EnableMessagePumping();
bool success = render_view->Send(message);
if (!success)
return node::ThrowError("Unable to send AtomViewHostMsg_Message_Sync");
- return scope.Close(converter->ToV8Value(&result, context));
+ return scope.Close(v8::String::New(json.data(), json.size()));
}
// static
sendSync: (args...) ->
msg = ipc.sendSync('ATOM_INTERNAL_MESSAGE_SYNC', 'sync-message', args...)
- msg.returnValue ? msg.result
+ JSON.parse(msg)
sendChannelSync: (args...) ->
msg = ipc.sendSync('ATOM_INTERNAL_MESSAGE_SYNC', args...)
- msg.returnValue ? msg.result
+ JSON.parse(msg)
module.exports = new Ipc