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/bind.h"
+#include "base/bind_helpers.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/manifest_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 72 matching lines @@
 
 #if defined(OS_POSIX)
   if (channel_handle.socket.fd == -1) {
     return false;
   }
 #endif
 
   return true;
 }
 
+// Callback invoked when an IPC channel connection is established.
+// As we will establish multiple IPC channels, this takes the number
+// of expected invocations and a callback. When all channels are established,
+// the given callback will be invoked on the main thread. Its argument will be
+// PP_OK if all the connections are successfully established. Otherwise,
+// the first error code will be passed, and remaining errors will be ignored.
+// Note that PP_CompletionCallback is designed to be called exactly once.
+class ChannelConnectedCallback {
+ public:
+  ChannelConnectedCallback(int num_expect_calls,
+                           PP_CompletionCallback callback)
+      : num_remaining_calls_(num_expect_calls),
+        callback_(callback),
+        result_(PP_OK) {
+  }
+
+  ~ChannelConnectedCallback() {
+  }
+
+  void Run(int32_t result) {
+    if (result_ == PP_OK && result != PP_OK) {
+      // This is the first error, so remember it.
+      result_ = result;
+    }
+
+    --num_remaining_calls_;
+    if (num_remaining_calls_ > 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, result_));
+  }
+
+ private:
+  int num_remaining_calls_;
+  PP_CompletionCallback callback_;
+  int32_t result_;
+
+  DISALLOW_COPY_AND_ASSIGN(ChannelConnectedCallback);
+};
+
 // 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.
-  // 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);
+  // Here after, we starts to establish connections for TrustedPluginChannel
+  // and ManifestServiceChannel in parallel. The invocation of the callback
+  // is delegated to their connection completion callback.
+  base::Callback<void(int32_t)> connected_callback = base::Bind(
+      &ChannelConnectedCallback::Run,
+      base::Owned(new ChannelConnectedCallback(
+          2, // For TrustedPluginChannel and ManifestServiceChannel.
+          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,
+            connected_callback,
             content::RenderThread::Get()->GetShutdownEvent()));
     load_manager->set_trusted_plugin_channel(trusted_plugin_channel.Pass());
   } else {
-    completion_callback.Run(PP_ERROR_FAILED);
+    connected_callback.Run(PP_ERROR_FAILED);
+  }
+
+  // Stash the manifest service handle as well.
+  if (load_manager &&
+      IsValidChannelHandle(
+          launch_result.manifest_service_ipc_channel_handle)) {
+    scoped_ptr<nacl::ManifestServiceChannel> manifest_service_channel(
+        new nacl::ManifestServiceChannel(
+            launch_result.manifest_service_ipc_channel_handle,
+            connected_callback,
+            content::RenderThread::Get()->GetShutdownEvent()));
+    load_manager->set_manifest_service_channel(
+        manifest_service_channel.Pass());
+  } else {
+    // Currently, manifest 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.
+    connected_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) {
@@ skipping 470 matching lines @@
 
 }  // namespace
 
 namespace nacl {
 
 const PPB_NaCl_Private* GetNaClPrivateInterface() {
   return &nacl_interface;
 }
 
 }  // namespace nacl