Messages from the browser process call atom.messageReceivedFromBrowserProcess

This is how we will handle replies from dialogs presented in the browser process.

native/atom_cef_render_process_handler.h

@@ -14,7 +14,10 @@ class AtomCefRenderProcessHandler : public CefRenderProcessHandler {
                                        CefProcessId source_process,
                                        CefRefPtr<CefProcessMessage> message) OVERRIDE;
 
+  
+  
   void Reload(CefRefPtr<CefBrowser> browser);
+  bool CallMessageReceivedHandler(CefRefPtr<CefV8Context> context, CefRefPtr<CefProcessMessage> message);
 
   IMPLEMENT_REFCOUNTING(AtomCefRenderProcessHandler);
 };

native/atom_cef_render_process_handler.mm

@@ -2,6 +2,7 @@
 #import "native/v8_extensions/atom.h"
 #import "native/v8_extensions/native.h"
 #import "native/v8_extensions/onig_reg_exp.h"
+#import "native/message_translation.h"
 #include <iostream>
 
 void AtomCefRenderProcessHandler::OnWebKitInitialized() {
@@ -25,13 +26,17 @@ void AtomCefRenderProcessHandler::OnContextCreated(CefRefPtr<CefBrowser> browser
 }
 
 bool AtomCefRenderProcessHandler::OnProcessMessageReceived(CefRefPtr<CefBrowser> browser,
-                                          CefProcessId source_process,
-                                          CefRefPtr<CefProcessMessage> message) {
-  if (message->GetName().ToString() == "reload") {
+                                                           CefProcessId source_process,
+                                                           CefRefPtr<CefProcessMessage> message) {
+  std::string name = message->GetName().ToString();
+  
+  if (name == "reload") {
     Reload(browser);
+    return true;
+  }
+  else {
+    return CallMessageReceivedHandler(browser->GetMainFrame()->GetV8Context(), message);
   }
-
-  return true;
 }
 
 void AtomCefRenderProcessHandler::Reload(CefRefPtr<CefBrowser> browser) {
@@ -48,3 +53,31 @@ void AtomCefRenderProcessHandler::Reload(CefRefPtr<CefBrowser> browser) {
   }
   context->Exit();
 }
+
+bool AtomCefRenderProcessHandler::CallMessageReceivedHandler(CefRefPtr<CefV8Context> context, CefRefPtr<CefProcessMessage> message) {
+  context->Enter();
+  
+  CefRefPtr<CefV8Value> atom = context->GetGlobal()->GetValue("atom");
+  CefRefPtr<CefV8Value> receiveFn = atom->GetValue("receiveMessageFromBrowserProcess");
+
+  CefV8ValueList arguments;
+  arguments.push_back(CefV8Value::CreateString(message->GetName().ToString()));
+  
+  CefRefPtr<CefListValue> messageArguments = message->GetArgumentList();
+  if (messageArguments->GetSize() > 0) {
+    CefRefPtr<CefV8Value> data = CefV8Value::CreateArray(messageArguments->GetSize());
+    TranslateList(messageArguments, data);
+    arguments.push_back(data);
+  }
+  
+  receiveFn->ExecuteFunction(atom, arguments);
+  context->Exit();
+  
+  if (receiveFn->HasException()) {
+    std::cout << "ERROR: Exception in JS receiving message " << message->GetName().ToString() << "\n";
+    return false;
+  }
+  else {
+    return true;    
+  }
+}

native/message_translation.cpp

@@ -0,0 +1,82 @@
+#include "message_translation.h"
+#include "util.h"
+
+// Transfer a V8 value to a List index.
+void TranslateListValue(CefRefPtr<CefListValue> list, int index, CefRefPtr<CefV8Value> value) {
+  if (value->IsArray()) {
+    CefRefPtr<CefListValue> new_list = CefListValue::Create();
+    TranslateList(value, new_list);
+    list->SetList(index, new_list);
+  } else if (value->IsString()) {
+    list->SetString(index, value->GetStringValue());
+  } else if (value->IsBool()) {
+    list->SetBool(index, value->GetBoolValue());
+  } else if (value->IsInt()) {
+    list->SetInt(index, value->GetIntValue());
+  } else if (value->IsDouble()) {
+    list->SetDouble(index, value->GetDoubleValue());
+  }
+}
+
+// Transfer a V8 array to a List.
+void TranslateList(CefRefPtr<CefV8Value> source, CefRefPtr<CefListValue> target) {
+  ASSERT(source->IsArray());
+
+  int arg_length = source->GetArrayLength();
+  if (arg_length == 0)
+    return;
+
+  // Start with null types in all spaces.
+  target->SetSize(arg_length);
+
+  for (int i = 0; i < arg_length; ++i) {
+    TranslateListValue(target, i, source->GetValue(i));
+  }
+}
+
+// Transfer a List value to a V8 array index.
+void TranslateListValue(CefRefPtr<CefV8Value> list, int index, CefRefPtr<CefListValue> value) {
+  CefRefPtr<CefV8Value> new_value;
+
+  CefValueType type = value->GetType(index);
+  switch (type) {
+    case VTYPE_LIST: {
+      CefRefPtr<CefListValue> list = value->GetList(index);
+      new_value = CefV8Value::CreateArray(list->GetSize());
+      TranslateList(list, new_value);
+    } break;
+    case VTYPE_BOOL:
+      new_value = CefV8Value::CreateBool(value->GetBool(index));
+      break;
+    case VTYPE_DOUBLE:
+      new_value = CefV8Value::CreateDouble(value->GetDouble(index));
+      break;
+    case VTYPE_INT:
+      new_value = CefV8Value::CreateInt(value->GetInt(index));
+      break;
+    case VTYPE_STRING:
+      new_value = CefV8Value::CreateString(value->GetString(index));
+      break;
+    default:
+      break;
+  }
+
+  if (new_value.get()) {
+    list->SetValue(index, new_value);
+  } else {
+    list->SetValue(index, CefV8Value::CreateNull());
+  }
+}
+
+// Transfer a List to a V8 array.
+void TranslateList(CefRefPtr<CefListValue> source, CefRefPtr<CefV8Value> target) {
+  ASSERT(target->IsArray());
+
+  int arg_length = source->GetSize();
+  if (arg_length == 0)
+    return;
+
+  for (int i = 0; i < arg_length; ++i) {
+    TranslateListValue(target, i, source);
+  }
+}

native/message_translation.h

@@ -0,0 +1,5 @@
+#include "include/cef_v8.h"
+
+// IPC data translation functions: translate a V8 array to a List, and vice versa
+void TranslateList(CefRefPtr<CefV8Value> source, CefRefPtr<CefListValue> target);
+void TranslateList(CefRefPtr<CefListValue> source, CefRefPtr<CefV8Value> target);

native/v8_extensions/atom.mm

@@ -4,20 +4,16 @@
 #import "atom.h"
 #import "atom_application.h"
 #import "util.h"
-
+#import "message_translation.h"
 
 namespace v8_extensions {
-  // IPC data translation functions: translate a V8 array to a List, and vice versa
-  void TranslateList(CefRefPtr<CefV8Value> source, CefRefPtr<CefListValue> target);
-  void TranslateList(CefRefPtr<CefListValue> source, CefRefPtr<CefV8Value> target);
-
-  v8_extensions::Atom::Atom() : CefV8Handler() {
+  Atom::Atom() : CefV8Handler() {
     NSString *filePath = [[[NSBundle mainBundle] resourcePath] stringByAppendingPathComponent:@"v8_extensions/atom.js"];
     NSString *extensionCode = [NSString stringWithContentsOfFile:filePath encoding:NSUTF8StringEncoding error:nil];
     CefRegisterExtension("v8/atom", [extensionCode UTF8String], this);
   }
 
-  bool v8_extensions::Atom::Execute(const CefString& name,
+  bool Atom::Execute(const CefString& name,
                               CefRefPtr<CefV8Value> object,
                               const CefV8ValueList& arguments,
                               CefRefPtr<CefV8Value>& retval,
@@ -42,84 +38,4 @@ namespace v8_extensions {
     }
     return false;
   };
-
-  // Transfer a V8 value to a List index.
-  void TranslateListValue(CefRefPtr<CefListValue> list, int index, CefRefPtr<CefV8Value> value) {
-    if (value->IsArray()) {
-      CefRefPtr<CefListValue> new_list = CefListValue::Create();
-      TranslateList(value, new_list);
-      list->SetList(index, new_list);
-    } else if (value->IsString()) {
-      list->SetString(index, value->GetStringValue());
-    } else if (value->IsBool()) {
-      list->SetBool(index, value->GetBoolValue());
-    } else if (value->IsInt()) {
-      list->SetInt(index, value->GetIntValue());
-    } else if (value->IsDouble()) {
-      list->SetDouble(index, value->GetDoubleValue());
-    }
-  }
-
-  // Transfer a V8 array to a List.
-  void TranslateList(CefRefPtr<CefV8Value> source, CefRefPtr<CefListValue> target) {
-    ASSERT(source->IsArray());
-
-    int arg_length = source->GetArrayLength();
-    if (arg_length == 0)
-      return;
-
-    // Start with null types in all spaces.
-    target->SetSize(arg_length);
-
-    for (int i = 0; i < arg_length; ++i) {
-      TranslateListValue(target, i, source->GetValue(i));
-    }
-  }
-
-  // Transfer a List value to a V8 array index.
-  void TranslateListValue(CefRefPtr<CefV8Value> list, int index, CefRefPtr<CefListValue> value) {
-    CefRefPtr<CefV8Value> new_value;
-
-    CefValueType type = value->GetType(index);
-    switch (type) {
-      case VTYPE_LIST: {
-        CefRefPtr<CefListValue> list = value->GetList(index);
-        new_value = CefV8Value::CreateArray(list->GetSize());
-        TranslateList(list, new_value);
-      } break;
-      case VTYPE_BOOL:
-        new_value = CefV8Value::CreateBool(value->GetBool(index));
-        break;
-      case VTYPE_DOUBLE:
-        new_value = CefV8Value::CreateDouble(value->GetDouble(index));
-        break;
-      case VTYPE_INT:
-        new_value = CefV8Value::CreateInt(value->GetInt(index));
-        break;
-      case VTYPE_STRING:
-        new_value = CefV8Value::CreateString(value->GetString(index));
-        break;
-      default:
-        break;
-    }
-
-    if (new_value.get()) {
-      list->SetValue(index, new_value);
-    } else {
-      list->SetValue(index, CefV8Value::CreateNull());
-    }
-  }
-
-  // Transfer a List to a V8 array.
-  void TranslateList(CefRefPtr<CefListValue> source, CefRefPtr<CefV8Value> target) {
-    ASSERT(target->IsArray());
-
-    int arg_length = source->GetSize();
-    if (arg_length == 0)
-      return;
-
-    for (int i = 0; i < arg_length; ++i) {
-      TranslateListValue(target, i, source);
-    }
-  }
 }