Simple shell that loads a dll and calls an entrypoint function passing in a handle to a pipe create…

mojo/shell/app_container.cc

+// Copyright (c) 2013 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 "base/bind.h"
+#include "base/callback_forward.h"
+#include "base/files/file_path.h"
+#include "base/threading/thread.h"
+#include "mojo/public/system/core.h"
+#include "mojo/shell/app_container.h"
+
+typedef MojoResult (*MojoMainFunction)(MojoHandle pipe);
+
+namespace mojo {
+namespace shell {
+
+void LaunchAppOnThread(const base::FilePath& app_path,
+                       MojoHandle app_handle,
+                       base::MessageLoop* main_thread_loop,
+                       const base::Callback<void()>& callback) {
+  HINSTANCE app_library = LoadLibrary(app_path.value().c_str());
+  if (!app_library) {
+    LOG(ERROR) << "Failed to load library: " << app_path.value().c_str();
+    goto completed;
+  }
+
+  MojoMainFunction main_function = reinterpret_cast<MojoMainFunction>(
+      GetProcAddress(app_library, "MojoMain"));
+  if (!main_function) {
+    LOG(ERROR) << "Entrypoint MojoMain not found.";
+    goto completed;

[darin (slow to review), 2013/10/04 21:47:14]

in these other error cases, we'll want to make sure the DLL doesn't leak. or
perhaps it is OK to leak it and just let the child process exit (once we have a
child process).

+  }
+
+  MojoResult result = main_function(app_handle);
+  if (result < MOJO_RESULT_OK) {
+    LOG(ERROR) << "MojoMain returned an error: " << result;
+    // Failure..
+    goto completed;
+  }
+

[darin (slow to review), 2013/10/04 21:47:14]

i guess there is a TODO here for error handling.

+completed:
+  main_thread_loop->PostTask(FROM_HERE, callback);
+}
+
+AppContainer::AppContainer()
+    : weak_factory_(this),
+      shell_handle_(NULL) {
+}
+
+AppContainer::~AppContainer() {
+}
+
+void AppContainer::LaunchApp(const base::FilePath& app_path) {
+  MojoHandle app_handle = MOJO_HANDLE_INVALID;
+  MojoResult result = MojoCreateMessagePipe(&shell_handle_, &app_handle);
+  if (result < MOJO_RESULT_OK) {
+    // Failure..
+  }
+
+  // Launch the app on its own thread.
+  // TODO(beng): Create a unique thread name.
+  thread_.reset(new base::Thread("app_thread"));
+  thread_->Start();
+  thread_->message_loop()->PostTask(
+      FROM_HERE,
+      base::Bind(&LaunchAppOnThread,
+                 app_path,
+                 app_handle,
+                 base::MessageLoop::current(),

[darin (slow to review), 2013/10/04 21:47:14]

there's an effort to move away from MessageLoop and use separate primitives for
identifying the current TaskRunner and the act of running and stopping the
message loop.  see base::ThreadTaskRunnerHandle and base::RunLoop.

[Ben Goodger (Google), 2013/10/07 23:48:44]

I can easily pass a threadtaskrunner to my function... but I don't see how to
avoid messageloop here completely since base::Thread provides a message loop,
not a runloop. What am I missing?

+                 base::Bind(&AppContainer::AppCompleted,
+                            weak_factory_.GetWeakPtr())));
+
+  const char* hello_msg = "Hello";
+  result = MojoWriteMessage(shell_handle_, hello_msg, strlen(hello_msg)+1,
+                            NULL, 0, MOJO_WRITE_MESSAGE_FLAG_NONE);
+  if (result < MOJO_RESULT_OK) {
+    // Failure..
+  }
+}
+
+
+void AppContainer::AppCompleted() {
+  thread_.reset();
+
+  // Probably want to do something more sophisticated here, like notify someone
+  // else to do this.
+  base::MessageLoop::current()->Quit();
+}
+
+}  // namespace shell
+}  // namespace mojo