Pass around IPC::ChannelHandles instead of raw fds in the NaCl IRT.

ppapi/nacl_irt/ppapi_dispatcher.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 "ppapi/nacl_irt/ppapi_dispatcher.h"
 
 #include <stddef.h>
 
 #include <map>
 #include <set>
@@ skipping 16 matching lines @@
 #include "ppapi/proxy/plugin_message_filter.h"
 #include "ppapi/proxy/plugin_proxy_delegate.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/resource_reply_thread_registrar.h"
 
 namespace ppapi {
 
 PpapiDispatcher::PpapiDispatcher(
     scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
     base::WaitableEvent* shutdown_event,
-    int browser_ipc_fd,
-    int renderer_ipc_fd)
+    IPC::ChannelHandle browser_ipc_handle,
+    IPC::ChannelHandle renderer_ipc_handle)
     : next_plugin_dispatcher_id_(0),
       task_runner_(io_task_runner),
       shutdown_event_(shutdown_event),
-      renderer_ipc_fd_(renderer_ipc_fd) {
-  IPC::ChannelHandle channel_handle(
-      "NaCl IPC", base::FileDescriptor(browser_ipc_fd, false));
-
+      renderer_ipc_handle_(renderer_ipc_handle) {
   proxy::PluginGlobals* globals = proxy::PluginGlobals::Get();
   // Delay initializing the SyncChannel until after we add filters. This
   // ensures that the filters won't miss any messages received by
   // the channel.
   channel_ =
       IPC::SyncChannel::Create(this, GetIPCTaskRunner(), GetShutdownEvent());
   scoped_refptr<ppapi::proxy::PluginMessageFilter> plugin_filter(
       new ppapi::proxy::PluginMessageFilter(
           NULL, globals->resource_reply_thread_registrar()));
   channel_->AddFilter(plugin_filter.get());
   globals->RegisterResourceMessageFilters(plugin_filter.get());
 
   channel_->AddFilter(new tracing::ChildTraceMessageFilter(task_runner_.get()));
-  channel_->Init(channel_handle, IPC::Channel::MODE_SERVER, true);
+  channel_->Init(browser_ipc_handle, IPC::Channel::MODE_SERVER, true);
 }
 
 base::SingleThreadTaskRunner* PpapiDispatcher::GetIPCTaskRunner() {
   return task_runner_.get();
 }
 
 base::WaitableEvent* PpapiDispatcher::GetShutdownEvent() {
   return shutdown_event_;
 }
 
@@ skipping 107 matching lines @@
 
   int32_t error = ::PPP_InitializeModule(
       0 /* module */,
       &proxy::PluginDispatcher::GetBrowserInterface);
   if (error)
     ::exit(error);
 
   proxy::PluginDispatcher* dispatcher =
       new proxy::PluginDispatcher(::PPP_GetInterface, args.permissions,
                                   args.off_the_record);
-  IPC::ChannelHandle channel_handle(
-      "nacl",
-      base::FileDescriptor(renderer_ipc_fd_, false));
   if (!dispatcher->InitPluginWithChannel(this, base::kNullProcessId,
-                                         channel_handle, false)) {
+                                         renderer_ipc_handle_, false)) {
     delete dispatcher;
     return;
   }
   // From here, the dispatcher will manage its own lifetime according to the
   // lifetime of the attached channel.
 
   // Notify the renderer process, if necessary.
   ManifestService* manifest_service = GetManifestService();
   if (manifest_service)
     manifest_service->StartupInitializationComplete();
 }
 
 void PpapiDispatcher::OnPluginDispatcherMessageReceived(
     const IPC::Message& msg) {
   // The first parameter should be a plugin dispatcher ID.
   base::PickleIterator iter(msg);
   uint32_t id = 0;
   if (!iter.ReadUInt32(&id)) {
     NOTREACHED();
     return;
   }
   std::map<uint32_t, proxy::PluginDispatcher*>::iterator dispatcher =
       plugin_dispatchers_.find(id);
   if (dispatcher != plugin_dispatchers_.end())
     dispatcher->second->OnMessageReceived(msg);
 }
 
 }  // namespace ppapi