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
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
|
// Copyright (c) 2012 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.
#ifndef DBUS_TEST_SERVICE_H_
#define DBUS_TEST_SERVICE_H_
#include "base/compiler_specific.h"
#include "base/memory/ref_counted.h"
#include "base/threading/thread.h"
#include "base/synchronization/waitable_event.h"
#include "dbus/bus.h"
#include "dbus/exported_object.h"
namespace base {
class SequencedTaskRunner;
}
namespace dbus {
class MethodCall;
class MessageWriter;
class Response;
// The test service is used for end-to-end tests. The service runs in a
// separate thread, so it does not interfere the test code that runs in
// the main thread.
//
// The test service exports an object with methods such as Echo() and
// SlowEcho(). The object has ability to send "Test" signal.
class TestService : public base::Thread {
public:
// Options for the test service.
struct Options {
Options();
~Options();
// NULL by default (i.e. don't use the D-Bus thread).
scoped_refptr<base::SequencedTaskRunner> dbus_task_runner;
// Flags governing parameters of service ownership request.
Bus::ServiceOwnershipOptions request_ownership_options;
};
// The number of methods we'll export.
static const int kNumMethodsToExport;
explicit TestService(const Options& options);
virtual ~TestService();
// Starts the service in a separate thread.
// Returns true if the thread is started successfully.
bool StartService();
// Waits until the service is started (i.e. all methods are exported).
// Returns true on success.
bool WaitUntilServiceIsStarted() WARN_UNUSED_RESULT;
// Shuts down the service and blocks until it's done.
void ShutdownAndBlock();
// Returns true if the bus has the D-Bus thread.
bool HasDBusThread();
// Sends "Test" signal with the given message from the exported object.
void SendTestSignal(const std::string& message);
// Sends "Test" signal with the given message from the root object ("/").
// This function emulates dbus-send's behavior.
void SendTestSignalFromRoot(const std::string& message);
// Request the ownership of a well-known name "TestService".
// |callback| will be called with the result when an ownership request is
// completed.
void RequestOwnership(base::Callback<void(bool)> callback);
// Release the ownership of the well-known name "TestService".
// |callback| will be called when the ownership has been released.
void ReleaseOwnership(base::Closure callback);
// Returns whether this instance has the name ownership or not.
bool has_ownership() const { return has_ownership_; }
private:
// Helper function for SendTestSignal().
void SendTestSignalInternal(const std::string& message);
// Helper function for SendTestSignalFromRoot.
void SendTestSignalFromRootInternal(const std::string& message);
// Helper function for ShutdownAndBlock().
void ShutdownAndBlockInternal();
// Called when an ownership request is completed.
// |callback| is the callback to be called with the result. |service_name| is
// the requested well-known bus name. |callback| and |service_name| are bound
// when the service requests the ownership. |success| is the result of the
// completed request, and is propagated to |callback|.
void OnOwnership(base::Callback<void(bool)> callback,
const std::string& service_name,
bool success);
// Called when a method is exported.
void OnExported(const std::string& interface_name,
const std::string& method_name,
bool success);
// base::Thread override.
virtual void Run(base::MessageLoop* message_loop) OVERRIDE;
//
// Exported methods.
//
// Echos the text message received from the method call.
void Echo(MethodCall* method_call,
dbus::ExportedObject::ResponseSender response_sender);
// Echos the text message received from the method call, but sleeps for
// TestTimeouts::tiny_timeout_ms() before returning the response.
void SlowEcho(MethodCall* method_call,
dbus::ExportedObject::ResponseSender response_sender);
// Echos the text message received from the method call, but sends its
// response asynchronously after this callback has returned.
void AsyncEcho(MethodCall* method_call,
dbus::ExportedObject::ResponseSender response_sender);
// Returns NULL, instead of a valid Response.
void BrokenMethod(MethodCall* method_call,
dbus::ExportedObject::ResponseSender response_sender);
// Returns a set of property values for testing.
void GetAllProperties(MethodCall* method_call,
dbus::ExportedObject::ResponseSender response_sender);
// Returns a new value of 20 for the Version property when called.
void GetProperty(MethodCall* method_call,
dbus::ExportedObject::ResponseSender response_sender);
// Allows the name property to be changed, errors otherwise.
void SetProperty(MethodCall* method_call,
dbus::ExportedObject::ResponseSender response_sender);
// Performs an action for testing.
void PerformAction(MethodCall* method_call,
dbus::ExportedObject::ResponseSender response_sender);
// Object Manager: returns the set of objects and properties.
void GetManagedObjects(MethodCall* method_call,
dbus::ExportedObject::ResponseSender response_sender);
// Add a properties dictionary to a message writer.
void AddPropertiesToWriter(MessageWriter* writer);
// Add a new object to the manager.
void AddObject(const dbus::ObjectPath& object_path);
void AddObjectInternal(const dbus::ObjectPath& object_path);
// Remove an object from the manager.
void RemoveObject(const dbus::ObjectPath& object_path);
void RemoveObjectInternal(const dbus::ObjectPath& object_path);
// Sends a property changed signal for the name property.
void SendPropertyChangedSignal(const std::string& name);
// Helper function for SendPropertyChangedSignal().
void SendPropertyChangedSignalInternal(const std::string& name);
// Helper function for RequestOwnership().
void RequestOwnershipInternal(base::Callback<void(bool)> callback);
// Helper function for ReleaseOwnership().
void ReleaseOwnershipInternal(base::Closure callback);
// Sends the response on completion of the performed action.
void PerformActionResponse(
MethodCall* method_call,
dbus::ExportedObject::ResponseSender response_sender);
// Re-requests ownership of the well-known name after releasing it.
void OwnershipReleased(
MethodCall* method_call,
dbus::ExportedObject::ResponseSender response_sender);
// Sends the action response after regaining the well-known name.
void OwnershipRegained(
MethodCall* method_call,
dbus::ExportedObject::ResponseSender response_sender,
bool success);
// Options to use when requesting service ownership.
Bus::ServiceOwnershipOptions request_ownership_options_;
scoped_refptr<base::SequencedTaskRunner> dbus_task_runner_;
base::WaitableEvent on_name_obtained_;
// The number of methods actually exported.
int num_exported_methods_;
// True iff this instance has successfully acquired the name ownership.
bool has_ownership_;
scoped_refptr<Bus> bus_;
ExportedObject* exported_object_;
ExportedObject* exported_object_manager_;
};
} // namespace dbus
#endif // DBUS_TEST_SERVICE_H_
|
