Revert "posix: two related changes to make plugin IPC work on POSIX."

This reverts commit r18850, as it had a compile failure.

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@18851 0039d316-1c4b-4281-b951-d872f2087c98

17 files changed, 60 insertions, 280 deletions

diff --git a/chrome/browser/plugin_process_host.cc b/chrome/browser/plugin_process_host.cc
index 833f17f..5216755 100644
--- a/chrome/browser/plugin_process_host.cc
+++ b/chrome/browser/plugin_process_host.cc
@@ -40,7 +40,6 @@
 #include "chrome/common/logging_chrome.h"
 #include "chrome/common/plugin_messages.h"
 #include "chrome/common/render_messages.h"
-#include "chrome/common/ipc_channel_handle.h"
 #include "net/base/cookie_monster.h"
 #include "net/base/file_stream.h"
 #include "net/base/io_buffer.h"
@@ -54,10 +53,6 @@
 #include "sandbox/src/sandbox.h"
 #endif
 
-#if defined(OS_POSIX)
-#include "chrome/common/ipc_channel_posix.h"
-#endif
-
 static const char kDefaultPluginFinderURL[] =
     "http://dl.google.com/chrome/plugins/plugins2.xml";
 
@@ -459,7 +454,7 @@ void PluginProcessHost::OnChannelConnected(int32 peer_pid) {
 void PluginProcessHost::OnChannelError() {
   for (size_t i = 0; i < pending_requests_.size(); ++i) {
     ReplyToRenderer(pending_requests_[i].renderer_message_filter_.get(),
-                    IPC::ChannelHandle(),
+                    std::string(),
                     FilePath(),
                     pending_requests_[i].reply_msg);
   }
@@ -473,17 +468,8 @@ void PluginProcessHost::OpenChannelToPlugin(
     IPC::Message* reply_msg) {
   InstanceCreated();
   if (opening_channel()) {
-    // The channel is already in the process of being opened.  Put
-    // this "open channel" request into a queue of requests that will
-    // be run once the channel is open.
-    //
-    // On POSIX, we'll only create the pipe when we get around to actually
-    // making this request.  So the socket fd is -1 for now.  (On Windows,
-    // socket_fd is unused.)
-    int socket_fd = -1;
     pending_requests_.push_back(
-        ChannelRequest(renderer_message_filter, mime_type, reply_msg,
-                       socket_fd));
+        ChannelRequest(renderer_message_filter, mime_type, reply_msg));
     return;
   }
 
@@ -520,8 +506,7 @@ void PluginProcessHost::OnResolveProxyCompleted(IPC::Message* reply_msg,
 
 void PluginProcessHost::ReplyToRenderer(
     ResourceMessageFilter* renderer_message_filter,
-    const IPC::ChannelHandle& channel,
-    const FilePath& plugin_path,
+    const std::string& channel, const FilePath& plugin_path,
     IPC::Message* reply_msg) {
   ViewHostMsg_OpenChannelToPlugin::WriteReplyParams(reply_msg, channel,
                                                     plugin_path);
@@ -537,45 +522,29 @@ URLRequestContext* PluginProcessHost::GetRequestContext(
 void PluginProcessHost::RequestPluginChannel(
     ResourceMessageFilter* renderer_message_filter,
     const std::string& mime_type, IPC::Message* reply_msg) {
-  // We're about to send the request for a plugin channel.
-  // On POSIX, we create the channel endpoints here, so we can send the
-  // endpoints to the plugin and renderer.
-  int plugin_fd = -1, renderer_fd = -1;
-#if defined(OS_POSIX)
-  // On POSIX, we create the channel endpoints here.
-  IPC::SocketPair(&plugin_fd, &renderer_fd);
-#endif
-
   // We can't send any sync messages from the browser because it might lead to
   // a hang.  However this async messages must be answered right away by the
   // plugin process (i.e. unblocks a Send() call like a sync message) otherwise
   // a deadlock can occur if the plugin creation request from the renderer is
   // a result of a sync message by the plugin process.
   PluginProcessMsg_CreateChannel* msg = new PluginProcessMsg_CreateChannel(
-#if defined(OS_POSIX)
-      // Takes ownership of plugin_fd.
-      base::FileDescriptor(plugin_fd, true),
-#endif
       renderer_message_filter->GetProcessId(),
       renderer_message_filter->off_the_record());
   msg->set_unblock(true);
   if (Send(msg)) {
     sent_requests_.push(ChannelRequest(
-        renderer_message_filter, mime_type, reply_msg, renderer_fd));
+        renderer_message_filter, mime_type, reply_msg));
   } else {
-    ReplyToRenderer(renderer_message_filter, IPC::ChannelHandle(), FilePath(),
+    ReplyToRenderer(renderer_message_filter, std::string(), FilePath(),
                     reply_msg);
   }
 }
 
 void PluginProcessHost::OnChannelCreated(const std::string& channel_name) {
-  const ChannelRequest& request = sent_requests_.front();
-  IPC::ChannelHandle channel_handle(channel_name,
-                                    base::FileDescriptor(request.socket, true));
-  ReplyToRenderer(request.renderer_message_filter_.get(),
-                  channel_handle,
+  ReplyToRenderer(sent_requests_.front().renderer_message_filter_.get(),
+                  channel_name,
                   info_.path,
-                  request.reply_msg);
+                  sent_requests_.front().reply_msg);
   sent_requests_.pop();
 }
 
diff --git a/chrome/browser/plugin_process_host.h b/chrome/browser/plugin_process_host.h
index 9a74dff..56004f6 100644
--- a/chrome/browser/plugin_process_host.h
+++ b/chrome/browser/plugin_process_host.h
@@ -18,7 +18,6 @@
 #include "chrome/browser/net/resolve_proxy_msg_helper.h"
 #include "chrome/browser/renderer_host/resource_message_filter.h"
 #include "chrome/common/child_process_host.h"
-#include "chrome/common/ipc_channel_handle.h"
 #include "webkit/glue/webplugininfo.h"
 
 class URLRequestContext;
@@ -66,7 +65,7 @@ class PluginProcessHost : public ChildProcessHost,
   // Sends the reply to an open channel request to the renderer with the given
   // channel name.
   static void ReplyToRenderer(ResourceMessageFilter* renderer_message_filter,
-                              const IPC::ChannelHandle& channel,
+                              const std::string& channel,
                               const FilePath& plugin_path,
                               IPC::Message* reply_msg);
 
@@ -114,15 +113,12 @@ class PluginProcessHost : public ChildProcessHost,
 
   struct ChannelRequest {
     ChannelRequest(ResourceMessageFilter* renderer_message_filter,
-                   const std::string& m, IPC::Message* r,
-                   int s) :
+                   const std::string& m, IPC::Message* r) :
         mime_type(m), reply_msg(r),
-        renderer_message_filter_(renderer_message_filter),
-        socket(s) { }
+        renderer_message_filter_(renderer_message_filter) { }
     std::string mime_type;
     IPC::Message* reply_msg;
     scoped_refptr<ResourceMessageFilter> renderer_message_filter_;
-    int socket;
   };
 
   // These are channel requests that we are waiting to send to the
diff --git a/chrome/browser/plugin_service.cc b/chrome/browser/plugin_service.cc
index c49d56d..773698a 100644
--- a/chrome/browser/plugin_service.cc
+++ b/chrome/browser/plugin_service.cc
@@ -167,7 +167,7 @@ void PluginService::OpenChannelToPlugin(
     plugin_host->OpenChannelToPlugin(renderer_msg_filter, mime_type, reply_msg);
   } else {
     PluginProcessHost::ReplyToRenderer(renderer_msg_filter,
-                                       IPC::ChannelHandle(),
+                                       std::string(),
                                        FilePath(),
                                        reply_msg);
   }
diff --git a/chrome/browser/renderer_host/resource_message_filter.cc b/chrome/browser/renderer_host/resource_message_filter.cc
index 4728b17..2121378 100644
--- a/chrome/browser/renderer_host/resource_message_filter.cc
+++ b/chrome/browser/renderer_host/resource_message_filter.cc
@@ -176,7 +176,7 @@ void ResourceMessageFilter::OnFilterAdded(IPC::Channel* channel) {
 
 // Called on the IPC thread:
 void ResourceMessageFilter::OnChannelConnected(int32 peer_pid) {
-  DCHECK(!handle()) << " " << handle();
+  DCHECK(!handle());
   base::ProcessHandle peer_handle;
   if (!base::OpenProcessHandle(peer_pid, &peer_handle)) {
     NOTREACHED();
diff --git a/chrome/chrome.gyp b/chrome/chrome.gyp
index 141f483..75ed116 100644
--- a/chrome/chrome.gyp
+++ b/chrome/chrome.gyp
@@ -347,7 +347,6 @@
         'common/important_file_writer.cc',
         'common/important_file_writer.h',
         'common/ipc_channel.h',
-        'common/ipc_channel_handle.h',
         'common/ipc_channel_posix.cc',
         'common/ipc_channel_posix.h',
         'common/ipc_channel_proxy.cc',
diff --git a/chrome/common/ipc_channel_handle.h b/chrome/common/ipc_channel_handle.h
deleted file mode 100644
index 2bb6380..0000000
--- a/chrome/common/ipc_channel_handle.h
+++ /dev/null
@@ -1,45 +0,0 @@
-// Copyright (c) 2009 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.
-
-#ifndef CHROME_COMMON_IPC_CHANNEL_HANDLE_H_
-#define CHROME_COMMON_IPC_CHANNEL_HANDLE_H_
-
-#include "build/build_config.h"
-
-#if defined(OS_POSIX)
-#include "base/file_descriptor_posix.h"
-#endif
-
-// On Windows, any process can create an IPC channel and others can fetch
-// it by name.  We pass around the channel names over IPC.
-// On POSIX, we instead pass around handles to channel endpoints via IPC.
-// When it's time to IPC a new channel endpoint around, we send both the
-// channel name as well as a base::FileDescriptor, which is itself a special
-// type that knows how to copy a socket endpoint over IPC.
-//
-// In sum, when passing a handle to a channel over IPC, use this data structure
-// to work on both Windows and POSIX.
-
-namespace IPC {
-
-struct ChannelHandle {
-  // Note that serialization for this object is defined in the ParamTraits
-  // template specialization in ipc_message_utils.h.
-  std::string name;
-#if defined(OS_POSIX)
-  base::FileDescriptor socket;
-#endif
-
-  ChannelHandle() {}
-#if defined(OS_POSIX)
-  ChannelHandle(const std::string& n, const base::FileDescriptor& s)
-      : name(n), socket(s) {}
-#else
-  ChannelHandle(const std::string& n) : name(n) {}
-#endif
-};
-
-}  // namespace IPC
-
-#endif  // CHROME_COMMON_IPC_CHANNEL_HANDLE_H_
diff --git a/chrome/common/ipc_channel_posix.cc b/chrome/common/ipc_channel_posix.cc
index 63f2703..babc16c 100644
--- a/chrome/common/ipc_channel_posix.cc
+++ b/chrome/common/ipc_channel_posix.cc
@@ -104,9 +104,9 @@ class PipeMap {
     DCHECK(fd != -1);
 
     ChannelToFDMap::const_iterator i = map_.find(channel_id);
-    CHECK(i == map_.end()) << "Creating second IPC server (fd " << fd << ") "
-                           << "for '" << channel_id << "' while first "
-                           << "(fd " << i->second << ") still exists";
+    CHECK(i == map_.end()) << "Creating second IPC server for '"
+                           << channel_id
+                           << "' while first still exists";
     map_[channel_id] = fd;
   }
 
@@ -116,20 +116,16 @@ class PipeMap {
   ChannelToFDMap map_;
 };
 
-// Used to map a channel name to the equivalent FD # in the current process.
-// Returns -1 if the channel is unknown.
-int ChannelNameToFD(const std::string& channel_id) {
+// Used to map a channel name to the equivalent FD # in the client process.
+int ChannelNameToClientFD(const std::string& channel_id) {
   // See the large block comment above PipeMap for the reasoning here.
   const int fd = Singleton<PipeMap>()->Lookup(channel_id);
+  if (fd != -1)
+    return dup(fd);
 
-  if (fd != -1) {
-    int dup_fd = dup(fd);
-    if (dup_fd < 0)
-      LOG(FATAL) << "dup(" << fd << "): " << strerror(errno);
-    return dup_fd;
-  }
-
-  return fd;
+  // If we don't find an entry, we assume that the correct value has been
+  // inserted in the magic slot.
+  return Singleton<base::GlobalDescriptors>()->Get(kPrimaryIPCChannel);
 }
 
 //------------------------------------------------------------------------------
@@ -265,34 +261,6 @@ Channel::ChannelImpl::ChannelImpl(const std::string& channel_id, Mode mode,
   }
 }
 
-// static
-void AddChannelSocket(const std::string& name, int socket) {
-  Singleton<PipeMap>()->Insert(name, socket);
-}
-
-// static
-bool SocketPair(int* fd1, int* fd2) {
-  int pipe_fds[2];
-  if (socketpair(AF_UNIX, SOCK_STREAM, 0, pipe_fds) != 0) {
-    LOG(ERROR) << "socketpair(): " << strerror(errno);
-    return false;
-  }
-
-  // Set both ends to be non-blocking.
-  if (fcntl(pipe_fds[0], F_SETFL, O_NONBLOCK) == -1 ||
-      fcntl(pipe_fds[1], F_SETFL, O_NONBLOCK) == -1) {
-    LOG(ERROR) << "fcntl(O_NONBLOCK): " << strerror(errno);
-    HANDLE_EINTR(close(pipe_fds[0]));
-    HANDLE_EINTR(close(pipe_fds[1]));
-    return false;
-  }
-
-  *fd1 = pipe_fds[0];
-  *fd2 = pipe_fds[1];
-
-  return true;
-}
-
 bool Channel::ChannelImpl::CreatePipe(const std::string& channel_id,
                                       Mode mode) {
   DCHECK(server_listen_pipe_ == -1 && pipe_ == -1);
@@ -314,24 +282,27 @@ bool Channel::ChannelImpl::CreatePipe(const std::string& channel_id,
       waiting_connect_ = false;
     }
   } else {
-    // This is the normal (non-unit-test) case, where we're using sockets.
-    // Three possible cases:
-    // 1) It's for a channel we already have a pipe for; reuse it.
-    // 2) It's the initial IPC channel:
-    //   2a) Server side: create the pipe.
-    //   2b) Client side: Pull the pipe out of the GlobalDescriptors set.
+    // socketpair()
     pipe_name_ = channel_id;
-    pipe_ = ChannelNameToFD(pipe_name_);
-    if (pipe_ < 0) {
-      // Initial IPC channel.
-      if (mode == MODE_SERVER) {
-        if (!SocketPair(&pipe_, &client_pipe_))
-          return false;
-        AddChannelSocket(pipe_name_, client_pipe_);
-      } else {
-        pipe_ = Singleton<base::GlobalDescriptors>()->Get(kPrimaryIPCChannel);
+    if (mode == MODE_SERVER) {
+      int pipe_fds[2];
+      if (socketpair(AF_UNIX, SOCK_STREAM, 0, pipe_fds) != 0) {
+        return false;
       }
+      // Set both ends to be non-blocking.
+      if (fcntl(pipe_fds[0], F_SETFL, O_NONBLOCK) == -1 ||
+          fcntl(pipe_fds[1], F_SETFL, O_NONBLOCK) == -1) {
+        HANDLE_EINTR(close(pipe_fds[0]));
+        HANDLE_EINTR(close(pipe_fds[1]));
+        return false;
+      }
+      pipe_ = pipe_fds[0];
+      client_pipe_ = pipe_fds[1];
+
+      Singleton<PipeMap>()->Insert(pipe_name_, client_pipe_);
     } else {
+      pipe_ = ChannelNameToClientFD(pipe_name_);
+      DCHECK(pipe_ > 0);
       waiting_connect_ = false;
     }
   }
@@ -641,7 +612,7 @@ bool Channel::ChannelImpl::ProcessOutgoingMessages() {
         return false;
       }
 #endif  // OS_MACOSX
-      LOG(ERROR) << "pipe error on " << pipe_ << ": " << strerror(errno);
+      LOG(ERROR) << "pipe error: " << strerror(errno);
       return false;
     }
 
diff --git a/chrome/common/ipc_channel_posix.h b/chrome/common/ipc_channel_posix.h
index 5e8d977..ed3d727 100644
--- a/chrome/common/ipc_channel_posix.h
+++ b/chrome/common/ipc_channel_posix.h
@@ -18,15 +18,6 @@
 
 namespace IPC {
 
-// Store that channel name |name| is available via socket |socket|.
-// Used when the channel has been precreated by another process on
-// our behalf and they've just shipped us the socket.
-void AddChannelSocket(const std::string& name, int socket);
-
-// Construct a socket pair appropriate for IPC: UNIX domain, nonblocking.
-// Returns false on error.
-bool SocketPair(int* fd1, int* fd2);
-
 // An implementation of ChannelImpl for POSIX systems that works via
 // socketpairs.  See the .cc file for an overview of the implementation.
 class Channel::ChannelImpl : public MessageLoopForIO::Watcher {
@@ -69,16 +60,9 @@ class Channel::ChannelImpl : public MessageLoopForIO::Watcher {
   // a socketpair().
   bool uses_fifo_;
 
-  // File descriptor we're listening on for new connections in the FIFO case;
-  // unused otherwise.
   int server_listen_pipe_;
-
-  // The pipe used for communication.
   int pipe_;
-
-  // For a server, the client end of our socketpair() -- the other end of our
-  // pipe_ that is passed to the client.
-  int client_pipe_;
+  int client_pipe_;  // The client end of our socketpair().
 
   // The "name" of our pipe.  On Windows this is the global identifier for
   // the pipe.  On POSIX it's used as a key in a local map of file descriptors.
diff --git a/chrome/common/ipc_message_utils.h b/chrome/common/ipc_message_utils.h
index 2ae2ab5..3f0f7b2 100644
--- a/chrome/common/ipc_message_utils.h
+++ b/chrome/common/ipc_message_utils.h
@@ -16,7 +16,6 @@
 #if defined(OS_POSIX)
 #include "chrome/common/file_descriptor_set_posix.h"
 #endif
-#include "chrome/common/ipc_channel_handle.h"
 #include "chrome/common/ipc_sync_message.h"
 #include "chrome/common/thumbnail_score.h"
 #include "chrome/common/transport_dib.h"
@@ -727,34 +726,6 @@ struct ParamTraits<base::FileDescriptor> {
 };
 #endif // defined(OS_POSIX)
 
-// A ChannelHandle is basically a platform-inspecific wrapper around the
-// fact that IPC endpoints are handled specially on POSIX.  See above comments
-// on FileDescriptor for more background.
-template<>
-struct ParamTraits<IPC::ChannelHandle> {
-  typedef ChannelHandle param_type;
-  static void Write(Message* m, const param_type& p) {
-    WriteParam(m, p.name);
-#if defined(OS_POSIX)
-    WriteParam(m, p.socket);
-#endif
-  }
-  static bool Read(const Message* m, void** iter, param_type* r) {
-    return ReadParam(m, iter, &r->name)
-#if defined(OS_POSIX)
-        && ReadParam(m, iter, &r->socket)
-#endif
-        ;
-  }
-  static void Log(const param_type& p, std::wstring* l) {
-    l->append(StringPrintf(L"ChannelHandle(%s", p.name.c_str()));
-#if defined(OS_POSIX)
-    ParamTraits<base::FileDescriptor>::Log(p.socket, l);
-#endif
-    l->append(L")");
-  }
-};
-
 template<>
 struct ParamTraits<ThumbnailScore> {
   typedef ThumbnailScore param_type;
diff --git a/chrome/common/plugin_messages_internal.h b/chrome/common/plugin_messages_internal.h
index 500bd93..b2805fc 100644
--- a/chrome/common/plugin_messages_internal.h
+++ b/chrome/common/plugin_messages_internal.h
@@ -3,14 +3,9 @@
 // found in the LICENSE file.
 
 #include "base/shared_memory.h"
-#include "build/build_config.h"
 #include "chrome/common/ipc_message_macros.h"
 #include "webkit/glue/webcursor.h"
 
-#if defined(OS_POSIX)
-#include "base/file_descriptor_posix.h"
-#endif
-
 //-----------------------------------------------------------------------------
 // PluginProcess messages
 // These are messages sent from the browser to the plugin process.
@@ -20,19 +15,9 @@ IPC_BEGIN_MESSAGES(PluginProcess)
   // PluginProcessHostMsg_ChannelCreated message.  The renderer's process_id is
   // passed so that the plugin process reuses an existing channel to that
   // process if it exists.
-  // It would be nice to use #ifdefs inside the parameter list to not need to
-  // duplicate this across POSIX/Windows but the Visual Studio compiler doesn't
-  // like that.
-#if defined(OS_WIN)
   IPC_MESSAGE_CONTROL2(PluginProcessMsg_CreateChannel,
                        int /* process_id */,
                        bool /* off_the_record */)
-#elif defined(OS_POSIX)
-  IPC_MESSAGE_CONTROL3(PluginProcessMsg_CreateChannel,
-                       base::FileDescriptor /* socket for new channel */,
-                       int /* process_id */,
-                       bool /* off_the_record */)
-#endif
 
   // Allows a chrome plugin loaded in the browser process to send arbitrary
   // data to an instance of the same plugin loaded in a plugin process.
diff --git a/chrome/common/render_messages_internal.h b/chrome/common/render_messages_internal.h
index 5debd5f..d96220d 100644
--- a/chrome/common/render_messages_internal.h
+++ b/chrome/common/render_messages_internal.h
@@ -17,7 +17,6 @@
 #include "base/gfx/native_widget_types.h"
 #include "base/shared_memory.h"
 #include "base/values.h"
-#include "chrome/common/ipc_channel_handle.h"
 #include "chrome/common/ipc_message_macros.h"
 #include "chrome/common/transport_dib.h"
 #include "third_party/skia/include/core/SkBitmap.h"
@@ -925,16 +924,16 @@ IPC_BEGIN_MESSAGES(ViewHost)
                       std::string  /* origin */,
                       std::string  /* target */)
 
-  // A renderer sends this to the browser process when it wants to
-  // create a plugin.  The browser will create the plugin process if
-  // necessary, and will return a handle to the channel on success.
-  // On error an empty string is returned.
+  // A renderer sends this to the browser process when it wants to create a
+  // plugin.  The browser will create the plugin process if necessary, and
+  // will return the channel name on success.  On error an empty string is
+  // returned.
   IPC_SYNC_MESSAGE_CONTROL4_2(ViewHostMsg_OpenChannelToPlugin,
                               GURL /* url */,
                               std::string /* mime_type */,
                               std::string /* clsid */,
                               std::wstring /* locale */,
-                              IPC::ChannelHandle /* handle to channel */,
+                              std::string /* channel_name */,
                               FilePath /* plugin_path */)
 
   // Clipboard IPC messages
diff --git a/chrome/plugin/plugin_channel.cc b/chrome/plugin/plugin_channel.cc
index b9e7a52..4ff7b2b 100644
--- a/chrome/plugin/plugin_channel.cc
+++ b/chrome/plugin/plugin_channel.cc
@@ -7,29 +7,17 @@
 #include "base/command_line.h"
 #include "base/process_util.h"
 #include "base/string_util.h"
-#include "build/build_config.h"
 #include "chrome/common/child_process.h"
 #include "chrome/common/plugin_messages.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/plugin/plugin_thread.h"
 
-#if defined(OS_POSIX)
-#include "chrome/common/ipc_channel_posix.h"
-#endif
-
 PluginChannel* PluginChannel::GetPluginChannel(
-    int process_id, MessageLoop* ipc_message_loop, int channel_fd) {
+    int process_id, MessageLoop* ipc_message_loop) {
   // map renderer's process id to a (single) channel to that process
   std::string channel_name = StringPrintf(
       "%d.r%d", base::GetCurrentProcId(), process_id);
 
-#if defined(OS_POSIX)
-  // If we were provided an already-open channel, associate it with
-  // the channel name in this process's name<->socket map.
-  if (channel_fd > 0)
-    IPC::AddChannelSocket(channel_name, channel_fd);
-#endif
-
   return static_cast<PluginChannel*>(PluginChannelBase::GetChannel(
       channel_name,
       IPC::Channel::MODE_SERVER,
diff --git a/chrome/plugin/plugin_channel.h b/chrome/plugin/plugin_channel.h
index 21373fb..f0bba80 100644
--- a/chrome/plugin/plugin_channel.h
+++ b/chrome/plugin/plugin_channel.h
@@ -15,12 +15,8 @@
 // process.  On the renderer side there's a corresponding PluginChannelHost.
 class PluginChannel : public PluginChannelBase {
  public:
-  // Get a new PluginChannel object for the current process.
-  // POSIX only: If |channel_fd| > 0, use that file descriptor for the
-  // channel socket.
-  static PluginChannel* GetPluginChannel(int process_id,
-                                         MessageLoop* ipc_message_loop,
-                                         int channel_fd);
+  static PluginChannel* GetPluginChannel(
+      int process_id, MessageLoop* ipc_message_loop);
 
   ~PluginChannel();
 
diff --git a/chrome/plugin/plugin_thread.cc b/chrome/plugin/plugin_thread.cc
index 2f9c2ec..cb92de4 100644
--- a/chrome/plugin/plugin_thread.cc
+++ b/chrome/plugin/plugin_thread.cc
@@ -102,19 +102,10 @@ void PluginThread::CleanUp() {
   lazy_tls.Pointer()->Set(NULL);
 }
 
-void PluginThread::OnCreateChannel(
-#if defined(OS_POSIX)
-    base::FileDescriptor socket,
-#endif
-    int process_id,
-    bool off_the_record) {
-  int fd = -1;
-#if defined(OS_POSIX)
-  fd = socket.fd;
-#endif
+void PluginThread::OnCreateChannel(int process_id, bool off_the_record) {
   std::string channel_name;
   scoped_refptr<PluginChannel> channel =
-      PluginChannel::GetPluginChannel(process_id, owner_loop(), fd);
+      PluginChannel::GetPluginChannel(process_id, owner_loop());
   if (channel.get()) {
     channel_name = channel->channel_name();
     channel->set_off_the_record(off_the_record);
diff --git a/chrome/plugin/plugin_thread.h b/chrome/plugin/plugin_thread.h
index 911940a..052be0a 100644
--- a/chrome/plugin/plugin_thread.h
+++ b/chrome/plugin/plugin_thread.h
@@ -7,15 +7,10 @@
 
 #include "base/file_path.h"
 #include "base/native_library.h"
-#include "build/build_config.h"
 #include "chrome/common/child_thread.h"
 #include "chrome/plugin/plugin_channel.h"
 #include "webkit/glue/plugins/plugin_lib.h"
 
-#if defined(OS_POSIX)
-#include "base/file_descriptor_posix.h"
-#endif
-
 class NotificationService;
 
 // The PluginThread class represents a background thread where plugin instances
@@ -36,14 +31,7 @@ class PluginThread : public ChildThread {
   virtual void Init();
   virtual void CleanUp();
 
-  // Callback for when a channel has been created.
-  // On POSIX, |socket| is the channel endpoint socket.
-  void OnCreateChannel(
-#if defined(OS_POSIX)
-      base::FileDescriptor socket,
-#endif
-      int process_id,
-      bool off_the_record);
+  void OnCreateChannel(int process_id, bool off_the_record);
   void OnPluginMessage(const std::vector<uint8> &data);
 
   scoped_ptr<NotificationService> notification_service_;
diff --git a/chrome/plugin/webplugin_delegate_stub.cc b/chrome/plugin/webplugin_delegate_stub.cc
index 8cc3273..800db41 100644
--- a/chrome/plugin/webplugin_delegate_stub.cc
+++ b/chrome/plugin/webplugin_delegate_stub.cc
@@ -135,9 +135,9 @@ void WebPluginDelegateStub::OnInit(const PluginMsg_Init_Params& params,
   delegate_ = WebPluginDelegate::Create(
       path, mime_type_, gfx::NativeViewFromId(params.containing_window));
 #else
-  NOTIMPLEMENTED() << " need to figure out nativeview id business";
-  delegate_ = WebPluginDelegate::Create(
-      path, mime_type_, NULL);
+  // We don't have gfx::NativeViewFromId on Linux
+  NOTIMPLEMENTED();
+  delegate_ = NULL;
 #endif
 
   if (delegate_) {
diff --git a/chrome/renderer/webplugin_delegate_proxy.cc b/chrome/renderer/webplugin_delegate_proxy.cc
index 8117acf..87d3ec1 100644
--- a/chrome/renderer/webplugin_delegate_proxy.cc
+++ b/chrome/renderer/webplugin_delegate_proxy.cc
@@ -41,10 +41,6 @@
 #include "chrome/common/gfx/emf.h"
 #endif
 
-#if defined(OS_POSIX)
-#include "chrome/common/ipc_channel_posix.h"
-#endif
-
 using WebKit::WebInputEvent;
 using WebKit::WebDragData;
 using WebKit::WebVector;
@@ -211,24 +207,16 @@ bool WebPluginDelegateProxy::Initialize(const GURL& url, char** argn,
                                         char** argv, int argc,
                                         WebPlugin* plugin,
                                         bool load_manually) {
-  IPC::ChannelHandle channel_handle;
+  std::string channel_name;
   FilePath plugin_path;
   if (!RenderThread::current()->Send(new ViewHostMsg_OpenChannelToPlugin(
           url, mime_type_, clsid_, webkit_glue::GetWebKitLocale(),
-          &channel_handle, &plugin_path))) {
+          &channel_name, &plugin_path)))
     return false;
-  }
-
-#if defined(OS_POSIX)
-  // If we received a ChannelHandle, register it now.
-  if (channel_handle.socket.fd >= 0)
-    IPC::AddChannelSocket(channel_handle.name, channel_handle.socket.fd);
-#endif
 
   MessageLoop* ipc_message_loop = RenderThread::current()->owner_loop();
   scoped_refptr<PluginChannelHost> channel_host =
-      PluginChannelHost::GetPluginChannelHost(channel_handle.name,
-                                              ipc_message_loop);
+      PluginChannelHost::GetPluginChannelHost(channel_name, ipc_message_loop);
   if (!channel_host.get())
     return false;