JavaScript Content Handler Version 0.0

mojo/apps/js/main.cc

-// Copyright 2013 The Chromium Authors. All rights reserved.
+// Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <stdio.h>
+
+#include "base/at_exit.h"
+#include "base/bind.h"
+#include "base/file_util.h"
+#include "base/i18n/icu_util.h"
 #include "base/message_loop/message_loop.h"
+#include "base/path_service.h"
+#include "gin/converter.h"
+#include "gin/modules/console.h"
+#include "gin/modules/module_registry.h"
+#include "gin/modules/module_runner_delegate.h"
 #include "gin/public/isolate_holder.h"
-#include "mojo/apps/js/mojo_runner_delegate.h"
-#include "mojo/public/cpp/system/core.h"
-#include "mojo/public/cpp/system/macros.h"
-
-#if defined(WIN32)
-#if !defined(CDECL)
-#define CDECL __cdecl
-#endif
-#define MOJO_APPS_JS_EXPORT __declspec(dllexport)
-#else
-#define CDECL
-#define MOJO_APPS_JS_EXPORT __attribute__((visibility("default")))
-#endif
+#include "gin/test/file_runner.h"
+#include "gin/try_catch.h"
+#include "mojo/apps/js/bindings/gl/module.h"
+#include "mojo/apps/js/bindings/threading.h"
+#include "mojo/bindings/js/core.h"
+#include "mojo/bindings/js/handle.h"
+#include "mojo/bindings/js/support.h"
+#include "mojo/common/data_pipe_utils.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/application_runner_chromium.h"
+#include "mojo/public/cpp/application/interface_factory_impl.h"
+#include "mojo/services/public/interfaces/content_handler/content_handler.mojom.h"
 
 namespace mojo {
 namespace apps {
+namespace {
 
-void Start(MojoHandle pipe, const std::string& module) {
-  base::MessageLoop loop;
+std::vector<base::FilePath> GetModuleSearchPaths() {
+  std::vector<base::FilePath> module_base(1);
+  CHECK(base::GetCurrentDirectory(&module_base[0]));
+  return module_base;
+}
 
-  gin::IsolateHolder instance(gin::IsolateHolder::kStrictMode);
-  MojoRunnerDelegate delegate;
-  gin::ShellRunner runner(&delegate, instance.isolate());
-  delegate.Start(&runner, pipe, module);
+void Run(
+    base::WeakPtr<gin::Runner> runner,
+    const std::string& code,
+    const std::string& path) {
+  if (!runner)
+    return;
+  gin::Runner::Scope scope(runner.get());
+  runner->Run(code.c_str(), path.c_str());
+}
 
-  base::MessageLoop::current()->Run();
+class MojoRunnerDelegate : public gin::ModuleRunnerDelegate {
+ public:
+  MojoRunnerDelegate() : gin::ModuleRunnerDelegate(GetModuleSearchPaths()) {
+    AddBuiltinModule(gin::Console::kModuleName, gin::Console::GetModule);
+  }
+
+  virtual void UnhandledException(gin::ShellRunner* runner,
+                                  gin::TryCatch& try_catch) OVERRIDE {
+    gin::ModuleRunnerDelegate::UnhandledException(runner, try_catch);
+    LOG(ERROR) << try_catch.GetStackTrace();
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MojoRunnerDelegate);
+};
+
+} // namespace
+
+
+class ContentHandlerApp;
+
+class ContentHandlerImpl : public InterfaceImpl<ContentHandler> {
+ public:
+  explicit ContentHandlerImpl(ContentHandlerApp* content_handler_app)
+      : content_handler_app_(content_handler_app) {
+  }
+  virtual ~ContentHandlerImpl() {}
+
+ private:
+  virtual void OnConnect(const mojo::String& url,
+                         URLResponsePtr content,
+                         ServiceProviderPtr service_provider) MOJO_OVERRIDE;
+
+  ContentHandlerApp* content_handler_app_;
+};
+
+// TODO(hansmuller); does this class define the right lifetime
+// for its gin members?
+class ContentHandlerApp : public ApplicationDelegate {

[Aaron Boodman, 2014/08/25 17:25:37]

Nit: the naming of this kind of confused me... I think it should be like JSApp
or something.

(actually: I think we should just rename the entire directory to 'bravo' or
something, so that we have a distinct name for this style of js-baesd mojo
application, but that can be separate).

[hansmuller, 2014/08/26 23:39:12]

I've renamed the class JSApp. It bugs me that the thing we're calling the
application is explicitly an ApplicationDelegate however I agree that JSApp is
better than ContentHandlerApp.

+ public:
+  ContentHandlerApp()
+      : isolate_holder_(gin::IsolateHolder::kStrictMode),
+        content_handler_factory_(this) {
+    base::i18n::InitializeICU();
+    shell_runner_.reset(
+        new gin::ShellRunner(&runner_delegate_, isolate_holder_.isolate()));
+  }
+
+  virtual bool ConfigureIncomingConnection(ApplicationConnection* connection)
+      MOJO_OVERRIDE {
+    connection->AddService(&content_handler_factory_);
+    return true;
+  }
+
+  void LoadMainJSModule(const std::string& module, const std::string& path) {
+    // TODO(hansmuller): is this the right place to put the stack
+    // frame capturer?
+    {
+      gin::Runner::Scope scope(shell_runner_.get());
+      v8::V8::SetCaptureStackTraceForUncaughtExceptions(true);
+    }
+
+    base::MessageLoop::current()->PostTask(FROM_HERE,

[darin (slow to review), 2014/08/26 05:23:22]

why do you need to use PostTask here?

[hansmuller, 2014/08/26 23:39:12]

It's not necessary to use PostTask. I've removed it.

+        base::Bind(apps::Run, shell_runner_->GetWeakPtr(), module, path));
+  }
+
+ private:
+  gin::IsolateHolder isolate_holder_;
+  scoped_ptr<gin::ShellRunner> shell_runner_;
+  apps::MojoRunnerDelegate runner_delegate_;
+  InterfaceFactoryImplWithContext<
+     ContentHandlerImpl, ContentHandlerApp> content_handler_factory_;
+};
+
+void ContentHandlerImpl::OnConnect(
+    const mojo::String& url,
+    URLResponsePtr content,
+    ServiceProviderPtr service_provider) {
+
+  std::string path(url.To<std::string>());
+  std::string module;
+  // TODO(hansmuller): is this the right place to block and load the

[Aaron Boodman, 2014/08/25 17:25:37]

I agree with your comment that it would be better to not do a blocking read.
Otherwise, launch of multiple JS apps could be serialized on the network.

However, I think that's fine to improve in a separate change --- if changing
module loading to be async would be more work.

[hansmuller, 2014/08/26 23:39:12]

OK, I'll add async loading of JS modules in a subsequent CL.

+  // initial JS module?
+  // TODO(hansmuller): check the return value and fail gracefully.
+  common::BlockingCopyToString(content->body.Pass(), &module);
+
+  content_handler_app_->LoadMainJSModule(module, path);

[Aaron Boodman, 2014/08/25 17:25:37]

Remember that OnConnect() can get called multiple times, each with a different
js app that should be run. You should be constructing a new object to
encapsulate each connection. See, e.g., PNGView in my CL.

[hansmuller, 2014/08/26 23:39:12]

It looks like I should to wait for your CL
(https://codereview.chromium.org/489493004) to land to do this?

[Aaron Boodman, 2014/08/27 05:55:53]

I think that you could structure the code to have an object that owns each
connection now. The only things my CL adds are:
- changes the signature to OnConnect so that it works properly for large
responses
- hooks up viewmanager and window manager so that we can actually navigate to
these things

 }
 
 }  // namespace apps
 }  // namespace mojo
 
-extern "C" MOJO_APPS_JS_EXPORT MojoResult CDECL MojoMain(MojoHandle pipe) {
-  mojo::apps::Start(pipe, "mojo/apps/js/main");
-  return MOJO_RESULT_OK;
+MojoResult MojoMain(MojoHandle shell_handle) {
+  mojo::ApplicationRunnerChromium runner(new mojo::apps::ContentHandlerApp());
+  return runner.Run(shell_handle);
 }
+