Use require('ipc').send to communicate between browser and renderer.

renderer/api/atom_api_renderer_ipc.cc

@@ -0,0 +1,83 @@
+// 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.
+
+#include "renderer/api/atom_api_renderer_ipc.h"
+
+#include "base/values.h"
+#include "common/api/api_messages.h"
+#include "content/public/renderer/render_view.h"
+#include "content/public/renderer/v8_value_converter.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
+#include "vendor/node/src/node.h"
+
+using content::RenderView;
+using content::V8ValueConverter;
+using WebKit::WebFrame;
+using WebKit::WebView;
+
+namespace atom {
+
+namespace api {
+
+namespace {
+
+RenderView* GetCurrentRenderView() {
+  WebFrame* frame = WebFrame::frameForCurrentContext();
+  DCHECK(frame);
+  if (!frame)
+    return NULL;
+
+  WebView* view = frame->view();
+  if (!view)
+    return NULL;  // can happen during closing.
+
+  RenderView* render_view = RenderView::FromWebView(view);
+  DCHECK(render_view);
+  return render_view;
+}
+
+}  // namespace
+
+// static
+v8::Handle<v8::Value> RendererIPC::Send(const v8::Arguments &args) {
+  v8::HandleScope scope;
+
+  if (!args[0]->IsString())
+    return node::ThrowTypeError("Bad argument");
+
+  std::string channel(*v8::String::Utf8Value(args[0]));
+
+  RenderView* render_view = GetCurrentRenderView();
+
+  // Convert Arguments to Array, so we can use V8ValueConverter to convert it
+  // to ListValue.
+  v8::Local<v8::Array> v8_args = v8::Array::New(args.Length() - 1);
+  for (int i = 0; i < args.Length() - 1; ++i)
+    v8_args->Set(i, args[i + 1]);
+
+  scoped_ptr<V8ValueConverter> converter(V8ValueConverter::create());
+  scoped_ptr<base::Value> arguments(
+      converter->FromV8Value(v8_args, v8::Context::GetCurrent()));
+
+  DCHECK(arguments && arguments->IsType(base::Value::TYPE_LIST));
+
+  render_view->Send(new AtomViewHostMsg_Message(
+      render_view->GetRoutingID(),
+      channel,
+      *static_cast<base::ListValue*>(arguments.get())));
+
+  return v8::Undefined();
+}
+
+// static
+void RendererIPC::Initialize(v8::Handle<v8::Object> target) {
+  node::SetMethod(target, "send", Send);
+}
+
+}  // namespace api
+
+}  // namespace atom
+
+NODE_MODULE(atom_renderer_ipc, atom::api::RendererIPC::Initialize)

renderer/api/atom_api_renderer_ipc.h

@@ -0,0 +1,29 @@
+// 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_RENDERER_API_ATOM_API_RENDERER_IPC_H_
+#define ATOM_RENDERER_API_ATOM_API_RENDERER_IPC_H_
+
+#include "base/basictypes.h"
+#include "v8/include/v8.h"
+
+namespace atom {
+
+namespace api {
+
+class RendererIPC {
+ public:
+  static void Initialize(v8::Handle<v8::Object> target);
+
+ private:
+  static v8::Handle<v8::Value> Send(const v8::Arguments &args);
+
+  DISALLOW_IMPLICIT_CONSTRUCTORS(RendererIPC);
+};
+
+}  // namespace api
+
+}  // namespace atom
+
+#endif  // ATOM_RENDERER_API_ATOM_API_RENDERER_IPC_H_

renderer/api/atom_renderer_bindings.cc

@@ -4,9 +4,10 @@
 
 #include "renderer/api/atom_renderer_bindings.h"
 
+#include <vector>
+
 #include "base/logging.h"
 #include "base/values.h"
-#include "common/api/api_messages.h"
 #include "content/public/renderer/render_view.h"
 #include "content/public/renderer/v8_value_converter.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
@@ -16,7 +17,6 @@
 using content::RenderView;
 using content::V8ValueConverter;
 using WebKit::WebFrame;
-using WebKit::WebView;
 
 namespace atom {
 
@@ -30,21 +30,6 @@ v8::Handle<v8::Object> GetProcessObject(v8::Handle<v8::Context> context) {
   return process;
 }
 
-RenderView* GetCurrentRenderView() {
-  WebFrame* frame = WebFrame::frameForCurrentContext();
-  DCHECK(frame);
-  if (!frame)
-    return NULL;
-
-  WebView* view = frame->view();
-  if (!view)
-    return NULL;  // can happen during closing.
-
-  RenderView* render_view = RenderView::FromWebView(view);
-  DCHECK(render_view);
-  return render_view;
-}
-
 }  // namespace
 
 AtomRendererBindings::AtomRendererBindings(RenderView* render_view)
