Introduce IPC::Channel::Create*() to ensure it being heap-allocated.

ipc/ipc_channel.h

 // Copyright (c) 2012 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 IPC_IPC_CHANNEL_H_
 #define IPC_IPC_CHANNEL_H_
 
 #include <string>
 
 #if defined(OS_POSIX)
@@ skipping 37 matching lines @@
     MODE_NO_FLAG = 0x0,
     MODE_SERVER_FLAG = 0x1,
     MODE_CLIENT_FLAG = 0x2,
     MODE_NAMED_FLAG = 0x4,
 #if defined(OS_POSIX)
     MODE_OPEN_ACCESS_FLAG = 0x8, // Don't restrict access based on client UID.
 #endif
   };
 
   // Some Standard Modes
+  // TODO(morrita): These are under deprecation work. You should use Create*()
+  // functions instead.
   enum Mode {
     MODE_NONE = MODE_NO_FLAG,
     MODE_SERVER = MODE_SERVER_FLAG,
     MODE_CLIENT = MODE_CLIENT_FLAG,
-    // Channels on Windows are named by default and accessible from other
-    // processes. On POSIX channels are anonymous by default and not accessible
-    // from other processes. Named channels work via named unix domain sockets.
-    // On Windows MODE_NAMED_SERVER is equivalent to MODE_SERVER and
-    // MODE_NAMED_CLIENT is equivalent to MODE_CLIENT.
     MODE_NAMED_SERVER = MODE_SERVER_FLAG | MODE_NAMED_FLAG,
     MODE_NAMED_CLIENT = MODE_CLIENT_FLAG | MODE_NAMED_FLAG,
 #if defined(OS_POSIX)
-    // An "open" named server accepts connections from ANY client.
-    // The caller must then implement their own access-control based on the
-    // client process' user Id.
     MODE_OPEN_NAMED_SERVER = MODE_OPEN_ACCESS_FLAG | MODE_SERVER_FLAG |
                              MODE_NAMED_FLAG
 #endif
   };
 
   // Messages internal to the IPC implementation are defined here.
   // Uses Maximum value of message type (uint16), to avoid conflicting
   // with normal message types, which are enumeration constants starting from 0.
   enum {
     // The Hello message is sent by the peer when the channel is connected.
@@ skipping 16 matching lines @@
 
   // Amount of data to read at once from the pipe.
   static const size_t kReadBufferSize = 4 * 1024;
 
   // Initialize a Channel.
   //
   // |channel_handle| identifies the communication Channel. For POSIX, if
   // the file descriptor in the channel handle is != -1, the channel takes
   // ownership of the file descriptor and will close it appropriately, otherwise
   // it will create a new descriptor internally.
-  // |mode| specifies whether this Channel is to operate in server mode or
-  // client mode.  In server mode, the Channel is responsible for setting up the
-  // IPC object, whereas in client mode, the Channel merely connects to the
-  // already established IPC object.
   // |listener| receives a callback on the current thread for each newly
   // received message.
   //
-  Channel(const IPC::ChannelHandle &channel_handle, Mode mode,
-          Listener* listener);
+  // There are four type of modes how channels operate:
+  //
+  // - Server and named server: In these modes, the Channel is
+  //   responsible for settingb up the IPC object
+  // - An "open" named server: It accepts connections from ANY client.
+  //   The caller must then implement their own access-control based on the
+  //   client process' user Id.
+  // - Client and named client: In these mode, the Channel merely
+  //   connects to the already established IPC object.
+  //
+  // Each mode has its own Create*() API to create the Channel object.
+  //
+  // TODO(morrita): Replace CreateByModeForProxy() with one of above Create*().
+  //
+  static scoped_ptr<Channel> CreateByModeForProxy(
+      const IPC::ChannelHandle &channel_handle, Mode mode,Listener* listener);
+  static scoped_ptr<Channel> CreateClient(
+      const IPC::ChannelHandle &channel_handle, Listener* listener);
+
+  // Channels on Windows are named by default and accessible from other
+  // processes. On POSIX channels are anonymous by default and not accessible
+  // from other processes. Named channels work via named unix domain sockets.
+  // On Windows MODE_NAMED_SERVER is equivalent to MODE_SERVER and
+  // MODE_NAMED_CLIENT is equivalent to MODE_CLIENT.
+  static scoped_ptr<Channel> CreateNamedServer(
+      const IPC::ChannelHandle &channel_handle, Listener* listener);
+  static scoped_ptr<Channel> CreateNamedClient(
+      const IPC::ChannelHandle &channel_handle, Listener* listener);
+#if defined(OS_POSIX)
+  // An "open" named server accepts connections from ANY client.
+  // The caller must then implement their own access-control based on the
+  // client process' user Id.
+  static scoped_ptr<Channel> CreateOpenNamedServer(
+      const IPC::ChannelHandle &channel_handle, Listener* listener);
+#endif
+  static scoped_ptr<Channel> CreateServer(
+      const IPC::ChannelHandle &channel_handle, Listener* listener);
+
 
   virtual ~Channel();
 
   // Connect the pipe.  On the server side, this will initiate
   // waiting for connections.  On the client, it attempts to
   // connect to a pre-existing pipe.  Note, calling Connect()
   // will not block the calling thread and may complete
   // asynchronously.
   bool Connect() WARN_UNUSED_RESULT;
 
@@ skipping 85 matching lines @@
 #endif
 
  protected:
   // Used in Chrome by the TestSink to provide a dummy channel implementation
   // for testing. TestSink overrides the "interesting" functions in Channel so
   // no actual implementation is needed. This will cause un-overridden calls to
   // segfault. Do not use outside of test code!
   Channel() : channel_impl_(0) { }
 
  private:
+  Channel(const IPC::ChannelHandle &channel_handle, Mode mode,
+          Listener* listener);
+
   // PIMPL to which all channel calls are delegated.
   class ChannelImpl;
   ChannelImpl *channel_impl_;
 };
 
 #if defined(OS_POSIX)
 // SocketPair() creates a pair of socket FDs suitable for using with
 // IPC::Channel.
 IPC_EXPORT bool SocketPair(int* fd1, int* fd2);
 #endif
 
 }  // namespace IPC
 
 #endif  // IPC_IPC_CHANNEL_H_