keybuk@google.com | bf4649a | 2012-02-15 06:29:06 +0900 | [diff] [blame] | 1 | // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
satorux@chromium.org | 163f1cb | 2011-08-18 05:58:12 +0900 | [diff] [blame] | 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
| 4 | |
| 5 | #include "dbus/exported_object.h" |
| 6 | |
avi | 0ad0ce0 | 2015-12-23 03:12:45 +0900 | [diff] [blame] | 7 | #include <stdint.h> |
dcheng | 6c1ffcf | 2015-12-28 11:24:50 +0900 | [diff] [blame] | 8 | #include <utility> |
avi | 0ad0ce0 | 2015-12-23 03:12:45 +0900 | [diff] [blame] | 9 | |
satorux@chromium.org | 163f1cb | 2011-08-18 05:58:12 +0900 | [diff] [blame] | 10 | #include "base/bind.h" |
| 11 | #include "base/logging.h" |
| 12 | #include "base/memory/ref_counted.h" |
avi@chromium.org | a29af56 | 2013-07-18 08:00:30 +0900 | [diff] [blame] | 13 | #include "base/message_loop/message_loop.h" |
asvitkine | 9481ed8 | 2017-01-20 00:17:38 +0900 | [diff] [blame] | 14 | #include "base/metrics/histogram_macros.h" |
satorux@chromium.org | 163f1cb | 2011-08-18 05:58:12 +0900 | [diff] [blame] | 15 | #include "base/threading/thread_restrictions.h" |
avi@chromium.org | 78a7e7b | 2013-06-29 00:20:02 +0900 | [diff] [blame] | 16 | #include "base/time/time.h" |
satorux@chromium.org | 163f1cb | 2011-08-18 05:58:12 +0900 | [diff] [blame] | 17 | #include "dbus/bus.h" |
| 18 | #include "dbus/message.h" |
keybuk@google.com | bf4649a | 2012-02-15 06:29:06 +0900 | [diff] [blame] | 19 | #include "dbus/object_path.h" |
satorux@chromium.org | 163f1cb | 2011-08-18 05:58:12 +0900 | [diff] [blame] | 20 | #include "dbus/scoped_dbus_error.h" |
armansito | f436464 | 2014-09-06 02:49:34 +0900 | [diff] [blame] | 21 | #include "dbus/util.h" |
satorux@chromium.org | 163f1cb | 2011-08-18 05:58:12 +0900 | [diff] [blame] | 22 | |
| 23 | namespace dbus { |
| 24 | |
| 25 | namespace { |
| 26 | |
satorux@chromium.org | 5a92cf3 | 2011-09-07 05:53:30 +0900 | [diff] [blame] | 27 | // Used for success ratio histograms. 1 for success, 0 for failure. |
| 28 | const int kSuccessRatioHistogramMaxValue = 2; |
| 29 | |
satorux@chromium.org | 163f1cb | 2011-08-18 05:58:12 +0900 | [diff] [blame] | 30 | } // namespace |
| 31 | |
| 32 | ExportedObject::ExportedObject(Bus* bus, |
keybuk@google.com | bf4649a | 2012-02-15 06:29:06 +0900 | [diff] [blame] | 33 | const ObjectPath& object_path) |
satorux@chromium.org | 163f1cb | 2011-08-18 05:58:12 +0900 | [diff] [blame] | 34 | : bus_(bus), |
satorux@chromium.org | 163f1cb | 2011-08-18 05:58:12 +0900 | [diff] [blame] | 35 | object_path_(object_path), |
satorux@chromium.org | c9ebea2 | 2011-10-08 01:26:30 +0900 | [diff] [blame] | 36 | object_is_registered_(false) { |
Ryo Hashimoto | 61ab06d | 2017-09-25 16:13:50 +0900 | [diff] [blame] | 37 | LOG_IF(FATAL, !object_path_.IsValid()) << object_path_.value(); |
satorux@chromium.org | 163f1cb | 2011-08-18 05:58:12 +0900 | [diff] [blame] | 38 | } |
| 39 | |
| 40 | ExportedObject::~ExportedObject() { |
| 41 | DCHECK(!object_is_registered_); |
| 42 | } |
| 43 | |
| 44 | bool ExportedObject::ExportMethodAndBlock( |
| 45 | const std::string& interface_name, |
| 46 | const std::string& method_name, |
| 47 | MethodCallCallback method_call_callback) { |
| 48 | bus_->AssertOnDBusThread(); |
| 49 | |
satorux@chromium.org | 7f0c451 | 2011-08-23 16:29:21 +0900 | [diff] [blame] | 50 | // Check if the method is already exported. |
| 51 | const std::string absolute_method_name = |
armansito | f436464 | 2014-09-06 02:49:34 +0900 | [diff] [blame] | 52 | GetAbsoluteMemberName(interface_name, method_name); |
satorux@chromium.org | 7f0c451 | 2011-08-23 16:29:21 +0900 | [diff] [blame] | 53 | if (method_table_.find(absolute_method_name) != method_table_.end()) { |
| 54 | LOG(ERROR) << absolute_method_name << " is already exported"; |
| 55 | return false; |
| 56 | } |
| 57 | |
satorux@chromium.org | 163f1cb | 2011-08-18 05:58:12 +0900 | [diff] [blame] | 58 | if (!bus_->Connect()) |
| 59 | return false; |
| 60 | if (!bus_->SetUpAsyncOperations()) |
| 61 | return false; |
satorux@chromium.org | 163f1cb | 2011-08-18 05:58:12 +0900 | [diff] [blame] | 62 | if (!Register()) |
| 63 | return false; |
| 64 | |
satorux@chromium.org | 7f0c451 | 2011-08-23 16:29:21 +0900 | [diff] [blame] | 65 | // Add the method callback to the method table. |
satorux@chromium.org | 163f1cb | 2011-08-18 05:58:12 +0900 | [diff] [blame] | 66 | method_table_[absolute_method_name] = method_call_callback; |
| 67 | |
| 68 | return true; |
| 69 | } |
| 70 | |
| 71 | void ExportedObject::ExportMethod(const std::string& interface_name, |
| 72 | const std::string& method_name, |
| 73 | MethodCallCallback method_call_callback, |
| 74 | OnExportedCallback on_exported_calback) { |
| 75 | bus_->AssertOnOriginThread(); |
| 76 | |
| 77 | base::Closure task = base::Bind(&ExportedObject::ExportMethodInternal, |
| 78 | this, |
| 79 | interface_name, |
| 80 | method_name, |
| 81 | method_call_callback, |
| 82 | on_exported_calback); |
hashimoto@chromium.org | 955f648 | 2013-09-26 13:32:29 +0900 | [diff] [blame] | 83 | bus_->GetDBusTaskRunner()->PostTask(FROM_HERE, task); |
satorux@chromium.org | 163f1cb | 2011-08-18 05:58:12 +0900 | [diff] [blame] | 84 | } |
| 85 | |
satorux@chromium.org | 7f0c451 | 2011-08-23 16:29:21 +0900 | [diff] [blame] | 86 | void ExportedObject::SendSignal(Signal* signal) { |
| 87 | // For signals, the object path should be set to the path to the sender |
| 88 | // object, which is this exported object here. |
hashimoto@chromium.org | b030551 | 2012-05-23 15:55:22 +0900 | [diff] [blame] | 89 | CHECK(signal->SetPath(object_path_)); |
satorux@chromium.org | 7f0c451 | 2011-08-23 16:29:21 +0900 | [diff] [blame] | 90 | |
| 91 | // Increment the reference count so we can safely reference the |
| 92 | // underlying signal message until the signal sending is complete. This |
| 93 | // will be unref'ed in SendSignalInternal(). |
| 94 | DBusMessage* signal_message = signal->raw_message(); |
| 95 | dbus_message_ref(signal_message); |
| 96 | |
satorux@chromium.org | 5a92cf3 | 2011-09-07 05:53:30 +0900 | [diff] [blame] | 97 | const base::TimeTicks start_time = base::TimeTicks::Now(); |
peary2 | 0791de9 | 2017-05-19 09:38:52 +0900 | [diff] [blame] | 98 | if (bus_->GetDBusTaskRunner()->RunsTasksInCurrentSequence()) { |
chirantan | d796bf7 | 2015-04-10 04:36:01 +0900 | [diff] [blame] | 99 | // The Chrome OS power manager doesn't use a dedicated TaskRunner for |
| 100 | // sending DBus messages. Sending signals asynchronously can cause an |
| 101 | // inversion in the message order if the power manager calls |
| 102 | // ObjectProxy::CallMethodAndBlock() before going back to the top level of |
| 103 | // the MessageLoop: crbug.com/472361. |
| 104 | SendSignalInternal(start_time, signal_message); |
| 105 | } else { |
| 106 | bus_->GetDBusTaskRunner()->PostTask( |
| 107 | FROM_HERE, |
| 108 | base::Bind(&ExportedObject::SendSignalInternal, |
| 109 | this, |
| 110 | start_time, |
| 111 | signal_message)); |
| 112 | } |
satorux@chromium.org | 7f0c451 | 2011-08-23 16:29:21 +0900 | [diff] [blame] | 113 | } |
| 114 | |
satorux@chromium.org | 163f1cb | 2011-08-18 05:58:12 +0900 | [diff] [blame] | 115 | void ExportedObject::Unregister() { |
| 116 | bus_->AssertOnDBusThread(); |
| 117 | |
| 118 | if (!object_is_registered_) |
| 119 | return; |
| 120 | |
| 121 | bus_->UnregisterObjectPath(object_path_); |
| 122 | object_is_registered_ = false; |
| 123 | } |
| 124 | |
| 125 | void ExportedObject::ExportMethodInternal( |
| 126 | const std::string& interface_name, |
| 127 | const std::string& method_name, |
| 128 | MethodCallCallback method_call_callback, |
| 129 | OnExportedCallback on_exported_calback) { |
| 130 | bus_->AssertOnDBusThread(); |
| 131 | |
| 132 | const bool success = ExportMethodAndBlock(interface_name, |
| 133 | method_name, |
| 134 | method_call_callback); |
hashimoto@chromium.org | 955f648 | 2013-09-26 13:32:29 +0900 | [diff] [blame] | 135 | bus_->GetOriginTaskRunner()->PostTask(FROM_HERE, |
| 136 | base::Bind(&ExportedObject::OnExported, |
| 137 | this, |
| 138 | on_exported_calback, |
| 139 | interface_name, |
| 140 | method_name, |
| 141 | success)); |
satorux@chromium.org | 163f1cb | 2011-08-18 05:58:12 +0900 | [diff] [blame] | 142 | } |
| 143 | |
| 144 | void ExportedObject::OnExported(OnExportedCallback on_exported_callback, |
| 145 | const std::string& interface_name, |
| 146 | const std::string& method_name, |
| 147 | bool success) { |
| 148 | bus_->AssertOnOriginThread(); |
| 149 | |
| 150 | on_exported_callback.Run(interface_name, method_name, success); |
| 151 | } |
| 152 | |
satorux@chromium.org | 5a92cf3 | 2011-09-07 05:53:30 +0900 | [diff] [blame] | 153 | void ExportedObject::SendSignalInternal(base::TimeTicks start_time, |
satorux@chromium.org | 47d706b | 2011-10-04 22:47:21 +0900 | [diff] [blame] | 154 | DBusMessage* signal_message) { |
avi | 0ad0ce0 | 2015-12-23 03:12:45 +0900 | [diff] [blame] | 155 | uint32_t serial = 0; |
satorux@chromium.org | 7f0c451 | 2011-08-23 16:29:21 +0900 | [diff] [blame] | 156 | bus_->Send(signal_message, &serial); |
| 157 | dbus_message_unref(signal_message); |
satorux@chromium.org | 5a92cf3 | 2011-09-07 05:53:30 +0900 | [diff] [blame] | 158 | // Record time spent to send the the signal. This is not accurate as the |
| 159 | // signal will actually be sent from the next run of the message loop, |
| 160 | // but we can at least tell the number of signals sent. |
| 161 | UMA_HISTOGRAM_TIMES("DBus.SignalSendTime", |
| 162 | base::TimeTicks::Now() - start_time); |
satorux@chromium.org | 7f0c451 | 2011-08-23 16:29:21 +0900 | [diff] [blame] | 163 | } |
| 164 | |
satorux@chromium.org | 163f1cb | 2011-08-18 05:58:12 +0900 | [diff] [blame] | 165 | bool ExportedObject::Register() { |
| 166 | bus_->AssertOnDBusThread(); |
| 167 | |
| 168 | if (object_is_registered_) |
| 169 | return true; |
| 170 | |
| 171 | ScopedDBusError error; |
| 172 | |
| 173 | DBusObjectPathVTable vtable = {}; |
| 174 | vtable.message_function = &ExportedObject::HandleMessageThunk; |
| 175 | vtable.unregister_function = &ExportedObject::OnUnregisteredThunk; |
| 176 | const bool success = bus_->TryRegisterObjectPath(object_path_, |
| 177 | &vtable, |
| 178 | this, |
| 179 | error.get()); |
| 180 | if (!success) { |
keybuk@google.com | bf4649a | 2012-02-15 06:29:06 +0900 | [diff] [blame] | 181 | LOG(ERROR) << "Failed to register the object: " << object_path_.value() |
| 182 | << ": " << (error.is_set() ? error.message() : ""); |
satorux@chromium.org | 163f1cb | 2011-08-18 05:58:12 +0900 | [diff] [blame] | 183 | return false; |
| 184 | } |
| 185 | |
| 186 | object_is_registered_ = true; |
| 187 | return true; |
| 188 | } |
| 189 | |
| 190 | DBusHandlerResult ExportedObject::HandleMessage( |
| 191 | DBusConnection* connection, |
| 192 | DBusMessage* raw_message) { |
| 193 | bus_->AssertOnDBusThread(); |
Sonny Sasaka | 28c6d5a | 2018-04-26 02:53:37 +0900 | [diff] [blame^] | 194 | // ExportedObject only handles method calls. Ignore other message types (e.g. |
| 195 | // signal). |
| 196 | if (dbus_message_get_type(raw_message) != DBUS_MESSAGE_TYPE_METHOD_CALL) |
| 197 | return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; |
satorux@chromium.org | 163f1cb | 2011-08-18 05:58:12 +0900 | [diff] [blame] | 198 | |
| 199 | // raw_message will be unrefed on exit of the function. Increment the |
| 200 | // reference so we can use it in MethodCall. |
| 201 | dbus_message_ref(raw_message); |
dcheng | 30c5a17 | 2016-04-09 07:55:04 +0900 | [diff] [blame] | 202 | std::unique_ptr<MethodCall> method_call( |
satorux@chromium.org | 163f1cb | 2011-08-18 05:58:12 +0900 | [diff] [blame] | 203 | MethodCall::FromRawMessage(raw_message)); |
| 204 | const std::string interface = method_call->GetInterface(); |
| 205 | const std::string member = method_call->GetMember(); |
| 206 | |
| 207 | if (interface.empty()) { |
| 208 | // We don't support method calls without interface. |
satorux@chromium.org | 5a92cf3 | 2011-09-07 05:53:30 +0900 | [diff] [blame] | 209 | LOG(WARNING) << "Interface is missing: " << method_call->ToString(); |
satorux@chromium.org | 163f1cb | 2011-08-18 05:58:12 +0900 | [diff] [blame] | 210 | return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; |
| 211 | } |
| 212 | |
| 213 | // Check if we know about the method. |
armansito | f436464 | 2014-09-06 02:49:34 +0900 | [diff] [blame] | 214 | const std::string absolute_method_name = GetAbsoluteMemberName( |
satorux@chromium.org | 163f1cb | 2011-08-18 05:58:12 +0900 | [diff] [blame] | 215 | interface, member); |
| 216 | MethodTable::const_iterator iter = method_table_.find(absolute_method_name); |
| 217 | if (iter == method_table_.end()) { |
| 218 | // Don't know about the method. |
satorux@chromium.org | 5a92cf3 | 2011-09-07 05:53:30 +0900 | [diff] [blame] | 219 | LOG(WARNING) << "Unknown method: " << method_call->ToString(); |
satorux@chromium.org | 163f1cb | 2011-08-18 05:58:12 +0900 | [diff] [blame] | 220 | return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; |
| 221 | } |
| 222 | |
satorux@chromium.org | 5a92cf3 | 2011-09-07 05:53:30 +0900 | [diff] [blame] | 223 | const base::TimeTicks start_time = base::TimeTicks::Now(); |
satorux@chromium.org | 163f1cb | 2011-08-18 05:58:12 +0900 | [diff] [blame] | 224 | if (bus_->HasDBusThread()) { |
satorux@chromium.org | 163f1cb | 2011-08-18 05:58:12 +0900 | [diff] [blame] | 225 | // Post a task to run the method in the origin thread. |
Claudio DeSouza | 1181b42 | 2018-02-22 02:27:16 +0900 | [diff] [blame] | 226 | bus_->GetOriginTaskRunner()->PostTask( |
| 227 | FROM_HERE, |
| 228 | base::BindOnce(&ExportedObject::RunMethod, this, iter->second, |
| 229 | std::move(method_call), start_time)); |
satorux@chromium.org | 163f1cb | 2011-08-18 05:58:12 +0900 | [diff] [blame] | 230 | } else { |
vlaviano@chromium.org | 241215d | 2011-11-30 13:57:42 +0900 | [diff] [blame] | 231 | // If the D-Bus thread is not used, just call the method directly. |
yuki@chromium.org | d4eedf8 | 2013-02-07 18:46:24 +0900 | [diff] [blame] | 232 | MethodCall* method = method_call.get(); |
| 233 | iter->second.Run(method, |
vlaviano@chromium.org | 241215d | 2011-11-30 13:57:42 +0900 | [diff] [blame] | 234 | base::Bind(&ExportedObject::SendResponse, |
| 235 | this, |
| 236 | start_time, |
yuki@chromium.org | d4eedf8 | 2013-02-07 18:46:24 +0900 | [diff] [blame] | 237 | base::Passed(&method_call))); |
satorux@chromium.org | 163f1cb | 2011-08-18 05:58:12 +0900 | [diff] [blame] | 238 | } |
satorux@chromium.org | c9ebea2 | 2011-10-08 01:26:30 +0900 | [diff] [blame] | 239 | |
| 240 | // It's valid to say HANDLED here, and send a method response at a later |
| 241 | // time from OnMethodCompleted() asynchronously. |
| 242 | return DBUS_HANDLER_RESULT_HANDLED; |
| 243 | } |
| 244 | |
| 245 | void ExportedObject::RunMethod(MethodCallCallback method_call_callback, |
dcheng | 30c5a17 | 2016-04-09 07:55:04 +0900 | [diff] [blame] | 246 | std::unique_ptr<MethodCall> method_call, |
satorux@chromium.org | c9ebea2 | 2011-10-08 01:26:30 +0900 | [diff] [blame] | 247 | base::TimeTicks start_time) { |
| 248 | bus_->AssertOnOriginThread(); |
yuki@chromium.org | d4eedf8 | 2013-02-07 18:46:24 +0900 | [diff] [blame] | 249 | MethodCall* method = method_call.get(); |
| 250 | method_call_callback.Run(method, |
vlaviano@chromium.org | 241215d | 2011-11-30 13:57:42 +0900 | [diff] [blame] | 251 | base::Bind(&ExportedObject::SendResponse, |
| 252 | this, |
| 253 | start_time, |
yuki@chromium.org | d4eedf8 | 2013-02-07 18:46:24 +0900 | [diff] [blame] | 254 | base::Passed(&method_call))); |
vlaviano@chromium.org | 241215d | 2011-11-30 13:57:42 +0900 | [diff] [blame] | 255 | } |
satorux@chromium.org | c9ebea2 | 2011-10-08 01:26:30 +0900 | [diff] [blame] | 256 | |
vlaviano@chromium.org | 241215d | 2011-11-30 13:57:42 +0900 | [diff] [blame] | 257 | void ExportedObject::SendResponse(base::TimeTicks start_time, |
dcheng | 30c5a17 | 2016-04-09 07:55:04 +0900 | [diff] [blame] | 258 | std::unique_ptr<MethodCall> method_call, |
| 259 | std::unique_ptr<Response> response) { |
vlaviano@chromium.org | 241215d | 2011-11-30 13:57:42 +0900 | [diff] [blame] | 260 | DCHECK(method_call); |
| 261 | if (bus_->HasDBusThread()) { |
hashimoto@chromium.org | 955f648 | 2013-09-26 13:32:29 +0900 | [diff] [blame] | 262 | bus_->GetDBusTaskRunner()->PostTask( |
Claudio DeSouza | 1181b42 | 2018-02-22 02:27:16 +0900 | [diff] [blame] | 263 | FROM_HERE, base::BindOnce(&ExportedObject::OnMethodCompleted, this, |
| 264 | std::move(method_call), std::move(response), |
| 265 | start_time)); |
vlaviano@chromium.org | 241215d | 2011-11-30 13:57:42 +0900 | [diff] [blame] | 266 | } else { |
dcheng | 6c1ffcf | 2015-12-28 11:24:50 +0900 | [diff] [blame] | 267 | OnMethodCompleted(std::move(method_call), std::move(response), start_time); |
vlaviano@chromium.org | 241215d | 2011-11-30 13:57:42 +0900 | [diff] [blame] | 268 | } |
satorux@chromium.org | c9ebea2 | 2011-10-08 01:26:30 +0900 | [diff] [blame] | 269 | } |
| 270 | |
dcheng | 30c5a17 | 2016-04-09 07:55:04 +0900 | [diff] [blame] | 271 | void ExportedObject::OnMethodCompleted(std::unique_ptr<MethodCall> method_call, |
| 272 | std::unique_ptr<Response> response, |
satorux@chromium.org | c9ebea2 | 2011-10-08 01:26:30 +0900 | [diff] [blame] | 273 | base::TimeTicks start_time) { |
| 274 | bus_->AssertOnDBusThread(); |
satorux@chromium.org | c9ebea2 | 2011-10-08 01:26:30 +0900 | [diff] [blame] | 275 | |
satorux@chromium.org | 5a92cf3 | 2011-09-07 05:53:30 +0900 | [diff] [blame] | 276 | // Record if the method call is successful, or not. 1 if successful. |
| 277 | UMA_HISTOGRAM_ENUMERATION("DBus.ExportedMethodHandleSuccess", |
| 278 | response ? 1 : 0, |
| 279 | kSuccessRatioHistogramMaxValue); |
satorux@chromium.org | 163f1cb | 2011-08-18 05:58:12 +0900 | [diff] [blame] | 280 | |
satorux@chromium.org | c9ebea2 | 2011-10-08 01:26:30 +0900 | [diff] [blame] | 281 | // Check if the bus is still connected. If the method takes long to |
| 282 | // complete, the bus may be shut down meanwhile. |
| 283 | if (!bus_->is_connected()) |
| 284 | return; |
| 285 | |
satorux@chromium.org | 163f1cb | 2011-08-18 05:58:12 +0900 | [diff] [blame] | 286 | if (!response) { |
satorux@chromium.org | c6ac757 | 2011-09-01 03:02:43 +0900 | [diff] [blame] | 287 | // Something bad happened in the method call. |
dcheng | 30c5a17 | 2016-04-09 07:55:04 +0900 | [diff] [blame] | 288 | std::unique_ptr<ErrorResponse> error_response(ErrorResponse::FromMethodCall( |
| 289 | method_call.get(), DBUS_ERROR_FAILED, |
| 290 | "error occurred in " + method_call->GetMember())); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 291 | bus_->Send(error_response->raw_message(), nullptr); |
satorux@chromium.org | c9ebea2 | 2011-10-08 01:26:30 +0900 | [diff] [blame] | 292 | return; |
satorux@chromium.org | 163f1cb | 2011-08-18 05:58:12 +0900 | [diff] [blame] | 293 | } |
| 294 | |
| 295 | // The method call was successful. |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 296 | bus_->Send(response->raw_message(), nullptr); |
satorux@chromium.org | c9ebea2 | 2011-10-08 01:26:30 +0900 | [diff] [blame] | 297 | |
satorux@chromium.org | 5a92cf3 | 2011-09-07 05:53:30 +0900 | [diff] [blame] | 298 | // Record time spent to handle the the method call. Don't include failures. |
| 299 | UMA_HISTOGRAM_TIMES("DBus.ExportedMethodHandleTime", |
| 300 | base::TimeTicks::Now() - start_time); |
satorux@chromium.org | 163f1cb | 2011-08-18 05:58:12 +0900 | [diff] [blame] | 301 | } |
| 302 | |
| 303 | void ExportedObject::OnUnregistered(DBusConnection* connection) { |
| 304 | } |
| 305 | |
| 306 | DBusHandlerResult ExportedObject::HandleMessageThunk( |
| 307 | DBusConnection* connection, |
| 308 | DBusMessage* raw_message, |
| 309 | void* user_data) { |
| 310 | ExportedObject* self = reinterpret_cast<ExportedObject*>(user_data); |
| 311 | return self->HandleMessage(connection, raw_message); |
| 312 | } |
| 313 | |
| 314 | void ExportedObject::OnUnregisteredThunk(DBusConnection *connection, |
| 315 | void* user_data) { |
| 316 | ExportedObject* self = reinterpret_cast<ExportedObject*>(user_data); |
| 317 | return self->OnUnregistered(connection); |
| 318 | } |
| 319 | |
| 320 | } // namespace dbus |