Convert over to channel handles

chrome/plugin/plugin_channel.cc

 // Copyright (c) 2010 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 "chrome/plugin/plugin_channel.h"
 
 #include "base/command_line.h"
 #include "base/lock.h"
 #include "base/process_util.h"
 #include "base/string_util.h"
@@ skipping 144 matching lines @@
 }
 
 // static
 void PluginChannel::NotifyRenderersOfPendingShutdown() {
   Broadcast(new PluginHostMsg_PluginShuttingDown());
 }
 
 PluginChannel::PluginChannel()
     : renderer_handle_(0),
       renderer_id_(-1),
-#if defined(OS_POSIX)
-      renderer_fd_(-1),
-#endif
       in_send_(0),
       off_the_record_(false),
       filter_(new MessageFilter()) {
   set_send_unblocking_only_during_unblock_dispatch();
   ChildProcess::current()->AddRefProcess();
   const CommandLine* command_line = CommandLine::ForCurrentProcess();
   log_messages_ = command_line->HasSwitch(switches::kLogPluginMessages);
 }
 
 PluginChannel::~PluginChannel() {
-#if defined(OS_POSIX)
-  // Won't be needing this any more.
-  CloseRendererFD();
-#endif
-
   if (renderer_handle_)
     base::CloseProcessHandle(renderer_handle_);
 
   MessageLoop::current()->PostDelayedTask(FROM_HERE, new PluginReleaseTask(),
                                           kPluginReleaseTimeMS);
 }
 
 bool PluginChannel::Send(IPC::Message* msg) {
   in_send_++;
   if (log_messages_) {
@@ skipping 93 matching lines @@
   }
   Send(new PluginHostMsg_ClearSiteDataResult(success));
 }
 
 base::WaitableEvent* PluginChannel::GetModalDialogEvent(
     gfx::NativeViewId containing_window) {
   return filter_->GetModalDialogEvent(containing_window);
 }
 
 void PluginChannel::OnChannelConnected(int32 peer_pid) {
-#if defined(OS_POSIX)
-  // By this point, the renderer must have its own copy of the plugin channel
-  // FD.
-  CloseRendererFD();
-#endif
-
   base::ProcessHandle handle;
   if (!base::OpenProcessHandle(peer_pid, &handle)) {
     NOTREACHED();
   }
   renderer_handle_ = handle;
   PluginChannelBase::OnChannelConnected(peer_pid);
 }
 
 void PluginChannel::OnChannelError() {
-#if defined(OS_POSIX)
-  // Won't be needing this any more.
-  CloseRendererFD();
-#endif
-
   base::CloseProcessHandle(renderer_handle_);
   renderer_handle_ = 0;
   PluginChannelBase::OnChannelError();
   CleanUp();
 }
 
 void PluginChannel::CleanUp() {
   // We need to clean up the stubs so that they call NPPDestroy.  This will
   // also lead to them releasing their reference on this object so that it can
   // be deleted.
   for (size_t i = 0; i < plugin_stubs_.size(); ++i)
     RemoveRoute(plugin_stubs_[i]->instance_id());
 
   // Need to addref this object temporarily because otherwise removing the last
   // stub will cause the destructor of this object to be called, however at
   // that point plugin_stubs_ will have one element and its destructor will be
   // called twice.
   scoped_refptr<PluginChannel> me(this);
 
   plugin_stubs_.clear();
 }
 
 bool PluginChannel::Init(MessageLoop* ipc_message_loop, bool create_pipe_now) {
-#if defined(OS_POSIX)
-  // This gets called when the PluginChannel is initially created. At this
-  // point, create the socketpair and assign the plugin side FD to the channel
-  // name. Keep the renderer side FD as a member variable in the PluginChannel
-  // to be able to transmit it through IPC.
-  int plugin_fd;
-  if (!IPC::SocketPair(&plugin_fd, &renderer_fd_))
-    return false;
-  IPC::AddChannelSocket(channel_name(), plugin_fd);
-#endif
-
   if (!PluginChannelBase::Init(ipc_message_loop, create_pipe_now))
     return false;
 
   channel_->AddFilter(filter_.get());
   return true;
 }
 
-#if defined(OS_POSIX)
-void PluginChannel::CloseRendererFD() {
-  if (renderer_fd_ != -1) {
-    if (HANDLE_EINTR(close(renderer_fd_)) < 0)
-      PLOG(ERROR) << "close";
-    renderer_fd_ = -1;
-  }
-}
-#endif