Mojo: First stab at making MessagePipes work across OS pipes.

mojo/system/raw_channel_posix.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 "mojo/system/raw_channel.h"
 
 #include <errno.h>
 #include <string.h>
 #include <unistd.h>
 
@@ skipping 21 matching lines @@
 
 class RawChannelPosix : public RawChannel,
                         public base::MessageLoopForIO::Watcher {
  public:
   RawChannelPosix(const PlatformChannelHandle& handle,
                   Delegate* delegate,
                   base::MessageLoop* message_loop);
   virtual ~RawChannelPosix();
 
   // |RawChannel| implementation:
-  virtual void Init() OVERRIDE;
+  virtual bool Init() OVERRIDE;
   virtual void Shutdown() OVERRIDE;
   virtual bool WriteMessage(MessageInTransit* message) OVERRIDE;
 
  private:
   // |base::MessageLoopForIO::Watcher| implementation:
   virtual void OnFileCanReadWithoutBlocking(int fd) OVERRIDE;
   virtual void OnFileCanWriteWithoutBlocking(int fd) OVERRIDE;
 
   // Watches for |fd_| to become writable. Must be called on the I/O thread.
   void WaitToWrite();
@@ skipping 62 matching lines @@
   // No need to take the |write_lock_| here -- if there are still weak pointers
   // outstanding, then we're hosed anyway (since we wouldn't be able to
   // invalidate them cleanly, since we might not be on the I/O thread).
   DCHECK(!weak_ptr_factory_.HasWeakPtrs());
 
   // These must have been shut down/destroyed on the I/O thread.
   DCHECK(!read_watcher_.get());
   DCHECK(!write_watcher_.get());
 }
 
-void RawChannelPosix::Init() {
+bool RawChannelPosix::Init() {
   DCHECK_EQ(base::MessageLoop::current(), message_loop());
 
   DCHECK(!read_watcher_.get());
   read_watcher_.reset(new base::MessageLoopForIO::FileDescriptorWatcher());
   DCHECK(!write_watcher_.get());
   write_watcher_.reset(new base::MessageLoopForIO::FileDescriptorWatcher());
 
   // No need to take the lock. No one should be using us yet.
   DCHECK(write_message_queue_.empty());
 
-  bool result = message_loop_for_io()->WatchFileDescriptor(
-      fd_, true, base::MessageLoopForIO::WATCH_READ, read_watcher_.get(), this);
-  DCHECK(result);
+  if (!message_loop_for_io()->WatchFileDescriptor(fd_, true,
+          base::MessageLoopForIO::WATCH_READ, read_watcher_.get(), this)) {
+    // TODO(vtl): I'm not sure |WatchFileDescriptor()| actually fails cleanly
+    // (in the sense of returning the message loop's state to what it was before
+    // it was called).
+    read_watcher_.reset();
+    write_watcher_.reset();
+    return false;
+  }
+
+  return true;
 }
 
 void RawChannelPosix::Shutdown() {
   DCHECK_EQ(base::MessageLoop::current(), message_loop());
 
   base::AutoLock locker(write_lock_);
   if (!is_dead_)
     CancelPendingWritesNoLock();
 
   DCHECK_NE(fd_, -1);
@@ skipping 240 matching lines @@
 // Static factory method declared in raw_channel.h.
 // static
 RawChannel* RawChannel::Create(const PlatformChannelHandle& handle,
                                Delegate* delegate,
                                base::MessageLoop* message_loop) {
   return new RawChannelPosix(handle, delegate, message_loop);
 }
 
 }  // namespace system
 }  // namespace mojo