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 #include "dbus/exported_object.h" 6 7 #include "base/bind.h" 8 #include "base/logging.h" 9 #include "base/memory/ref_counted.h" 10 #include "base/message_loop/message_loop.h" 11 #include "base/metrics/histogram.h" 12 #include "base/threading/thread_restrictions.h" 13 #include "base/time/time.h" 14 #include "dbus/bus.h" 15 #include "dbus/message.h" 16 #include "dbus/object_path.h" 17 #include "dbus/scoped_dbus_error.h" 18 19 namespace dbus { 20 21 namespace { 22 23 // Used for success ratio histograms. 1 for success, 0 for failure. 24 const int kSuccessRatioHistogramMaxValue = 2; 25 26 // Gets the absolute method name by concatenating the interface name and 27 // the method name. Used for building keys for method_table_ in 28 // ExportedObject. 29 std::string GetAbsoluteMethodName( 30 const std::string& interface_name, 31 const std::string& method_name) { 32 return interface_name + "." + method_name; 33 } 34 35 } // namespace 36 37 ExportedObject::ExportedObject(Bus* bus, 38 const ObjectPath& object_path) 39 : bus_(bus), 40 object_path_(object_path), 41 object_is_registered_(false) { 42 } 43 44 ExportedObject::~ExportedObject() { 45 DCHECK(!object_is_registered_); 46 } 47 48 bool ExportedObject::ExportMethodAndBlock( 49 const std::string& interface_name, 50 const std::string& method_name, 51 MethodCallCallback method_call_callback) { 52 bus_->AssertOnDBusThread(); 53 54 // Check if the method is already exported. 55 const std::string absolute_method_name = 56 GetAbsoluteMethodName(interface_name, method_name); 57 if (method_table_.find(absolute_method_name) != method_table_.end()) { 58 LOG(ERROR) << absolute_method_name << " is already exported"; 59 return false; 60 } 61 62 if (!bus_->Connect()) 63 return false; 64 if (!bus_->SetUpAsyncOperations()) 65 return false; 66 if (!Register()) 67 return false; 68 69 // Add the method callback to the method table. 70 method_table_[absolute_method_name] = method_call_callback; 71 72 return true; 73 } 74 75 void ExportedObject::ExportMethod(const std::string& interface_name, 76 const std::string& method_name, 77 MethodCallCallback method_call_callback, 78 OnExportedCallback on_exported_calback) { 79 bus_->AssertOnOriginThread(); 80 81 base::Closure task = base::Bind(&ExportedObject::ExportMethodInternal, 82 this, 83 interface_name, 84 method_name, 85 method_call_callback, 86 on_exported_calback); 87 bus_->GetDBusTaskRunner()->PostTask(FROM_HERE, task); 88 } 89 90 void ExportedObject::SendSignal(Signal* signal) { 91 // For signals, the object path should be set to the path to the sender 92 // object, which is this exported object here. 93 CHECK(signal->SetPath(object_path_)); 94 95 // Increment the reference count so we can safely reference the 96 // underlying signal message until the signal sending is complete. This 97 // will be unref'ed in SendSignalInternal(). 98 DBusMessage* signal_message = signal->raw_message(); 99 dbus_message_ref(signal_message); 100 101 const base::TimeTicks start_time = base::TimeTicks::Now(); 102 bus_->GetDBusTaskRunner()->PostTask( 103 FROM_HERE, 104 base::Bind(&ExportedObject::SendSignalInternal, 105 this, 106 start_time, 107 signal_message)); 108 } 109 110 void ExportedObject::Unregister() { 111 bus_->AssertOnDBusThread(); 112 113 if (!object_is_registered_) 114 return; 115 116 bus_->UnregisterObjectPath(object_path_); 117 object_is_registered_ = false; 118 } 119 120 void ExportedObject::ExportMethodInternal( 121 const std::string& interface_name, 122 const std::string& method_name, 123 MethodCallCallback method_call_callback, 124 OnExportedCallback on_exported_calback) { 125 bus_->AssertOnDBusThread(); 126 127 const bool success = ExportMethodAndBlock(interface_name, 128 method_name, 129 method_call_callback); 130 bus_->GetOriginTaskRunner()->PostTask(FROM_HERE, 131 base::Bind(&ExportedObject::OnExported, 132 this, 133 on_exported_calback, 134 interface_name, 135 method_name, 136 success)); 137 } 138 139 void ExportedObject::OnExported(OnExportedCallback on_exported_callback, 140 const std::string& interface_name, 141 const std::string& method_name, 142 bool success) { 143 bus_->AssertOnOriginThread(); 144 145 on_exported_callback.Run(interface_name, method_name, success); 146 } 147 148 void ExportedObject::SendSignalInternal(base::TimeTicks start_time, 149 DBusMessage* signal_message) { 150 uint32 serial = 0; 151 bus_->Send(signal_message, &serial); 152 dbus_message_unref(signal_message); 153 // Record time spent to send the the signal. This is not accurate as the 154 // signal will actually be sent from the next run of the message loop, 155 // but we can at least tell the number of signals sent. 156 UMA_HISTOGRAM_TIMES("DBus.SignalSendTime", 157 base::TimeTicks::Now() - start_time); 158 } 159 160 bool ExportedObject::Register() { 161 bus_->AssertOnDBusThread(); 162 163 if (object_is_registered_) 164 return true; 165 166 ScopedDBusError error; 167 168 DBusObjectPathVTable vtable = {}; 169 vtable.message_function = &ExportedObject::HandleMessageThunk; 170 vtable.unregister_function = &ExportedObject::OnUnregisteredThunk; 171 const bool success = bus_->TryRegisterObjectPath(object_path_, 172 &vtable, 173 this, 174 error.get()); 175 if (!success) { 176 LOG(ERROR) << "Failed to register the object: " << object_path_.value() 177 << ": " << (error.is_set() ? error.message() : ""); 178 return false; 179 } 180 181 object_is_registered_ = true; 182 return true; 183 } 184 185 DBusHandlerResult ExportedObject::HandleMessage( 186 DBusConnection* connection, 187 DBusMessage* raw_message) { 188 bus_->AssertOnDBusThread(); 189 DCHECK_EQ(DBUS_MESSAGE_TYPE_METHOD_CALL, dbus_message_get_type(raw_message)); 190 191 // raw_message will be unrefed on exit of the function. Increment the 192 // reference so we can use it in MethodCall. 193 dbus_message_ref(raw_message); 194 scoped_ptr<MethodCall> method_call( 195 MethodCall::FromRawMessage(raw_message)); 196 const std::string interface = method_call->GetInterface(); 197 const std::string member = method_call->GetMember(); 198 199 if (interface.empty()) { 200 // We don't support method calls without interface. 201 LOG(WARNING) << "Interface is missing: " << method_call->ToString(); 202 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; 203 } 204 205 // Check if we know about the method. 206 const std::string absolute_method_name = GetAbsoluteMethodName( 207 interface, member); 208 MethodTable::const_iterator iter = method_table_.find(absolute_method_name); 209 if (iter == method_table_.end()) { 210 // Don't know about the method. 211 LOG(WARNING) << "Unknown method: " << method_call->ToString(); 212 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; 213 } 214 215 const base::TimeTicks start_time = base::TimeTicks::Now(); 216 if (bus_->HasDBusThread()) { 217 // Post a task to run the method in the origin thread. 218 bus_->GetOriginTaskRunner()->PostTask(FROM_HERE, 219 base::Bind(&ExportedObject::RunMethod, 220 this, 221 iter->second, 222 base::Passed(&method_call), 223 start_time)); 224 } else { 225 // If the D-Bus thread is not used, just call the method directly. 226 MethodCall* method = method_call.get(); 227 iter->second.Run(method, 228 base::Bind(&ExportedObject::SendResponse, 229 this, 230 start_time, 231 base::Passed(&method_call))); 232 } 233 234 // It's valid to say HANDLED here, and send a method response at a later 235 // time from OnMethodCompleted() asynchronously. 236 return DBUS_HANDLER_RESULT_HANDLED; 237 } 238 239 void ExportedObject::RunMethod(MethodCallCallback method_call_callback, 240 scoped_ptr<MethodCall> method_call, 241 base::TimeTicks start_time) { 242 bus_->AssertOnOriginThread(); 243 MethodCall* method = method_call.get(); 244 method_call_callback.Run(method, 245 base::Bind(&ExportedObject::SendResponse, 246 this, 247 start_time, 248 base::Passed(&method_call))); 249 } 250 251 void ExportedObject::SendResponse(base::TimeTicks start_time, 252 scoped_ptr<MethodCall> method_call, 253 scoped_ptr<Response> response) { 254 DCHECK(method_call); 255 if (bus_->HasDBusThread()) { 256 bus_->GetDBusTaskRunner()->PostTask( 257 FROM_HERE, 258 base::Bind(&ExportedObject::OnMethodCompleted, 259 this, 260 base::Passed(&method_call), 261 base::Passed(&response), 262 start_time)); 263 } else { 264 OnMethodCompleted(method_call.Pass(), response.Pass(), start_time); 265 } 266 } 267 268 void ExportedObject::OnMethodCompleted(scoped_ptr<MethodCall> method_call, 269 scoped_ptr<Response> response, 270 base::TimeTicks start_time) { 271 bus_->AssertOnDBusThread(); 272 273 // Record if the method call is successful, or not. 1 if successful. 274 UMA_HISTOGRAM_ENUMERATION("DBus.ExportedMethodHandleSuccess", 275 response ? 1 : 0, 276 kSuccessRatioHistogramMaxValue); 277 278 // Check if the bus is still connected. If the method takes long to 279 // complete, the bus may be shut down meanwhile. 280 if (!bus_->is_connected()) 281 return; 282 283 if (!response) { 284 // Something bad happened in the method call. 285 scoped_ptr<ErrorResponse> error_response( 286 ErrorResponse::FromMethodCall( 287 method_call.get(), 288 DBUS_ERROR_FAILED, 289 "error occurred in " + method_call->GetMember())); 290 bus_->Send(error_response->raw_message(), NULL); 291 return; 292 } 293 294 // The method call was successful. 295 bus_->Send(response->raw_message(), NULL); 296 297 // Record time spent to handle the the method call. Don't include failures. 298 UMA_HISTOGRAM_TIMES("DBus.ExportedMethodHandleTime", 299 base::TimeTicks::Now() - start_time); 300 } 301 302 void ExportedObject::OnUnregistered(DBusConnection* connection) { 303 } 304 305 DBusHandlerResult ExportedObject::HandleMessageThunk( 306 DBusConnection* connection, 307 DBusMessage* raw_message, 308 void* user_data) { 309 ExportedObject* self = reinterpret_cast<ExportedObject*>(user_data); 310 return self->HandleMessage(connection, raw_message); 311 } 312 313 void ExportedObject::OnUnregisteredThunk(DBusConnection *connection, 314 void* user_data) { 315 ExportedObject* self = reinterpret_cast<ExportedObject*>(user_data); 316 return self->OnUnregistered(connection); 317 } 318 319 } // namespace dbus 320
