Factor out loading & running of DSOs

mojo/shell/app_child_process.cc

 // 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 "mojo/shell/app_child_process.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/scoped_native_library.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_checker.h"
 #include "mojo/common/message_pump_mojo.h"
 #include "mojo/edk/embedder/embedder.h"
 #include "mojo/edk/embedder/simple_platform_support.h"
 #include "mojo/public/cpp/system/core.h"
 #include "mojo/shell/app_child_process.mojom.h"
+#include "mojo/shell/dynamic_service_runner.h"
 
 namespace mojo {
 namespace shell {
 
 namespace {
 
 // Blocker ---------------------------------------------------------------------
 
 // Blocks a thread until another thread unblocks it, at which point it unblocks
 // and runs a closure provided by that thread.
@@ skipping 183 matching lines @@
     DCHECK(thread_checker_.CalledOnValidThread());
     channel_info_ = channel_info;
   }
 
   static void StartAppOnMainThread(const base::FilePath& app_path,
                                    ScopedMessagePipeHandle service) {
     // TODO(vtl): This is copied from in_process_dynamic_service_runner.cc.
     DVLOG(2) << "Loading/running Mojo app from " << app_path.value()
              << " out of process";
 
-    do {
-      base::NativeLibraryLoadError load_error;
-      base::ScopedNativeLibrary app_library(
-          base::LoadNativeLibrary(app_path, &load_error));
-      if (!app_library.is_valid()) {
-        LOG(ERROR) << "Failed to load library (error: " << load_error.ToString()
-                   << ")";
-        break;
-      }
-
-      typedef MojoResult (*MojoMainFunction)(MojoHandle);
-      MojoMainFunction main_function = reinterpret_cast<MojoMainFunction>(
-          app_library.GetFunctionPointer("MojoMain"));
-      if (!main_function) {
-        LOG(ERROR) << "Entrypoint MojoMain not found";
-        break;
-      }
-
-      // TODO(vtl): Report the result back to our parent process.
-      // |MojoMain()| takes ownership of the service handle.
-      MojoResult result = main_function(service.release().value());
-      if (result < MOJO_RESULT_OK)
-        LOG(ERROR) << "MojoMain returned an error: " << result;
-    } while (false);
+    base::ScopedNativeLibrary app_library(

[DaveMoore, 2014/10/29 22:15:13]

This keeps the semantics of unloading the library. It's possible we shouldn't
bother here though as the process is going away.

[viettrungluu, 2014/10/29 23:11:43]

We probably shouldn't. (I don't know if TLS destructors are fired when a process
exits in a normal way. Probably they do.)

[DaveMoore, 2014/10/30 15:32:56]

Done.

+        DynamicServiceRunner::LoadAndRunService(app_path, service.Pass()));
   }
 
   base::ThreadChecker thread_checker_;
   AppContext* const app_context_;
   Blocker::Unblocker unblocker_;
 
   embedder::ChannelInfo* channel_info_;
 
   DISALLOW_COPY_AND_ASSIGN(AppChildControllerImpl);
 };
@@ skipping 20 matching lines @@
       base::Bind(&AppChildControllerImpl::Init, base::Unretained(&app_context),
                  base::Passed(platform_channel()), blocker.GetUnblocker()));
   // This will block, then run whatever the controller wants.
   blocker.Block();
 
   app_context.Shutdown();
 }
 
 }  // namespace shell
 }  // namespace mojo