summaryrefslogtreecommitdiffstats
path: root/ipc/ipdl/test/cxx/TestUrgency.cpp
blob: 5845f8210d350ff6c741eedb4f416866b580c65c (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
#include "TestUrgency.h"

#include "IPDLUnitTests.h"  // fail etc.
#if defined(OS_POSIX)
#  include <unistd.h>
#else
#  include <windows.h>
#endif

namespace mozilla {
namespace _ipdltest {

#if defined(OS_POSIX)
static void Sleep(int ms) { sleep(ms / 1000); }
#endif

//-----------------------------------------------------------------------------
// parent

TestUrgencyParent::TestUrgencyParent() : inreply_(false) {
  MOZ_COUNT_CTOR(TestUrgencyParent);
}

TestUrgencyParent::~TestUrgencyParent() { MOZ_COUNT_DTOR(TestUrgencyParent); }

void TestUrgencyParent::Main() {
  if (!SendStart()) fail("sending Start");
}

mozilla::ipc::IPCResult TestUrgencyParent::RecvTest1(uint32_t* value) {
  if (!SendReply1(value)) fail("sending Reply1");
  if (*value != 99) fail("bad value");
  return IPC_OK();
}

mozilla::ipc::IPCResult TestUrgencyParent::RecvTest2() {
  uint32_t value;
  inreply_ = true;
  if (!SendReply2(&value)) fail("sending Reply2");
  inreply_ = false;
  if (value != 500) fail("bad value");
  return IPC_OK();
}

mozilla::ipc::IPCResult TestUrgencyParent::RecvTest3(uint32_t* value) {
  if (inreply_) fail("nested non-urgent on top of urgent rpc");
  *value = 1000;
  return IPC_OK();
}

mozilla::ipc::IPCResult TestUrgencyParent::RecvFinalTest_Begin() {
  return IPC_OK();
}

//-----------------------------------------------------------------------------
// child

enum {
  kFirstTestBegin = 1,
  kFirstTestGotReply,
  kSecondTestBegin,
  kSecondTestGotReply,
};

mozilla::ipc::IPCResult TestUrgencyChild::RecvStart() {
  uint32_t result;

  // Send a synchronous message, expect to get an urgent message while
  // blocked.
  test_ = kFirstTestBegin;
  if (!SendTest1(&result)) fail("calling SendTest1");
  if (result != 99) fail("bad result in RecvStart");
  if (test_ != kFirstTestGotReply) fail("never received urgent message");

  // Initiate the next test by sending an asynchronous message, then becoming
  // blocked. This tests that the urgent message is still delivered properly,
  // and that the parent does not try to service the sync
  test_ = kSecondTestBegin;
  if (!SendTest2()) fail("calling SendTest2");
  if (!SendTest3(&result)) fail("calling SendTest3");
  if (test_ != kSecondTestGotReply) fail("never received urgent message #2");
  if (result != 1000) fail("wrong value from test3");

  if (!SendFinalTest_Begin()) fail("Final test should have succeeded");

  Close();

  return IPC_OK();
}

mozilla::ipc::IPCResult TestUrgencyChild::RecvReply1(uint32_t* reply) {
  if (test_ != kFirstTestBegin) fail("wrong test # in RecvReply1");

  *reply = 99;
  test_ = kFirstTestGotReply;
  return IPC_OK();
}

mozilla::ipc::IPCResult TestUrgencyChild::RecvReply2(uint32_t* reply) {
  if (test_ != kSecondTestBegin) fail("wrong test # in RecvReply2");

  // sleep for 5 seconds so the parent process tries to deliver more messages.
  Sleep(5000);

  *reply = 500;
  test_ = kSecondTestGotReply;
  return IPC_OK();
}

TestUrgencyChild::TestUrgencyChild() : test_(0) {
  MOZ_COUNT_CTOR(TestUrgencyChild);
}

TestUrgencyChild::~TestUrgencyChild() { MOZ_COUNT_DTOR(TestUrgencyChild); }

}  // namespace _ipdltest
}  // namespace mozilla