Revert of ChannelMojo: Ensure that it always has ScopedIPCSupport

ipc/mojo/ipc_channel_mojo_unittest.cc

 // Copyright 2014 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/mojo/ipc_channel_mojo.h"
 
 #include "base/base_paths.h"
 #include "base/files/file.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
@@ skipping 48 matching lines @@
     ASSERT_TRUE(sender->Send(message));
   }
 
  private:
   bool received_ok_;
 };
 
 class ChannelClient {
  public:
   explicit ChannelClient(IPC::Listener* listener, const char* name) {
-    channel_ = IPC::ChannelMojo::Create(NULL, main_message_loop_.task_runner(),
+    ipc_support_.reset(
+        new IPC::ScopedIPCSupport(main_message_loop_.task_runner()));
+    channel_ = IPC::ChannelMojo::Create(NULL,
                                         IPCTestBase::GetChannelName(name),
-                                        IPC::Channel::MODE_CLIENT, listener);
+                                        IPC::Channel::MODE_CLIENT,
+                                        listener);
   }
 
   void Connect() {
     CHECK(channel_->Connect());
   }
 
   void Close() {
     channel_->Close();
 
     base::RunLoop run_loop;
     base::MessageLoop::current()->PostTask(FROM_HERE, run_loop.QuitClosure());
     run_loop.Run();
   }
 
   IPC::ChannelMojo* channel() const { return channel_.get(); }
 
  private:
   base::MessageLoopForIO main_message_loop_;
+  scoped_ptr<IPC::ScopedIPCSupport> ipc_support_;
   scoped_ptr<IPC::ChannelMojo> channel_;
 };
 
 class IPCChannelMojoTestBase : public IPCTestBase {
  public:
   void InitWithMojo(const std::string& test_client_name) {
     Init(test_client_name);
+    ipc_support_.reset(new IPC::ScopedIPCSupport(task_runner()));
   }
 
   void TearDown() override {
     // Make sure Mojo IPC support is properly shutdown on the I/O loop before
     // TearDown continues.
+    ipc_support_.reset();
     base::RunLoop run_loop;
     task_runner()->PostTask(FROM_HERE, run_loop.QuitClosure());
     run_loop.Run();
 
     IPCTestBase::TearDown();
   }
+
+ private:
+  scoped_ptr<IPC::ScopedIPCSupport> ipc_support_;
 };
 
 class IPCChannelMojoTest : public IPCChannelMojoTestBase {
  protected:
   scoped_ptr<IPC::ChannelFactory> CreateChannelFactory(
       const IPC::ChannelHandle& handle,
       base::SequencedTaskRunner* runner) override {
     host_.reset(new IPC::ChannelMojoHost(task_runner()));
     return IPC::ChannelMojo::CreateServerFactory(host_->channel_delegate(),
-                                                 task_runner(), handle);
+                                                 handle);
   }
 
   bool DidStartClient() override {
     bool ok = IPCTestBase::DidStartClient();
     DCHECK(ok);
     host_->OnClientLaunched(client_process().Handle());
     return ok;
   }
 
  private:
@@ skipping 87 matching lines @@
 };
 
 
 class IPCChannelMojoErrorTest : public IPCChannelMojoTestBase {
  protected:
   scoped_ptr<IPC::ChannelFactory> CreateChannelFactory(
       const IPC::ChannelHandle& handle,
       base::SequencedTaskRunner* runner) override {
     host_.reset(new IPC::ChannelMojoHost(task_runner()));
     return IPC::ChannelMojo::CreateServerFactory(host_->channel_delegate(),
-                                                 task_runner(), handle);
+                                                 handle);
   }
 
   bool DidStartClient() override {
     bool ok = IPCTestBase::DidStartClient();
     DCHECK(ok);
     host_->OnClientLaunched(client_process().Handle());
     return ok;
   }
 
  private:
@@ skipping 313 matching lines @@
 }
 
 #if defined(OS_WIN)
 class IPCChannelMojoDeadHandleTest : public IPCChannelMojoTestBase {
  protected:
   virtual scoped_ptr<IPC::ChannelFactory> CreateChannelFactory(
       const IPC::ChannelHandle& handle,
       base::SequencedTaskRunner* runner) override {
     host_.reset(new IPC::ChannelMojoHost(task_runner()));
     return IPC::ChannelMojo::CreateServerFactory(host_->channel_delegate(),
-                                                 task_runner(), handle);
+                                                 handle);
   }
 
   virtual bool DidStartClient() override {
     IPCTestBase::DidStartClient();
     const base::ProcessHandle client = client_process().Handle();
     // Forces GetFileHandleForProcess() fail. It happens occasionally
     // in production, so we should exercise it somehow.
     // TODO(morrita): figure out how to safely test this. See crbug.com/464109.
     // ::CloseHandle(client);
     host_->OnClientLaunched(client);
@@ skipping 204 matching lines @@
   base::MessageLoop::current()->Run();
 
   client.Close();
 
   return 0;
 }
 
 #endif // OS_LINUX
 
 }  // namespace