Add IPC Channel for new ManifestService.

components/nacl/renderer/ppb_nacl_private_impl.cc

 // Copyright 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 "components/nacl/renderer/ppb_nacl_private_impl.h"
 
 #include "base/command_line.h"
 #include "base/containers/scoped_ptr_hash_map.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/rand_util.h"
 #include "components/nacl/common/nacl_host_messages.h"
 #include "components/nacl/common/nacl_messages.h"
 #include "components/nacl/common/nacl_switches.h"
 #include "components/nacl/common/nacl_types.h"
+#include "components/nacl/renderer/embedder_service_channel.h"
 #include "components/nacl/renderer/nexe_load_manager.h"
 #include "components/nacl/renderer/pnacl_translation_resource_host.h"
 #include "components/nacl/renderer/sandbox_arch.h"
 #include "components/nacl/renderer/trusted_plugin_channel.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/sandbox_init.h"
 #include "content/public/renderer/pepper_plugin_instance.h"
 #include "content/public/renderer/render_thread.h"
 #include "content/public/renderer/render_view.h"
@@ skipping 71 matching lines @@
 
 #if defined(OS_POSIX)
   if (channel_handle.socket.fd == -1) {
     return false;
   }
 #endif
 
   return true;
 }
 
+struct LaunchSelLdrCompletionCallbackData :

[dmichael (off chromium), 2014/04/10 18:06:23]

A brief description of what the class does might be useful.

[hidehiko, 2014/04/10 19:02:08]

Done.

+      public base::RefCounted<LaunchSelLdrCompletionCallbackData> {
+ public:
+  LaunchSelLdrCompletionCallbackData(int num_expect_call)

[dmichael (off chromium), 2014/04/10 18:06:23]

nit: explicit

[hidehiko, 2014/04/10 19:02:08]

Acknowledged.

+      : num_remaining_call(num_expect_call),
+        result(PP_OK) {
+  }
+  int num_remaining_call;

[dmichael (off chromium), 2014/04/10 18:06:23]

nit: call->calls

[hidehiko, 2014/04/10 19:02:08]

Done.

+  int32_t result;
+
+ private:
+  friend class base::RefCounted<LaunchSelLdrCompletionCallbackData>;
+  ~LaunchSelLdrCompletionCallbackData() {
+  }
+};
+
+void LaunchSelLdrCompletionCallback(

[dmichael (off chromium), 2014/04/10 18:06:23]

suggestion: It might simplify things a tiny bit to make this a member on the
class.

It also might be good to name this function more specifically...  it's called in
response to a channel being connected, so maybe ChannelConnectedCallback

[hidehiko, 2014/04/10 19:02:08]

Good idea. How about this?

+    scoped_refptr<LaunchSelLdrCompletionCallbackData> data,
+    PP_CompletionCallback callback,
+    int32_t result) {
+  if (data->result == PP_OK && result != PP_OK)
+    data->result = result;
+
+  --data->num_remaining_call;
+  if (data->num_remaining_call > 0) {
+    // There still are some pending or on-going tasks. Wait for the results.
+    return;
+  }
+
+  ppapi::PpapiGlobals::Get()->GetMainThreadMessageLoop()->PostTask(
+      FROM_HERE,
+      base::Bind(callback.func, callback.user_data, data->result));
+}
+
 // Launch NaCl's sel_ldr process.
 void LaunchSelLdr(PP_Instance instance,
                   const char* alleged_url,
                   PP_Bool uses_irt,
                   PP_Bool uses_ppapi,
                   PP_Bool uses_nonsfi_mode,
                   PP_Bool enable_ppapi_dev,
                   PP_Bool enable_dyncode_syscalls,
                   PP_Bool enable_exception_handling,
                   PP_Bool enable_crash_throttling,
@@ skipping 67 matching lines @@
   instance_info.plugin_pid = launch_result.plugin_pid;
   instance_info.plugin_child_id = launch_result.plugin_child_id;
 
   // Don't save instance_info if channel handle is invalid.
   if (IsValidChannelHandle(instance_info.channel_handle))
     g_instance_info.Get()[instance] = instance_info;
 
   *(static_cast<NaClHandle*>(imc_handle)) =
       nacl::ToNativeHandle(result_socket);
 
-  // TODO(hidehiko): We'll add EmbedderServiceChannel here, and it will wait
-  // for the connection in parallel with TrustedPluginChannel.
-  // Thus, the callback will wait for its second invocation to run callback,
-  // then.
+  // Here after we start to establish TrustedPluginChannel and
+  // EmbedderServiceChannel in parallel. So, we count the number of connections
+  // (or errors), and invoke callback when all the connections are established.
   // Note that PP_CompletionCallback is not designed to be called twice or
   // more. Thus, it is necessary to create a function to handle multiple
   // invocation.
-  base::Callback<void(int32_t)> completion_callback =
-      base::Bind(callback.func, callback.user_data);
+  base::Callback<void(int32_t)> completion_callback = base::Bind(
+      &LaunchSelLdrCompletionCallback,
+      make_scoped_refptr(new LaunchSelLdrCompletionCallbackData(2)),
+      callback);
+
   nacl::NexeLoadManager* load_manager = GetNexeLoadManager(instance);
   DCHECK(load_manager);
 
   // Stash the trusted handle as well.
   if (load_manager &&
       IsValidChannelHandle(launch_result.trusted_ipc_channel_handle)) {
     scoped_ptr<nacl::TrustedPluginChannel> trusted_plugin_channel(
         new nacl::TrustedPluginChannel(
             launch_result.trusted_ipc_channel_handle,
             completion_callback,
             content::RenderThread::Get()->GetShutdownEvent()));
     load_manager->set_trusted_plugin_channel(trusted_plugin_channel.Pass());
   } else {
     completion_callback.Run(PP_ERROR_FAILED);
   }
+
+  // Stash the embedder service handle as well.
+  if (load_manager &&
+      IsValidChannelHandle(
+          launch_result.embedder_service_ipc_channel_handle)) {
+    scoped_ptr<nacl::EmbedderServiceChannel> embedder_service_channel(
+        new nacl::EmbedderServiceChannel(
+            launch_result.embedder_service_ipc_channel_handle,
+            completion_callback,
+            content::RenderThread::Get()->GetShutdownEvent()));
+    load_manager->set_embedder_service_channel(
+        embedder_service_channel.Pass());
+  } else {
+    // Currently, embedder service works only on linux/non-SFI mode.
+    // On other platforms, the socket will not be created, and thus this
+    // condition needs to be handled as success.
+    completion_callback.Run(PP_OK);
+  }
 }
 
 // Forward declaration.
 void ReportLoadError(PP_Instance instance,
                      PP_NaClError error,
                      const char* error_message,
                      const char* console_message);
 
 PP_Bool StartPpapiProxy(PP_Instance instance) {
   InstanceInfoMap& map = g_instance_info.Get();
@@ skipping 447 matching lines @@
 
 }  // namespace
 
 namespace nacl {
 
 const PPB_NaCl_Private* GetNaClPrivateInterface() {
   return &nacl_interface;
 }
 
 }  // namespace nacl