Update mojo sdk to rev 3d23dae011859a2aae49f1d1adde705c8e85d819

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"
 #include "base/pickle.h"
+#include "base/run_loop.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/thread.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_test_base.h"
 #include "ipc/ipc_test_channel_listener.h"
 #include "ipc/mojo/ipc_channel_mojo_host.h"
 #include "ipc/mojo/ipc_mojo_handle_attachment.h"
 #include "ipc/mojo/ipc_mojo_message_helper.h"
+#include "ipc/mojo/scoped_ipc_support.h"
 
 #if defined(OS_POSIX)
 #include "base/file_descriptor_posix.h"
 #include "ipc/ipc_platform_file_attachment_posix.h"
 #endif
 
 namespace {
 
 class ListenerThatExpectsOK : public IPC::Listener {
  public:
@@ skipping 26 matching lines @@
     ASSERT_TRUE(sender->Send(message));
   }
 
  private:
   bool received_ok_;
 };
 
 class ChannelClient {
  public:
   explicit ChannelClient(IPC::Listener* listener, const char* name) {
+    ipc_support_.reset(
+        new IPC::ScopedIPCSupport(main_message_loop_.task_runner()));
     channel_ = IPC::ChannelMojo::Create(NULL,
                                         IPCTestBase::GetChannelName(name),
                                         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 IPCChannelMojoTest : public IPCTestBase {
+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::TaskRunner* runner) override {
     host_.reset(new IPC::ChannelMojoHost(task_runner()));
     return IPC::ChannelMojo::CreateServerFactory(host_->channel_delegate(),
                                                  handle);
   }
 
   bool DidStartClient() override {
@@ skipping 21 matching lines @@
     is_connected_called_ = true;
   }
 
   bool is_connected_called() const { return is_connected_called_; }
 
  private:
   bool is_connected_called_;
 };
 
 TEST_F(IPCChannelMojoTest, ConnectedFromClient) {
-  Init("IPCChannelMojoTestClient");
+  InitWithMojo("IPCChannelMojoTestClient");
 
   // Set up IPC channel and start client.
   TestChannelListenerWithExtraExpectations listener;
   CreateChannel(&listener);
   listener.Init(sender());
   ASSERT_TRUE(ConnectChannel());
   ASSERT_TRUE(StartClient());
 
   IPC::TestChannelListener::SendOneMessage(
       sender(), "hello from parent");
@@ skipping 16 matching lines @@
   ChannelClient client(&listener, "IPCChannelMojoTestClient");
   client.Connect();
   listener.Init(client.channel());
 
   IPC::TestChannelListener::SendOneMessage(
       client.channel(), "hello from child");
   base::MessageLoop::current()->Run();
   EXPECT_TRUE(listener.is_connected_called());
   EXPECT_TRUE(listener.HasSentAll());
 
+  client.Close();
+
   return 0;
 }
 
 class ListenerExpectingErrors : public IPC::Listener {
  public:
   ListenerExpectingErrors()
       : has_error_(false) {
   }
 
   void OnChannelConnected(int32 peer_pid) override {
     base::MessageLoop::current()->Quit();
   }
 
   bool OnMessageReceived(const IPC::Message& message) override { return true; }
 
   void OnChannelError() override {
     has_error_ = true;
     base::MessageLoop::current()->Quit();
   }
 
   bool has_error() const { return has_error_; }
 
  private:
   bool has_error_;
 };
 
 
-class IPCChannelMojoErrorTest : public IPCTestBase {
+class IPCChannelMojoErrorTest : public IPCChannelMojoTestBase {
  protected:
   scoped_ptr<IPC::ChannelFactory> CreateChannelFactory(
       const IPC::ChannelHandle& handle,
       base::TaskRunner* runner) override {
     host_.reset(new IPC::ChannelMojoHost(task_runner()));
     return IPC::ChannelMojo::CreateServerFactory(host_->channel_delegate(),
                                                  handle);
   }
 
   bool DidStartClient() override {
@@ skipping 22 matching lines @@
 };
 
 // A long running process that connects to us.
 MULTIPROCESS_IPC_TEST_CLIENT_MAIN(IPCChannelMojoErraticTestClient) {
   ListenerThatQuits listener;
   ChannelClient client(&listener, "IPCChannelMojoErraticTestClient");
   client.Connect();
 
   base::MessageLoop::current()->Run();
 
+  client.Close();
+
   return 0;
 }
 
 TEST_F(IPCChannelMojoErrorTest, SendFailWithPendingMessages) {
-  Init("IPCChannelMojoErraticTestClient");
+  InitWithMojo("IPCChannelMojoErraticTestClient");
 
   // Set up IPC channel and start client.
   ListenerExpectingErrors listener;
   CreateChannel(&listener);
   ASSERT_TRUE(ConnectChannel());
 
   // This matches a value in mojo/edk/system/constants.h
   const int kMaxMessageNumBytes = 4 * 1024 * 1024;
   std::string overly_large_data(kMaxMessageNumBytes, '*');
   // This messages are queued as pending.
@@ skipping 119 matching lines @@
 
   void OnChannelError() override { NOTREACHED(); }
 
   void set_sender(IPC::Sender* sender) { sender_ = sender; }
 
  private:
   IPC::Sender* sender_;
 };
 
 TEST_F(IPCChannelMojoTest, SendMessagePipe) {
-  Init("IPCChannelMojoTestSendMessagePipeClient");
+  InitWithMojo("IPCChannelMojoTestSendMessagePipeClient");
 
   ListenerThatExpectsOK listener;
   CreateChannel(&listener);
   ASSERT_TRUE(ConnectChannel());
   ASSERT_TRUE(StartClient());
 
   TestingMessagePipe pipe;
   HandleSendingHelper::WritePipeThenSend(channel(), &pipe);
 
   base::MessageLoop::current()->Run();
   this->channel()->Close();
 
   EXPECT_TRUE(WaitForClientShutdown());
   DestroyChannel();
 }
 
 MULTIPROCESS_IPC_TEST_CLIENT_MAIN(IPCChannelMojoTestSendMessagePipeClient) {
   ListenerThatExpectsMessagePipe listener;
   ChannelClient client(&listener, "IPCChannelMojoTestSendPlatformHandleClient");
   client.Connect();
   listener.set_sender(client.channel());
 
   base::MessageLoop::current()->Run();
 
+  client.Close();
+
   return 0;
 }
 
 #if defined(OS_WIN)
-class IPCChannelMojoDeadHandleTest : public IPCTestBase {
+class IPCChannelMojoDeadHandleTest : public IPCChannelMojoTestBase {
  protected:
   virtual scoped_ptr<IPC::ChannelFactory> CreateChannelFactory(
       const IPC::ChannelHandle& handle,
       base::TaskRunner* runner) override {
     host_.reset(new IPC::ChannelMojoHost(task_runner()));
     return IPC::ChannelMojo::CreateServerFactory(host_->channel_delegate(),
                                                  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.
     // ::CloseHandle(client);
     host_->OnClientLaunched(client);
     return true;
   }
 
  private:
   scoped_ptr<IPC::ChannelMojoHost> host_;
 };
 
 TEST_F(IPCChannelMojoDeadHandleTest, InvalidClientHandle) {
   // Any client type is fine as it is going to be killed anyway.
-  Init("IPCChannelMojoTestDoNothingClient");
+  InitWithMojo("IPCChannelMojoTestDoNothingClient");
 
   // Set up IPC channel and start client.
   ListenerExpectingErrors listener;
   CreateChannel(&listener);
   ASSERT_TRUE(ConnectChannel());
 
   ASSERT_TRUE(StartClient());
   base::MessageLoop::current()->Run();
 
   this->channel()->Close();
@@ skipping 39 matching lines @@
   }
 
   void set_sender(IPC::Sender* sender) { sender_ = sender; }
 
  private:
   IPC::Sender* sender_;
 };
 
 
 TEST_F(IPCChannelMojoTest, SendPlatformHandle) {
-  Init("IPCChannelMojoTestSendPlatformHandleClient");
+  InitWithMojo("IPCChannelMojoTestSendPlatformHandleClient");
 
   ListenerThatExpectsOK listener;
   CreateChannel(&listener);
   ASSERT_TRUE(ConnectChannel());
   ASSERT_TRUE(StartClient());
 
   base::File file(HandleSendingHelper::GetSendingFilePath(),
                   base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE |
                       base::File::FLAG_READ);
   HandleSendingHelper::WriteFileThenSend(channel(), file);
   base::MessageLoop::current()->Run();
 
   this->channel()->Close();
 
   EXPECT_TRUE(WaitForClientShutdown());
   DestroyChannel();
 }
 
 MULTIPROCESS_IPC_TEST_CLIENT_MAIN(IPCChannelMojoTestSendPlatformHandleClient) {
   ListenerThatExpectsFile listener;
   ChannelClient client(
       &listener, "IPCChannelMojoTestSendPlatformHandleClient");
   client.Connect();
   listener.set_sender(client.channel());
 
   base::MessageLoop::current()->Run();
 
+  client.Close();
+
   return 0;
 }
 
 class ListenerThatExpectsFileAndPipe : public IPC::Listener {
  public:
   ListenerThatExpectsFileAndPipe() : sender_(NULL) {}
 
   ~ListenerThatExpectsFileAndPipe() override {}
 
   bool OnMessageReceived(const IPC::Message& message) override {
     PickleIterator iter(message);
     HandleSendingHelper::ReadReceivedFile(message, &iter);
     HandleSendingHelper::ReadReceivedPipe(message, &iter);
     base::MessageLoop::current()->Quit();
     ListenerThatExpectsOK::SendOK(sender_);
     return true;
   }
 
   void OnChannelError() override { NOTREACHED(); }
 
   void set_sender(IPC::Sender* sender) { sender_ = sender; }
 
  private:
   IPC::Sender* sender_;
 };
 
 TEST_F(IPCChannelMojoTest, SendPlatformHandleAndPipe) {
-  Init("IPCChannelMojoTestSendPlatformHandleAndPipeClient");
+  InitWithMojo("IPCChannelMojoTestSendPlatformHandleAndPipeClient");
 
   ListenerThatExpectsOK listener;
   CreateChannel(&listener);
   ASSERT_TRUE(ConnectChannel());
   ASSERT_TRUE(StartClient());
 
   base::File file(HandleSendingHelper::GetSendingFilePath(),
                   base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE |
                       base::File::FLAG_READ);
   TestingMessagePipe pipe;
   HandleSendingHelper::WriteFileAndPipeThenSend(channel(), file, &pipe);
 
   base::MessageLoop::current()->Run();
   this->channel()->Close();
 
   EXPECT_TRUE(WaitForClientShutdown());
   DestroyChannel();
 }
 
 MULTIPROCESS_IPC_TEST_CLIENT_MAIN(
     IPCChannelMojoTestSendPlatformHandleAndPipeClient) {
   ListenerThatExpectsFileAndPipe listener;
   ChannelClient client(&listener,
                        "IPCChannelMojoTestSendPlatformHandleAndPipeClient");
   client.Connect();
   listener.set_sender(client.channel());
 
   base::MessageLoop::current()->Run();
 
+  client.Close();
+
   return 0;
 }
 
 #endif
 
 #if defined(OS_LINUX)
 
 const base::ProcessId kMagicChildId = 54321;
 
 class ListenerThatVerifiesPeerPid : public IPC::Listener {
  public:
   void OnChannelConnected(int32 peer_pid) override {
     EXPECT_EQ(peer_pid, kMagicChildId);
     base::MessageLoop::current()->Quit();
   }
 
   bool OnMessageReceived(const IPC::Message& message) override {
     NOTREACHED();
     return true;
   }
 };
 
 TEST_F(IPCChannelMojoTest, VerifyGlobalPid) {
-  Init("IPCChannelMojoTestVerifyGlobalPidClient");
+  InitWithMojo("IPCChannelMojoTestVerifyGlobalPidClient");
 
   ListenerThatVerifiesPeerPid listener;
   CreateChannel(&listener);
   ASSERT_TRUE(ConnectChannel());
   ASSERT_TRUE(StartClient());
 
   base::MessageLoop::current()->Run();
-  this->channel()->Close();
+  channel()->Close();
 
   EXPECT_TRUE(WaitForClientShutdown());
   DestroyChannel();
 }
 
 MULTIPROCESS_IPC_TEST_CLIENT_MAIN(IPCChannelMojoTestVerifyGlobalPidClient) {
   IPC::Channel::SetGlobalPid(kMagicChildId);
   ListenerThatQuits listener;
   ChannelClient client(&listener,
                        "IPCChannelMojoTestVerifyGlobalPidClient");
   client.Connect();
 
   base::MessageLoop::current()->Run();
 
+  client.Close();
+
   return 0;
 }
 
 #endif // OS_LINUX
 
 }  // namespace