dbus/test_service.h

   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   // Release the ownership of the well-known name "TestService".
  78   // |callback| will be called when the ownership has been released.
  79   void ReleaseOwnership(base::Closure callback);
  80
  81   // Returns whether this instance has the name ownership or not.
  82   bool has_ownership() const { return has_ownership_; }
  83
  84  private:
  85   // Helper function for SendTestSignal().
  86   void SendTestSignalInternal(const std::string& message);
  87
  88   // Helper function for SendTestSignalFromRoot.
  89   void SendTestSignalFromRootInternal(const std::string& message);
  90
  91   // Helper function for ShutdownAndBlock().
  92   void ShutdownAndBlockInternal();
  93
  94   // Called when an ownership request is completed.
  95   // |callback| is the callback to be called with the result. |service_name| is
  96   // the requested well-known bus name. |callback| and |service_name| are bound
  97   // when the service requests the ownership. |success| is the result of the
  98   // completed request, and is propagated to |callback|.
  99   void OnOwnership(base::Callback<void(bool)> callback,
 100                    const std::string& service_name,
 101                    bool success);
 102
 103   // Called when a method is exported.
 104   void OnExported(const std::string& interface_name,
 105                   const std::string& method_name,
 106                   bool success);
 107
 108   // base::Thread override.
 109   virtual void Run(base::MessageLoop* message_loop) OVERRIDE;
 110
 111   //
 112   // Exported methods.
 113   //
 114
 115   // Echos the text message received from the method call.
 116   void Echo(MethodCall* method_call,
 117             dbus::ExportedObject::ResponseSender response_sender);
 118
 119   // Echos the text message received from the method call, but sleeps for
 120   // TestTimeouts::tiny_timeout_ms() before returning the response.
 121   void SlowEcho(MethodCall* method_call,
 122                 dbus::ExportedObject::ResponseSender response_sender);
 123
 124   // Echos the text message received from the method call, but sends its
 125   // response asynchronously after this callback has returned.
 126   void AsyncEcho(MethodCall* method_call,
 127                  dbus::ExportedObject::ResponseSender response_sender);
 128
 129   // Returns NULL, instead of a valid Response.
 130   void BrokenMethod(MethodCall* method_call,
 131                     dbus::ExportedObject::ResponseSender response_sender);
 132
 133   // Returns a set of property values for testing.
 134   void GetAllProperties(MethodCall* method_call,
 135                         dbus::ExportedObject::ResponseSender response_sender);
 136
 137   // Returns a new value of 20 for the Version property when called.
 138   void GetProperty(MethodCall* method_call,
 139                    dbus::ExportedObject::ResponseSender response_sender);
 140
 141   // Allows the name property to be changed, errors otherwise.
 142   void SetProperty(MethodCall* method_call,
 143                    dbus::ExportedObject::ResponseSender response_sender);
 144
 145   // Performs an action for testing.
 146   void PerformAction(MethodCall* method_call,
 147                      dbus::ExportedObject::ResponseSender response_sender);
 148
 149   // Object Manager: returns the set of objects and properties.
 150   void GetManagedObjects(MethodCall* method_call,
 151                          dbus::ExportedObject::ResponseSender response_sender);
 152
 153   // Add a properties dictionary to a message writer.
 154   void AddPropertiesToWriter(MessageWriter* writer);
 155
 156   // Add a new object to the manager.
 157   void AddObject(const dbus::ObjectPath& object_path);
 158   void AddObjectInternal(const dbus::ObjectPath& object_path);
 159
 160   // Remove an object from the manager.
 161   void RemoveObject(const dbus::ObjectPath& object_path);
 162   void RemoveObjectInternal(const dbus::ObjectPath& object_path);
 163
 164   // Sends a property changed signal for the name property.
 165   void SendPropertyChangedSignal(const std::string& name);
 166
 167   // Helper function for SendPropertyChangedSignal().
 168   void SendPropertyChangedSignalInternal(const std::string& name);
 169
 170   // Helper function for RequestOwnership().
 171   void RequestOwnershipInternal(base::Callback<void(bool)> callback);
 172
 173   // Helper function for ReleaseOwnership().
 174   void ReleaseOwnershipInternal(base::Closure callback);
 175
 176   // Sends the response on completion of the performed action.
 177   void PerformActionResponse(
 178       MethodCall* method_call,
 179       dbus::ExportedObject::ResponseSender response_sender);
 180
 181   // Re-requests ownership of the well-known name after releasing it.
 182   void OwnershipReleased(
 183       MethodCall* method_call,
 184       dbus::ExportedObject::ResponseSender response_sender);
 185
 186   // Sends the action response after regaining the well-known name.
 187   void OwnershipRegained(
 188       MethodCall* method_call,
 189       dbus::ExportedObject::ResponseSender response_sender,
 190       bool success);
 191
 192   // Options to use when requesting service ownership.
 193   Bus::ServiceOwnershipOptions request_ownership_options_;
 194
 195   scoped_refptr<base::SequencedTaskRunner> dbus_task_runner_;
 196   base::WaitableEvent on_name_obtained_;
 197   // The number of methods actually exported.
 198   int num_exported_methods_;
 199
 200   // True iff this instance has successfully acquired the name ownership.
 201   bool has_ownership_;
 202
 203   scoped_refptr<Bus> bus_;
 204   ExportedObject* exported_object_;
 205   ExportedObject* exported_object_manager_;
 206 };
 207
 208 }  // namespace dbus
 209
 210 #endif  // DBUS_TEST_SERVICE_H_