@@ -66,43 +51,34 @@ void AtomRendererBindings::BindToFrame(WebFrame* frame) {
   AtomBindings::BindTo(GetProcessObject(context));
 }
 
-void AtomRendererBindings::AddIPCBindings(WebFrame* frame) {
-  v8::HandleScope handle_scope;
+void AtomRendererBindings::OnRendererMessage(const std::string& channel,
+                                             const base::ListValue& args) {
+  if (!render_view_->GetWebView())
+    return;
 
-  v8::Handle<v8::Context> context = frame->mainWorldScriptContext();
+  v8::HandleScope scope;
+
+  v8::Local<v8::Context> context =
+      render_view_->GetWebView()->mainFrame()->mainWorldScriptContext();
   if (context.IsEmpty())
     return;
 
-  v8::Context::Scope scope(context);
+  v8::Context::Scope context_scope(context);
 
   v8::Handle<v8::Object> process = GetProcessObject(context);
-
-  node::SetMethod(process, "send", Send);
-}
-
-// static
-v8::Handle<v8::Value> AtomRendererBindings::Send(const v8::Arguments &args) {
-  v8::HandleScope scope;
-
-  RenderView* render_view = GetCurrentRenderView();
-
-  // Convert Arguments to Array, so we can use V8ValueConverter to convert it
-  // to ListValue.
-  v8::Local<v8::Array> v8_args = v8::Array::New(args.Length());
-  for (int i = 0; i < args.Length(); ++i)
-    v8_args->Set(i, args[i]);
-
   scoped_ptr<V8ValueConverter> converter(V8ValueConverter::create());
-  scoped_ptr<base::Value> arguments(
-      converter->FromV8Value(v8_args, v8::Context::GetCurrent()));
 
-  DCHECK(arguments && arguments->IsType(base::Value::TYPE_LIST));
+  std::vector<v8::Handle<v8::Value>> arguments;
+  arguments.reserve(1 + args.GetSize());
+  arguments.push_back(v8::String::New(channel.c_str(), channel.size()));
 
-  render_view->Send(new AtomViewHostMsg_Message(
-      render_view->GetRoutingID(),
-      *static_cast<base::ListValue*>(arguments.get())));
+  for (size_t i = 0; i < args.GetSize(); i++) {
+    const base::Value* value;
+    if (args.Get(i, &value))
+      arguments.push_back(converter->ToV8Value(value, context));
+  }
 
-  return v8::Undefined();
+  node::MakeCallback(process, "emit", arguments.size(), &arguments[0]);
 }
 
 }  // namespace atom

renderer/api/atom_renderer_bindings.h

@@ -2,11 +2,17 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef ATOM_RENDERER_API_ATOM_RENDERER_BINDINGS_
-#define ATOM_RENDERER_API_ATOM_RENDERER_BINDINGS_
+#ifndef ATOM_RENDERER_API_ATOM_RENDERER_BINDINGS_H_
+#define ATOM_RENDERER_API_ATOM_RENDERER_BINDINGS_H_
+
+#include <iosfwd>
 
 #include "common/api/atom_bindings.h"
 
+namespace base {
+class ListValue;
+}
+
 namespace content {
 class RenderView;
 }
@@ -25,12 +31,11 @@ class AtomRendererBindings : public AtomBindings {
   // Call BindTo for process object of the frame.
   void BindToFrame(WebKit::WebFrame* frame);
 
-  // Add process.send and make process.on accept IPC message.
-  void AddIPCBindings(WebKit::WebFrame* frame);
+  // Dispatch messages from browser.
+  void OnRendererMessage(const std::string& channel,
+                         const base::ListValue& args);
 
  private:
-  static v8::Handle<v8::Value> Send(const v8::Arguments &args);
-
   content::RenderView* render_view_;
 
   DISALLOW_COPY_AND_ASSIGN(AtomRendererBindings);
@@ -38,4 +43,4 @@ class AtomRendererBindings : public AtomBindings {
 
 }  // namespace atom
 
-#endif  // ATOM_RENDERER_API_ATOM_BINDINGS_
+#endif  // ATOM_RENDERER_API_ATOM_BINDINGS_H_

renderer/api/lib/ipc.coffee

@@ -0,0 +1,12 @@
+EventEmitter = require('events').EventEmitter
+send = process.atom_binding('ipc').send
+
+class Ipc extends EventEmitter
+  constructor: ->
+    process.on 'ATOM_INTERNAL_MESSAGE', (args...) =>
+      @emit('message', args...)
+
+  send: (args...) ->
+    send('ATOM_INTERNAL_MESSAGE', args...)
+
+module.exports = new Ipc

renderer/api/lib/remote_object.coffee

@@ -1,3 +0,0 @@
-RemoteObject = process.atom_binding('remote_object').RemoteObject
-
-module.exports = RemoteObject