1 // Copyright (c) 2012 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 #ifndef DBUS_TEST_SERVICE_H_ 6 #define DBUS_TEST_SERVICE_H_ 7 8 #include "base/compiler_specific.h" 9 #include "base/memory/ref_counted.h" 10 #include "base/threading/thread.h" 11 #include "base/synchronization/waitable_event.h" 12 #include "dbus/bus.h" 13 #include "dbus/exported_object.h" 14 15 namespace base { 16 class SequencedTaskRunner; 17 } 18 19 namespace dbus { 20 21 class MethodCall; 22 class MessageWriter; 23 class Response; 24 25 // The test service is used for end-to-end tests. The service runs in a 26 // separate thread, so it does not interfere the test code that runs in 27 // the main thread. 28 // 29 // The test service exports an object with methods such as Echo() and 30 // SlowEcho(). The object has ability to send "Test" signal. 31 class TestService : public base::Thread { 32 public: 33 // Options for the test service. 34 struct Options { 35 Options(); 36 ~Options(); 37 38 // NULL by default (i.e. don't use the D-Bus thread). 39 scoped_refptr<base::SequencedTaskRunner> dbus_task_runner; 40 41 // Flags governing parameters of service ownership request. 42 Bus::ServiceOwnershipOptions request_ownership_options; 43 }; 44 45 // The number of methods we'll export. 46 static const int kNumMethodsToExport; 47 48 explicit TestService(const Options& options); 49 virtual ~TestService(); 50 51 // Starts the service in a separate thread. 52 // Returns true if the thread is started successfully. 53 bool StartService(); 54 55 // Waits until the service is started (i.e. all methods are exported). 56 // Returns true on success. 57 bool WaitUntilServiceIsStarted() WARN_UNUSED_RESULT; 58 59 // Shuts down the service and blocks until it's done. 60 void ShutdownAndBlock(); 61 62 // Returns true if the bus has the D-Bus thread. 63 bool HasDBusThread(); 64 65 // Sends "Test" signal with the given message from the exported object. 66 void SendTestSignal(const std::string& message); 67 68 // Sends "Test" signal with the given message from the root object ("/"). 69 // This function emulates dbus-send's behavior. 70 void SendTestSignalFromRoot(const std::string& message); 71 72 // Request the ownership of a well-known name "TestService". 73 // |callback| will be called with the result when an ownership request is 74 // completed. 75 void RequestOwnership(base::Callback<void(bool)> callback); 76 77 // Returns whether this instance has the name ownership or not. has_ownership()78 bool has_ownership() const { return has_ownership_; } 79 80 private: 81 // Helper function for SendTestSignal(). 82 void SendTestSignalInternal(const std::string& message); 83 84 // Helper function for SendTestSignalFromRoot. 85 void SendTestSignalFromRootInternal(const std::string& message); 86 87 // Helper function for ShutdownAndBlock(). 88 void ShutdownAndBlockInternal(); 89 90 // Called when an ownership request is completed. 91 // |callback| is the callback to be called with the result. |service_name| is 92 // the requested well-known bus name. |callback| and |service_name| are bound 93 // when the service requests the ownership. |success| is the result of the 94 // completed request, and is propagated to |callback|. 95 void OnOwnership(base::Callback<void(bool)> callback, 96 const std::string& service_name, 97 bool success); 98 99 // Called when a method is exported. 100 void OnExported(const std::string& interface_name, 101 const std::string& method_name, 102 bool success); 103 104 // base::Thread override. 105 virtual void Run(base::MessageLoop* message_loop) OVERRIDE; 106 107 // 108 // Exported methods. 109 // 110 111 // Echos the text message received from the method call. 112 void Echo(MethodCall* method_call, 113 dbus::ExportedObject::ResponseSender response_sender); 114 115 // Echos the text message received from the method call, but sleeps for 116 // TestTimeouts::tiny_timeout_ms() before returning the response. 117 void SlowEcho(MethodCall* method_call, 118 dbus::ExportedObject::ResponseSender response_sender); 119 120 // Echos the text message received from the method call, but sends its 121 // response asynchronously after this callback has returned. 122 void AsyncEcho(MethodCall* method_call, 123 dbus::ExportedObject::ResponseSender response_sender); 124 125 // Returns NULL, instead of a valid Response. 126 void BrokenMethod(MethodCall* method_call, 127 dbus::ExportedObject::ResponseSender response_sender); 128 129 // Returns a set of property values for testing. 130 void GetAllProperties(MethodCall* method_call, 131 dbus::ExportedObject::ResponseSender response_sender); 132 133 // Returns a new value of 20 for the Version property when called. 134 void GetProperty(MethodCall* method_call, 135 dbus::ExportedObject::ResponseSender response_sender); 136 137 // Allows the name property to be changed, errors otherwise. 138 void SetProperty(MethodCall* method_call, 139 dbus::ExportedObject::ResponseSender response_sender); 140 141 // Performs an action for testing. 142 void PerformAction(MethodCall* method_call, 143 dbus::ExportedObject::ResponseSender response_sender); 144 145 // Object Manager: returns the set of objects and properties. 146 void GetManagedObjects(MethodCall* method_call, 147 dbus::ExportedObject::ResponseSender response_sender); 148 149 // Add a properties dictionary to a message writer. 150 void AddPropertiesToWriter(MessageWriter* writer); 151 152 // Add a new object to the manager. 153 void AddObject(const dbus::ObjectPath& object_path); 154 void AddObjectInternal(const dbus::ObjectPath& object_path); 155 156 // Remove an object from the manager. 157 void RemoveObject(const dbus::ObjectPath& object_path); 158 void RemoveObjectInternal(const dbus::ObjectPath& object_path); 159 160 // Sends a property changed signal for the name property. 161 void SendPropertyChangedSignal(const std::string& name); 162 163 // Helper function for SendPropertyChangedSignal(). 164 void SendPropertyChangedSignalInternal(const std::string& name); 165 166 // Helper function for RequestOwnership(). 167 void RequestOwnershipInternal(base::Callback<void(bool)> callback); 168 169 // Options to use when requesting service ownership. 170 Bus::ServiceOwnershipOptions request_ownership_options_; 171 172 scoped_refptr<base::SequencedTaskRunner> dbus_task_runner_; 173 base::WaitableEvent on_all_methods_exported_; 174 // The number of methods actually exported. 175 int num_exported_methods_; 176 177 // True iff this instance has successfully acquired the name ownership. 178 bool has_ownership_; 179 180 scoped_refptr<Bus> bus_; 181 ExportedObject* exported_object_; 182 ExportedObject* exported_object_manager_; 183 }; 184 185 } // namespace dbus 186 187 #endif // DBUS_TEST_SERVICE_H_ 188