Defines a JavaScript application that's a client of the shell provided by the JS content handler. Includes a simple hello world example.

BUG=
[email protected]

Review URL: https://codereview.chromium.org/757703002

Author: Hans Muller

examples/js/README.md

@@ -0,0 +1,5 @@
+JavaScript Mojo Example Applications
+=====================
+
+hello.js, world.js - A minimal application that connects to another.
+

examples/js/hello.js

@@ -0,0 +1,34 @@
+#!mojo:js_content_handler
+// Demonstrate one JS Mojo application connecting to another to emit "hello
+// world". To run this application with mojo_shell, set DIR to be the absolute
+// path for this directory, then:
+//   mojo_shell "file://$DIR/hello.js file://$DIR/world.js"
+// Launches the Mojo hello.js application which connects to the application
+// URL specified as a Mojo application argument, world.js in this case.
+
+define("main", [
+  "console",
+  "mojo/public/interfaces/application/service_provider.mojom",
+], function(console, sp) {
+
+  function Application(shell, url) {
+    this.shell = shell;
+    console.log(url + ": Hello");
+  }
+
+  Application.prototype.initialize = function(args) {
+    if (args.length != 2) {
+      console.log("Expected hello.js URL argument");
+      return;
+    }
+    var serviceProvider = new sp.ServiceProvider.proxyClass();
+    // TODO(hansmuller): the following step shouldn't be necessary.
+    var handle = serviceProvider.getConnection$().messagePipeHandle;
+    this.shell.connectToApplication(args[1], handle);
+  }
+
+  Application.prototype.acceptConnection = function(url, serviceProvider) {
+  }
+
+  return Application;
+});

examples/js/main.js

@@ -0,0 +1,15 @@
+#!mojo:js_content_handler
+// See hello.js.
+define("main", ["console"], function(console) {
+  function Application(shell, url) {
+    console.log(url + ": World");
+  }
+
+  Application.prototype.initialize = function(args) {
+  }
+
+  Application.prototype.acceptConnection = function(url, serviceProvider) {
+  }
+
+  return Application;
+});

examples/js/world.js

@@ -168,6 +168,12 @@ void ModuleRegistry::LoadModule(Isolate* isolate,
     return;
   }
   waiting_callbacks_.insert(std::make_pair(id, callback));
+
+  for (size_t i = 0; i < pending_modules_.size(); ++i) {
+    if (pending_modules_[i]->id == id)
+      return;
+  }
+
   unsatisfied_dependencies_.insert(id);
 }
 

gin/modules/module_registry.cc

@@ -15,6 +15,10 @@ mojo_native_application("js_content_handler") {
     "content_handler_main.cc",
     "js_app.cc",
     "js_app.h",
+    "js_app_runner_delegate.cc",
+    "js_app_runner_delegate.h",
+    "js_app_shell.cc",
+    "js_app_shell.h",
     "mojo_bridge_module.cc",
     "mojo_bridge_module.h",
   ]

services/js/BUILD.gn

@@ -8,8 +8,8 @@
 #include "mojo/application/application_runner_chromium.h"
 #include "mojo/application/content_handler_factory.h"
 #include "mojo/public/c/system/main.h"
+#include "mojo/public/cpp/application/application_delegate.h"
 #include "mojo/public/cpp/application/application_impl.h"
