Add IPC::ChannelProxy::Create() and IPC::SyncChannel::Create()

ipc/ipc_sync_channel_unittest.cc

 // 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.
 
 #include "ipc/ipc_sync_channel.h"
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 133 matching lines @@
     OnDouble(in, &result);
     SyncChannelTestMsg_Double::WriteReplyParams(reply_msg, result);
     Send(reply_msg);
   }
 
   virtual void OnNestedTestMsg(Message* reply_msg) {
     NOTREACHED();
   }
 
   virtual SyncChannel* CreateChannel() {
-    return new SyncChannel(channel_name_,
-                           mode_,
-                           this,
-                           ipc_thread_.message_loop_proxy().get(),
-                           true,
-                           &shutdown_event_);
+    scoped_ptr<SyncChannel> channel = SyncChannel::Create(
+        channel_name_, mode_, this, ipc_thread_.message_loop_proxy().get(),
+        true, &shutdown_event_);
+    return channel.release();
   }
 
   base::Thread* ListenerThread() {
     return overrided_thread_ ? overrided_thread_ : &listener_thread_;
   }
 
   const base::Thread& ipc_thread() const { return ipc_thread_; }
 
  private:
   // Called on the listener thread to create the sync channel.
@@ skipping 147 matching lines @@
   explicit TwoStepServer(bool create_pipe_now)
       : Worker(Channel::MODE_SERVER, "simpler_server"),
         create_pipe_now_(create_pipe_now) { }
 
   virtual void Run() OVERRIDE {
     SendAnswerToLife(false, true);
     Done();
   }
 
   virtual SyncChannel* CreateChannel() OVERRIDE {
-    SyncChannel* channel = new SyncChannel(
-        this, ipc_thread().message_loop_proxy().get(), shutdown_event());
-    channel->Init(channel_name(), mode(), create_pipe_now_);
+    SyncChannel* channel =
+        SyncChannel::Create(channel_name(), mode(), this,
+                            ipc_thread().message_loop_proxy().get(),
+                            create_pipe_now_,
+                            shutdown_event()).release();
     return channel;
   }
 
   bool create_pipe_now_;
 };
 
 class TwoStepClient : public Worker {
  public:
   TwoStepClient(bool create_pipe_now)
       : Worker(Channel::MODE_CLIENT, "simple_client"),
         create_pipe_now_(create_pipe_now) { }
 
   virtual void OnAnswer(int* answer) OVERRIDE {
     *answer = 42;
     Done();
   }
 
   virtual SyncChannel* CreateChannel() OVERRIDE {
-    SyncChannel* channel = new SyncChannel(
-        this, ipc_thread().message_loop_proxy().get(), shutdown_event());
-    channel->Init(channel_name(), mode(), create_pipe_now_);
+    SyncChannel* channel =
+        SyncChannel::Create(channel_name(), mode(), this,
+                            ipc_thread().message_loop_proxy().get(),
+                            create_pipe_now_,
+                            shutdown_event()).release();
     return channel;
   }
 
   bool create_pipe_now_;
 };
 
 void TwoStep(bool create_server_pipe_now, bool create_client_pipe_now) {
   std::vector<Worker*> workers;
   workers.push_back(new TwoStepServer(create_server_pipe_now));
   workers.push_back(new TwoStepClient(create_client_pipe_now));
@@ skipping 767 matching lines @@
 
     server_->ListenerThread()->message_loop()->PostTask(
         FROM_HERE, base::Bind(&RestrictedDispatchServer::OnDoPing, server_, 1));
     sent_ping_event_->Wait();
     Send(new SyncChannelTestMsg_NoArgs);
     if (ping_ == 1)
       ++*success_;
     else
       LOG(ERROR) << "Send failed to dispatch incoming message on same channel";
 
-    non_restricted_channel_.reset(
-        new SyncChannel("non_restricted_channel",
-                        Channel::MODE_CLIENT,
-                        this,
-                        ipc_thread().message_loop_proxy().get(),
-                        true,
-                        shutdown_event()));
+    non_restricted_channel_ =
+        SyncChannel::Create("non_restricted_channel",
+                            IPC::Channel::MODE_CLIENT,
+                            this,
+                            ipc_thread().message_loop_proxy().get(),
+                            true,
+                            shutdown_event());
 
     server_->ListenerThread()->message_loop()->PostTask(
         FROM_HERE, base::Bind(&RestrictedDispatchServer::OnDoPing, server_, 2));
     sent_ping_event_->Wait();
     // Check that the incoming message is *not* dispatched when sending on the
     // non restricted channel.
     // TODO(piman): there is a possibility of a false positive race condition
     // here, if the message that was posted on the server-side end of the pipe
     // is not visible yet on the client side, but I don't know how to solve this
     // without hooking into the internals of SyncChannel. I haven't seen it in
@@ skipping 364 matching lines @@
     other_channel_->Send(new SyncChannelTestMsg_Done);
     other_channel_.reset();
     Done();
   }
 
   virtual void Run() OVERRIDE {
     channel()->SetRestrictDispatchChannelGroup(group_);
     if (is_first())
       event1_->Signal();
     event2_->Wait();
-    other_channel_.reset(
-        new SyncChannel(other_channel_name_,
-                        Channel::MODE_CLIENT,
-                        this,
-                        ipc_thread().message_loop_proxy().get(),
-                        true,
-                        shutdown_event()));
+    other_channel_ =
+        SyncChannel::Create(other_channel_name_,
+                            IPC::Channel::MODE_CLIENT,
+                            this,
+                            ipc_thread().message_loop_proxy().get(),
+                            true,
+                            shutdown_event());
     other_channel_->SetRestrictDispatchChannelGroup(group_);
     if (!is_first()) {
       event1_->Signal();
       return;
     }
     *success_ = 0;
     int value = 0;
     OnPingTTL(3, &value);
     *success_ += (value == 3);
     OnPingTTL(4, &value);
@@ skipping 53 matching lines @@
 // it will send another message to Server2. While sending that second message it
 // will receive a reply from Server1 with the unblock flag.
 
 class ReentrantReplyServer1 : public Worker {
  public:
   ReentrantReplyServer1(WaitableEvent* server_ready)
       : Worker("reentrant_reply1", Channel::MODE_SERVER),
         server_ready_(server_ready) { }
 
   virtual void Run() OVERRIDE {
-    server2_channel_.reset(
-        new SyncChannel("reentrant_reply2",
-                        Channel::MODE_CLIENT,
-                        this,
-                        ipc_thread().message_loop_proxy().get(),
-                        true,
-                        shutdown_event()));
+    server2_channel_ =
+        SyncChannel::Create("reentrant_reply2",
+                            IPC::Channel::MODE_CLIENT,
+                            this,
+                            ipc_thread().message_loop_proxy().get(),
+                            true,
+                            shutdown_event());
     server_ready_->Signal();
     Message* msg = new SyncChannelTestMsg_Reentrant1();
     server2_channel_->Send(msg);
     server2_channel_.reset();
     Done();
   }
 
  private:
   virtual bool OnMessageReceived(const Message& message) OVERRIDE {
     IPC_BEGIN_MESSAGE_MAP(ReentrantReplyServer1, message)
@@ skipping 158 matching lines @@
 }
 
 // Windows needs to send an out-of-band secret to verify the client end of the
 // channel. Test that we still connect correctly in that case.
 TEST_F(IPCSyncChannelTest, Verified) {
   Verified();
 }
 
 }  // namespace
 }  // namespace IPC