Mojo: Make Channel take a RawChannel rather than creating it.

mojo/system/raw_channel.h

 // 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.
 
 #ifndef MOJO_SYSTEM_RAW_CHANNEL_H_
 #define MOJO_SYSTEM_RAW_CHANNEL_H_
 
 #include <deque>
 #include <vector>
 
@@ skipping 54 matching lines @@
     // After |OnFatalError(FATAL_ERROR_FAILED_READ)| there won't be further
     // |OnReadMessage()| calls.
     virtual void OnFatalError(FatalError fatal_error) = 0;
 
    protected:
     virtual ~Delegate() {}
   };
 
   // Static factory method. |handle| should be a handle to a
   // (platform-appropriate) bidirectional communication channel (e.g., a socket
-  // on POSIX, a named pipe on Windows). Does *not* take ownership of |delegate|
-  // and |message_loop_for_io|, which must remain alive while this object does.
-  static RawChannel* Create(embedder::ScopedPlatformHandle handle,
-                            Delegate* delegate,
-                            base::MessageLoopForIO* message_loop_for_io);
+  // on POSIX, a named pipe on Windows).
+  static scoped_ptr<RawChannel> Create(embedder::ScopedPlatformHandle handle);
 
-  // This must be called (on an I/O thread) before this object is used. Returns
-  // true on success. On failure, |Shutdown()| should *not* be called.
-  bool Init();
+  // This must be called (on an I/O thread) before this object is used. Does
+  // *not* take ownership of |delegate|. Both the I/O thread and |delegate| must
+  // remain alive for the lifetime of this object. Returns true on success. On
+  // failure, |Shutdown()| should *not* be called.
+  bool Init(Delegate* delegate);
 
   // This must be called (on the I/O thread) before this object is destroyed.
   void Shutdown();
 
   // Writes the given message (or schedules it to be written). This is
   // thread-safe. Returns true on success.
   bool WriteMessage(scoped_ptr<MessageInTransit> message);
 
   // Returns true if the write buffer is empty (i.e., all messages written using
   // |WriteMessage()| have actually been sent.
@@ skipping 49 matching lines @@
     // TODO(vtl): When C++11 is available, switch this to a deque of
     // |scoped_ptr|/|unique_ptr|s.
     std::deque<MessageInTransit*> message_queue_;
     // The first message may have been partially sent. |offset_| indicates the
     // position in the first message where to start the next write.
     size_t offset_;
 
     DISALLOW_COPY_AND_ASSIGN(WriteBuffer);
   };
 
-  RawChannel(Delegate* delegate, base::MessageLoopForIO* message_loop_for_io);
+  RawChannel();
 
   base::MessageLoopForIO* message_loop_for_io() { return message_loop_for_io_; }
   base::Lock& write_lock() { return write_lock_; }
 
   // Only accessed on the I/O thread.
   ReadBuffer* read_buffer();
 
   // Only accessed under |write_lock_|.
   WriteBuffer* write_buffer_no_lock();
 
@@ skipping 52 matching lines @@
   // thread WITHOUT |write_lock_| held.
   void CallOnFatalError(Delegate::FatalError fatal_error);
 
   // If |result| is true, updates the write buffer and schedules a write
   // operation to run later if there are more contents to write. If |result| is
   // false or any error occurs during the method execution, cancels pending
   // writes and returns false.
   // Must be called only if |write_stopped_| is false and under |write_lock_|.
   bool OnWriteCompletedNoLock(bool result, size_t bytes_written);
 
-  Delegate* const delegate_;
-  base::MessageLoopForIO* const message_loop_for_io_;
+  // Set in |Init()| and never changed (hence usable on any thread without
+  // locking):
+  Delegate* delegate_;
+  base::MessageLoopForIO* message_loop_for_io_;
 
   // Only used on the I/O thread:
   bool read_stopped_;
   scoped_ptr<ReadBuffer> read_buffer_;
 
   base::Lock write_lock_;  // Protects the following members.
   bool write_stopped_;
   scoped_ptr<WriteBuffer> write_buffer_;
 
   // This is used for posting tasks from write threads to the I/O thread. It
   // must only be accessed under |write_lock_|. The weak pointers it produces
   // are only used/invalidated on the I/O thread.
   base::WeakPtrFactory<RawChannel> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RawChannel);
 };
 
 }  // namespace system
 }  // namespace mojo
 
 #endif  // MOJO_SYSTEM_RAW_CHANNEL_H_