blob: e6139e38c5dd4a7e507ccedac4bf01fa3cbc15f5 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
|
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
* vim: sw=2 ts=4 et :
*/
#include "TestUrgentHangs.h"
#include "IPDLUnitTests.h" // fail etc.
#include "prthread.h"
#if defined(OS_POSIX)
# include <unistd.h>
#else
# include <windows.h>
#endif
namespace mozilla {
namespace _ipdltest {
//-----------------------------------------------------------------------------
// parent
TestUrgentHangsParent::TestUrgentHangsParent()
: mInnerCount(0), mInnerUrgentCount(0) {
MOZ_COUNT_CTOR(TestUrgentHangsParent);
}
TestUrgentHangsParent::~TestUrgentHangsParent() {
MOZ_COUNT_DTOR(TestUrgentHangsParent);
}
void TestUrgentHangsParent::Main() {
SetReplyTimeoutMs(1000);
// Should succeed despite the nested sleep call because the content process
// responded to the transaction.
if (!SendTest1_1()) fail("sending Test1_1");
// Fails with a timeout.
if (SendTest2()) fail("sending Test2");
// Also fails since we haven't gotten a response for Test2 yet.
if (SendTest3()) fail("sending Test3");
// Do a second round of testing once the reply to Test2 comes back.
MessageLoop::current()->PostDelayedTask(
NewNonOwningRunnableMethod(
"_ipdltest::TestUrgentHangsParent::SecondStage", this,
&TestUrgentHangsParent::SecondStage),
3000);
}
void TestUrgentHangsParent::SecondStage() {
// Send an async message that waits 2 seconds and then sends a sync message
// (which should be processed).
if (!SendTest4()) fail("sending Test4");
// Send a sync message that will time out because the child is waiting
// inside RecvTest4.
if (SendTest4_1()) fail("sending Test4_1");
MessageLoop::current()->PostDelayedTask(
NewNonOwningRunnableMethod("_ipdltest::TestUrgentHangsParent::ThirdStage",
this, &TestUrgentHangsParent::ThirdStage),
3000);
}
void TestUrgentHangsParent::ThirdStage() {
// The third stage does the same thing as the second stage except that the
// child sends an urgent message to us. In this case, we actually answer
// that message unconditionally.
// Send an async message that waits 2 seconds and then sends a sync message
// (which should be processed).
if (!SendTest5()) fail("sending Test5");
// Send a sync message that will time out because the child is waiting
// inside RecvTest5.
if (SendTest5_1()) fail("sending Test5_1");
// Close the channel after the child finishes its work in RecvTest5.
MessageLoop::current()->PostDelayedTask(
NewNonOwningRunnableMethod("ipc::IToplevelProtocol::Close", this,
&TestUrgentHangsParent::Close),
3000);
}
mozilla::ipc::IPCResult TestUrgentHangsParent::RecvTest1_2() {
if (!SendTest1_3()) fail("sending Test1_3");
return IPC_OK();
}
mozilla::ipc::IPCResult TestUrgentHangsParent::RecvTestInner() {
mInnerCount++;
return IPC_OK();
}
mozilla::ipc::IPCResult TestUrgentHangsParent::RecvTestInnerUrgent() {
mInnerUrgentCount++;
return IPC_OK();
}
//-----------------------------------------------------------------------------
// child
mozilla::ipc::IPCResult TestUrgentHangsChild::RecvTest1_1() {
if (!SendTest1_2()) fail("sending Test1_2");
return IPC_OK();
}
mozilla::ipc::IPCResult TestUrgentHangsChild::RecvTest1_3() {
PR_Sleep(PR_SecondsToInterval(2));
return IPC_OK();
}
mozilla::ipc::IPCResult TestUrgentHangsChild::RecvTest2() {
PR_Sleep(PR_SecondsToInterval(2));
// Should fail because of the timeout.
if (SendTestInner()) fail("sending TestInner");
return IPC_OK();
}
mozilla::ipc::IPCResult TestUrgentHangsChild::RecvTest3() {
fail("RecvTest3 should never be called");
return IPC_OK();
}
mozilla::ipc::IPCResult TestUrgentHangsChild::RecvTest4() {
PR_Sleep(PR_SecondsToInterval(2));
// This won't fail because we should handle Test4_1 here before actually
// sending TestInner to the parent.
if (!SendTestInner()) fail("sending TestInner");
return IPC_OK();
}
mozilla::ipc::IPCResult TestUrgentHangsChild::RecvTest4_1() {
// This should fail because Test4_1 timed out and hasn't gotten a response
// yet.
if (SendTestInner()) fail("sending TestInner");
return IPC_OK();
}
mozilla::ipc::IPCResult TestUrgentHangsChild::RecvTest5() {
PR_Sleep(PR_SecondsToInterval(2));
// This message will actually be handled by the parent even though it's in
// the timeout state.
if (!SendTestInnerUrgent()) fail("sending TestInner");
return IPC_OK();
}
mozilla::ipc::IPCResult TestUrgentHangsChild::RecvTest5_1() {
// This message will actually be handled by the parent even though it's in
// the timeout state.
if (!SendTestInnerUrgent()) fail("sending TestInner");
return IPC_OK();
}
TestUrgentHangsChild::TestUrgentHangsChild() {
MOZ_COUNT_CTOR(TestUrgentHangsChild);
}
TestUrgentHangsChild::~TestUrgentHangsChild() {
MOZ_COUNT_DTOR(TestUrgentHangsChild);
}
} // namespace _ipdltest
} // namespace mozilla
|
