Introduce IPC::ChannelProxy::Create*() and IPC::SynChannel::Create*()

ipc/ipc_channel_proxy.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_PROXY_H_
 #define IPC_IPC_CHANNEL_PROXY_H_
 
 #include <vector>
 
 #include "base/memory/ref_counted.h"
@@ skipping 46 matching lines @@
 class IPC_EXPORT ChannelProxy : public Sender, public base::NonThreadSafe {
  public:
   // Initializes a channel proxy.  The channel_handle and mode parameters are
   // passed directly to the underlying IPC::Channel.  The listener is called on
   // the thread that creates the ChannelProxy.  The filter's OnMessageReceived
   // method is called on the thread where the IPC::Channel is running.  The
   // filter may be null if the consumer is not interested in handling messages
   // on the background thread.  Any message not handled by the filter will be
   // dispatched to the listener.  The given task runner correspond to a thread
   // on which IPC::Channel is created and used (e.g. IO thread).
-  ChannelProxy(const IPC::ChannelHandle& channel_handle,
-               Channel::Mode mode,
-               Listener* listener,
-               base::SingleThreadTaskRunner* ipc_task_runner);
+  // The naming pattern follows IPC::Channel. The Create() does not create
+  // underlying channel and let Init*() do it.
+  static scoped_ptr<ChannelProxy> Create(
+      Listener* listener,
+      base::SingleThreadTaskRunner* ipc_task_runner);
+
+  static scoped_ptr<ChannelProxy> CreateClient(
+      const IPC::ChannelHandle& channel_handle,
+      Listener* listener,
+      base::SingleThreadTaskRunner* ipc_task_runner);
+
+  static scoped_ptr<ChannelProxy> CreateServer(
+      const IPC::ChannelHandle& channel_handle,
+      Listener* listener,
+      base::SingleThreadTaskRunner* ipc_task_runner);
+
+  static scoped_ptr<ChannelProxy> CreateNamedClient(
+      const IPC::ChannelHandle& channel_handle,
+      Listener* listener,
+      base::SingleThreadTaskRunner* ipc_task_runner);
+
+  static scoped_ptr<ChannelProxy> CreateNamedServer(
+      const IPC::ChannelHandle& channel_handle,
+      Listener* listener,
+      base::SingleThreadTaskRunner* ipc_task_runner);
 
   virtual ~ChannelProxy();
 
   // Initializes the channel proxy. Only call this once to initialize a channel
   // proxy that was not initialized in its constructor. If create_pipe_now is
   // true, the pipe is created synchronously. Otherwise it's created on the IO
   // thread.
-  void Init(const IPC::ChannelHandle& channel_handle, Channel::Mode mode,
-            bool create_pipe_now);
+  // The naming pattern follows IPC::Channel::Create*().
+  void InitByMode(const IPC::ChannelHandle& channel_handle, Channel::Mode mode,
+                  bool create_pipe_now);
+  void InitClient(const IPC::ChannelHandle& channel_handle,
+                  bool create_pipe_now);
+  void InitServer(const IPC::ChannelHandle& channel_handle,
+                  bool create_pipe_now);
+  void InitNamedClient(const IPC::ChannelHandle& channel_handle,
+                       bool create_pipe_now);
+  void InitNamedServer(const IPC::ChannelHandle& channel_handle,
+                       bool create_pipe_now);
 
   // Close the IPC::Channel.  This operation completes asynchronously, once the
   // background thread processes the command to close the channel.  It is ok to
   // call this method multiple times.  Redundant calls are ignored.
   //
   // WARNING: MessageFilter objects held by the ChannelProxy is also
   // released asynchronously, and it may in fact have its final reference
   // released on the background thread.  The caller should be careful to deal
   // with / allow for this possibility.
   void Close();
@@ skipping 27 matching lines @@
   int TakeClientFileDescriptor();
   bool GetPeerEuid(uid_t* peer_euid) const;
 #endif  // defined(OS_POSIX)
 
  protected:
   class Context;
   // A subclass uses this constructor if it needs to add more information
   // to the internal state.
   ChannelProxy(Context* context);
 
+  ChannelProxy(Listener* listener,
+               base::SingleThreadTaskRunner* ipc_task_runner);
+
+
   // Used internally to hold state that is referenced on the IPC thread.
   class Context : public base::RefCountedThreadSafe<Context>,
                   public Listener {
    public:
     Context(Listener* listener, base::SingleThreadTaskRunner* ipc_thread);
     void ClearIPCTaskRunner();
     base::SingleThreadTaskRunner* ipc_task_runner() const {
       return ipc_task_runner_.get();
     }
     const std::string& channel_id() const { return channel_id_; }
@@ skipping 84 matching lines @@
   // that involves this data.
   scoped_refptr<Context> context_;
 
   // Whether the channel has been initialized.
   bool did_init_;
 };
 
 }  // namespace IPC
 
 #endif  // IPC_IPC_CHANNEL_PROXY_H_