-#include "mojo/public/cpp/application/interface_factory_impl.h"
 #include "services/js/js_app.h"
 
 namespace mojo {

services/js/content_handler_main.cc

@@ -5,60 +5,112 @@
 #include "services/js/js_app.h"
 
 #include "base/bind.h"
-#include "gin/array_buffer.h"
+#include "base/message_loop/message_loop.h"
 #include "gin/converter.h"
+#include "gin/modules/module_registry.h"
+#include "gin/try_catch.h"
 #include "mojo/common/data_pipe_utils.h"
+#include "mojo/edk/js/core.h"
+#include "mojo/edk/js/handle.h"
+#include "mojo/edk/js/support.h"
+#include "mojo/public/cpp/bindings/interface_request.h"
+#include "services/js/js_app_shell.h"
 #include "services/js/mojo_bridge_module.h"
 
 namespace mojo {
 namespace js {
 
+const char JSApp::kMainModuleName[] = "main";
+
 JSApp::JSApp(ShellPtr shell, URLResponsePtr response) : shell_(shell.Pass()) {
-  // TODO(hansmuller): handle load failure here and below.
+  isolate_holder_.AddRunMicrotasksObserver();
+
   DCHECK(!response.is_null());
-  file_name_ = response->url;
-  bool result = common::BlockingCopyToString(response->body.Pass(), &source_);
-  DCHECK(result);
+  std::string url(response->url);
+  std::string source;
+  CHECK(common::BlockingCopyToString(response->body.Pass(), &source));
 
-  runner_delegate.AddBuiltinModule(MojoInternals::kModuleName,
-                                   base::Bind(MojoInternals::GetModule, this));
-  shell_.set_client(this);
+  v8::Isolate* isolate = isolate_holder_.isolate();
+  shell_runner_.reset(new gin::ShellRunner(&runner_delegate_, isolate));
+  gin::Runner::Scope scope(shell_runner_.get());
+  shell_runner_->Run(source.c_str(), kMainModuleName);
+
+  gin::ModuleRegistry* registry =
+      gin::ModuleRegistry::From(shell_runner_->GetContextHolder()->context());
+  registry->LoadModule(
+      isolate,
+      kMainModuleName,
+      base::Bind(&JSApp::OnAppLoaded, base::Unretained(this), url));
 }
 
 JSApp::~JSApp() {
+  app_instance_.Reset();
 }
 
-void JSApp::Quit() {
-  isolate_holder_.RemoveRunMicrotasksObserver();
-  base::MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(&JSApp::QuitInternal, base::Unretained(this)));
+
+void JSApp::OnAppLoaded(std::string url, v8::Handle<v8::Value> main_module) {
+  gin::Runner::Scope scope(shell_runner_.get());
+  gin::TryCatch try_catch;
+  v8::Isolate* isolate = isolate_holder_.isolate();
+
+  v8::Handle<v8::Value> argv[] = {
+    gin::ConvertToV8(isolate, JSAppShell::Create(isolate, this)),
+    gin::ConvertToV8(isolate, url)
+  };
+
+  v8::Handle<v8::Function> app_class;
+  CHECK(gin::ConvertFromV8(isolate, main_module, &app_class));
+  app_instance_.Reset(isolate, app_class->NewInstance(arraysize(argv), argv));
+  if (try_catch.HasCaught())
+    runner_delegate_.UnhandledException(shell_runner_.get(), try_catch);
+
+  shell_.set_client(this);
 }
 
-MessagePipeHandle JSApp::ConnectToApplication(
-    const std::string& application_url) {
-  MessagePipe pipe;
-  InterfaceRequest<ServiceProvider> request =
-      MakeRequest<ServiceProvider>(pipe.handle1.Pass());
-  shell_->ConnectToApplication(application_url, request.Pass());
-  return pipe.handle0.Pass().release();
+void JSApp::ConnectToApplication(const std::string& application_url,
+                                 ScopedMessagePipeHandle service_provider) {
+  shell_->ConnectToApplication(
+      application_url, MakeRequest<ServiceProvider>(service_provider.Pass()));
 }
 
-MessagePipeHandle JSApp::RequestorMessagePipeHandle() {
-  return requestor_handle_.get();
+void JSApp::CallAppInstanceMethod(
+    const std::string& name, int argc, v8::Handle<v8::Value> argv[]) {
+  v8::Isolate* isolate = isolate_holder_.isolate();
+  v8::Local<v8::Object> app =
+      v8::Local<v8::Object>::New(isolate, app_instance_);
+  v8::Handle<v8::Value> key = gin::StringToV8(isolate, name);
+  v8::Handle<v8::Value> value = app->Get(key);
+  if (!value->IsFunction())
+    return;
+  v8::Handle<v8::Function> app_method;
+  CHECK(gin::ConvertFromV8(isolate, value, &app_method));
+  shell_runner_->Call(app_method, app, argc, argv);
+}
+
+void JSApp::Initialize(Array<String> app_args) {
+  gin::Runner::Scope scope(shell_runner_.get());
+  v8::Isolate* isolate = isolate_holder_.isolate();
+  v8::Handle<v8::Value> argv[] = {
+    gin::ConvertToV8(isolate, app_args.To<std::vector<std::string>>()),
+  };
+  CallAppInstanceMethod("initialize", 1, argv);
 }
 
 void JSApp::AcceptConnection(const String& requestor_url,
                              ServiceProviderPtr provider) {
-  requestor_handle_ = provider.PassMessagePipe();
-
-  isolate_holder_.AddRunMicrotasksObserver();
-  shell_runner_.reset(
-      new gin::ShellRunner(&runner_delegate, isolate_holder_.isolate()));
   gin::Runner::Scope scope(shell_runner_.get());
-  shell_runner_->Run(source_.c_str(), file_name_.c_str());
+  v8::Isolate* isolate = isolate_holder_.isolate();
+  v8::Handle<v8::Value> argv[] = {
+    gin::ConvertToV8(isolate, requestor_url.To<std::string>()),
+    gin::ConvertToV8(isolate, provider.PassMessagePipe().get()),
+  };
+  CallAppInstanceMethod("acceptConnection", arraysize(argv), argv);
 }
 
-void JSApp::Initialize(Array<String> args) {
+void JSApp::Quit() {
+  isolate_holder_.RemoveRunMicrotasksObserver();
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&JSApp::QuitInternal, base::Unretained(this)));
 }
 
 void JSApp::QuitInternal() {
@@ -68,3 +120,4 @@ void JSApp::QuitInternal() {
 
 }  // namespace js
 }  // namespace mojo
+

services/js/js_app.cc

@@ -2,65 +2,64 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef MOJO_SERVICES_JS_JS_APP_H_
-#define MOJO_SERVICES_JS_JS_APP_H_
+#ifndef SERVICES_JS_JS_APP_H_
+#define SERVICES_JS_JS_APP_H_
 
-#include "base/memory/ref_counted.h"
-#include "base/threading/thread.h"
 #include "gin/public/isolate_holder.h"
 #include "gin/shell_runner.h"
 #include "mojo/application/content_handler_factory.h"
-#include "mojo/edk/js/mojo_runner_delegate.h"
-#include "mojo/public/cpp/application/application_delegate.h"
+#include "mojo/public/cpp/system/message_pipe.h"
 #include "mojo/public/interfaces/application/application.mojom.h"
 #include "mojo/public/interfaces/application/shell.mojom.h"
-#include "mojo/services/public/interfaces/network/url_loader.mojom.h"
+#include "services/js/js_app_runner_delegate.h"
+#include "v8/include/v8.h"
 
 namespace mojo {
 namespace js {
 
 class JSApp;
 class ApplicationDelegateImpl;
 
-// Each JavaScript app started by content handler runs on its own thread and
-// in its own V8 isolate. This class represents one running JS app.
+// Each JavaScript app started by the content handler runs on its own thread
+// and in its own V8 isolate. This class represents one running JS app.
 
 class JSApp : public InterfaceImpl<Application>,
               public ContentHandlerFactory::HandledApplicationHolder {
  public:
   JSApp(ShellPtr shell, URLResponsePtr response);
   virtual ~JSApp();
 
-  // Called by the JS mojo module to quit this JS app. See mojo.js.
+  // This method just delegates to shell_->ConnectToApplication().
+  void ConnectToApplication(const std::string& application_url,
+                            ScopedMessagePipeHandle service_provider);
+
   void Quit();
 
-  // Called by the JS mojo module to connect to a Mojo application.
-  MessagePipeHandle ConnectToApplication(const std::string& application_url);
+ private:
+  static const char kMainModuleName[];
 
-  // Called by the JS mojo module to retrieve the ServiceProvider message
-  // pipe handle passed to the JS application's AcceptConnection() method.
-  MessagePipeHandle RequestorMessagePipeHandle();
+  void OnAppLoaded(std::string url, v8::Handle<v8::Value> module);
 
- private:
   // Application methods:
   void AcceptConnection(const String& requestor_url,
                         ServiceProviderPtr provider) override;
   void Initialize(Array<String> args) override;
 
+  void CallAppInstanceMethod(
+      const std::string& name, int argc, v8::Handle<v8::Value> argv[]);
+
   void QuitInternal();
 
   ShellPtr shell_;
-  js::MojoRunnerDelegate runner_delegate;
+  JSAppRunnerDelegate runner_delegate_;
   gin::IsolateHolder isolate_holder_;
   scoped_ptr<gin::ShellRunner> shell_runner_;
-  std::string source_;
-  std::string file_name_;
-  ScopedMessagePipeHandle requestor_handle_;
+  v8::Persistent<v8::Object> app_instance_;
 
   DISALLOW_COPY_AND_ASSIGN(JSApp);
 };
 
 }  // namespace js
 }  // namespace mojo
 
-#endif  // MOJO_SERVICES_JS_JS_APP_H_
+#endif  // SERVICES_JS_JS_APP_H_