OLD | NEW |
| (Empty) |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #include <stddef.h> | |
6 #include <memory> | |
7 | |
8 #include "base/memory/ptr_util.h" | |
9 #include "base/run_loop.h" | |
10 #include "base/threading/thread_task_runner_handle.h" | |
11 #include "build/build_config.h" | |
12 #include "ipc/ipc_perftest_support.h" | |
13 #include "ipc/mojo/ipc_channel_mojo.h" | |
14 #include "mojo/edk/embedder/embedder.h" | |
15 #include "mojo/edk/embedder/platform_channel_pair.h" | |
16 #include "mojo/edk/test/multiprocess_test_helper.h" | |
17 #include "mojo/edk/test/scoped_ipc_support.h" | |
18 | |
19 namespace IPC { | |
20 namespace { | |
21 | |
22 class MojoChannelPerfTest : public test::IPCChannelPerfTestBase { | |
23 public: | |
24 void TearDown() override { | |
25 ipc_support_.reset(); | |
26 test::IPCChannelPerfTestBase::TearDown(); | |
27 } | |
28 | |
29 std::unique_ptr<ChannelFactory> CreateChannelFactory( | |
30 const ChannelHandle& handle, | |
31 base::SequencedTaskRunner* runner) override { | |
32 ipc_support_.reset(new mojo::edk::test::ScopedIPCSupport(io_task_runner())); | |
33 return ChannelMojo::CreateServerFactory( | |
34 helper_.StartChild("MojoPerfTestClient")); | |
35 } | |
36 | |
37 bool StartClient() override { | |
38 return true; | |
39 } | |
40 | |
41 bool WaitForClientShutdown() override { | |
42 return helper_.WaitForChildTestShutdown(); | |
43 } | |
44 | |
45 mojo::edk::test::MultiprocessTestHelper helper_; | |
46 std::unique_ptr<mojo::edk::test::ScopedIPCSupport> ipc_support_; | |
47 }; | |
48 | |
49 TEST_F(MojoChannelPerfTest, ChannelPingPong) { | |
50 RunTestChannelPingPong(GetDefaultTestParams()); | |
51 | |
52 base::RunLoop run_loop; | |
53 run_loop.RunUntilIdle(); | |
54 } | |
55 | |
56 TEST_F(MojoChannelPerfTest, ChannelProxyPingPong) { | |
57 RunTestChannelProxyPingPong(GetDefaultTestParams()); | |
58 | |
59 base::RunLoop run_loop; | |
60 run_loop.RunUntilIdle(); | |
61 } | |
62 | |
63 // Test to see how many channels we can create. | |
64 TEST_F(MojoChannelPerfTest, DISABLED_MaxChannelCount) { | |
65 #if defined(OS_POSIX) | |
66 LOG(INFO) << "base::GetMaxFds " << base::GetMaxFds(); | |
67 base::SetFdLimit(20000); | |
68 #endif | |
69 | |
70 std::vector<mojo::edk::PlatformChannelPair*> channels; | |
71 for (size_t i = 0; i < 10000; ++i) { | |
72 LOG(INFO) << "channels size: " << channels.size(); | |
73 channels.push_back(new mojo::edk::PlatformChannelPair()); | |
74 } | |
75 } | |
76 | |
77 class MojoPerfTestClient : public test::PingPongTestClient { | |
78 public: | |
79 typedef test::PingPongTestClient SuperType; | |
80 | |
81 MojoPerfTestClient(); | |
82 | |
83 std::unique_ptr<Channel> CreateChannel(Listener* listener) override; | |
84 | |
85 int Run(MojoHandle handle); | |
86 | |
87 private: | |
88 mojo::edk::test::ScopedIPCSupport ipc_support_; | |
89 mojo::ScopedMessagePipeHandle handle_; | |
90 }; | |
91 | |
92 MojoPerfTestClient::MojoPerfTestClient() | |
93 : ipc_support_(base::ThreadTaskRunnerHandle::Get()) { | |
94 mojo::edk::test::MultiprocessTestHelper::ChildSetup(); | |
95 } | |
96 | |
97 std::unique_ptr<Channel> MojoPerfTestClient::CreateChannel(Listener* listener) { | |
98 return ChannelMojo::Create(std::move(handle_), Channel::MODE_CLIENT, | |
99 listener); | |
100 } | |
101 | |
102 int MojoPerfTestClient::Run(MojoHandle handle) { | |
103 handle_ = mojo::MakeScopedHandle(mojo::MessagePipeHandle(handle)); | |
104 return RunMain(); | |
105 } | |
106 | |
107 MULTIPROCESS_TEST_MAIN(MojoPerfTestClientTestChildMain) { | |
108 MojoPerfTestClient client; | |
109 int rv = mojo::edk::test::MultiprocessTestHelper::RunClientMain( | |
110 base::Bind(&MojoPerfTestClient::Run, base::Unretained(&client))); | |
111 | |
112 base::RunLoop run_loop; | |
113 run_loop.RunUntilIdle(); | |
114 | |
115 return rv; | |
116 } | |
117 | |
118 } // namespace | |
119 } // namespace IPC | |
OLD | NEW |