OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "dbus/property.h" | 5 #include "dbus/property.h" |
6 | 6 |
7 #include "base/basictypes.h" | 7 #include "base/basictypes.h" |
8 #include "base/bind.h" | 8 #include "base/bind.h" |
9 #include "base/logging.h" | 9 #include "base/logging.h" |
10 | 10 |
(...skipping 73 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
84 } | 84 } |
85 | 85 |
86 void PropertySet::ChangedConnected(const std::string& interface_name, | 86 void PropertySet::ChangedConnected(const std::string& interface_name, |
87 const std::string& signal_name, | 87 const std::string& signal_name, |
88 bool success) { | 88 bool success) { |
89 LOG_IF(WARNING, !success) << "Failed to connect to " << signal_name | 89 LOG_IF(WARNING, !success) << "Failed to connect to " << signal_name |
90 << "signal."; | 90 << "signal."; |
91 } | 91 } |
92 | 92 |
93 | 93 |
| 94 void PropertySet::Get(PropertyBase* property, GetCallback callback) { |
| 95 MethodCall method_call(kPropertiesInterface, kPropertiesGet); |
| 96 MessageWriter writer(&method_call); |
| 97 writer.AppendString(interface()); |
| 98 writer.AppendString(property->name()); |
| 99 |
| 100 DCHECK(object_proxy_); |
| 101 object_proxy_->CallMethod(&method_call, |
| 102 ObjectProxy::TIMEOUT_USE_DEFAULT, |
| 103 base::Bind(&PropertySet::OnGet, |
| 104 GetWeakPtr(), |
| 105 property, |
| 106 callback)); |
| 107 } |
| 108 |
| 109 void PropertySet::OnGet(PropertyBase* property, GetCallback callback, |
| 110 Response* response) { |
| 111 if (!response) { |
| 112 LOG(WARNING) << property->name() << ": Get: failed."; |
| 113 return; |
| 114 } |
| 115 |
| 116 MessageReader reader(response); |
| 117 if (property->PopValueFromReader(&reader)) |
| 118 NotifyPropertyChanged(property->name()); |
| 119 |
| 120 if (!callback.is_null()) |
| 121 callback.Run(response); |
| 122 } |
| 123 |
94 void PropertySet::GetAll() { | 124 void PropertySet::GetAll() { |
95 MethodCall method_call(kPropertiesInterface, kPropertiesGetAll); | 125 MethodCall method_call(kPropertiesInterface, kPropertiesGetAll); |
96 MessageWriter writer(&method_call); | 126 MessageWriter writer(&method_call); |
97 writer.AppendString(interface()); | 127 writer.AppendString(interface()); |
98 | 128 |
99 DCHECK(object_proxy_); | 129 DCHECK(object_proxy_); |
100 object_proxy_->CallMethod(&method_call, | 130 object_proxy_->CallMethod(&method_call, |
101 ObjectProxy::TIMEOUT_USE_DEFAULT, | 131 ObjectProxy::TIMEOUT_USE_DEFAULT, |
102 base::Bind(&PropertySet::OnGetAll, | 132 base::Bind(&PropertySet::OnGetAll, |
103 weak_ptr_factory_.GetWeakPtr())); | 133 weak_ptr_factory_.GetWeakPtr())); |
104 } | 134 } |
105 | 135 |
106 void PropertySet::OnGetAll(Response* response) { | 136 void PropertySet::OnGetAll(Response* response) { |
107 if (!response) { | 137 if (!response) { |
108 LOG(WARNING) << "GetAll request failed."; | 138 LOG(WARNING) << "GetAll request failed."; |
109 return; | 139 return; |
110 } | 140 } |
111 | 141 |
112 MessageReader reader(response); | 142 MessageReader reader(response); |
113 if (!UpdatePropertiesFromReader(&reader)) { | 143 if (!UpdatePropertiesFromReader(&reader)) { |
114 LOG(WARNING) << "GetAll response has wrong parameters: " | 144 LOG(WARNING) << "GetAll response has wrong parameters: " |
115 << "expected dictionary: " << response->ToString(); | 145 << "expected dictionary: " << response->ToString(); |
116 } | 146 } |
117 } | 147 } |
118 | 148 |
| 149 void PropertySet::Set(PropertyBase* property, SetCallback callback) { |
| 150 MethodCall method_call(kPropertiesInterface, kPropertiesSet); |
| 151 MessageWriter writer(&method_call); |
| 152 writer.AppendString(interface()); |
| 153 writer.AppendString(property->name()); |
| 154 property->AppendSetValueToWriter(&writer); |
| 155 |
| 156 DCHECK(object_proxy_); |
| 157 object_proxy_->CallMethod(&method_call, |
| 158 ObjectProxy::TIMEOUT_USE_DEFAULT, |
| 159 base::Bind(&PropertySet::OnSet, |
| 160 GetWeakPtr(), |
| 161 property, |
| 162 callback)); |
| 163 } |
| 164 |
| 165 void PropertySet::OnSet(PropertyBase* property, SetCallback callback, |
| 166 Response* response) { |
| 167 LOG_IF(WARNING, !response) << property->name() << ": Set: failed."; |
| 168 if (!callback.is_null()) |
| 169 callback.Run(response); |
| 170 } |
119 | 171 |
120 bool PropertySet::UpdatePropertiesFromReader(MessageReader* reader) { | 172 bool PropertySet::UpdatePropertiesFromReader(MessageReader* reader) { |
121 DCHECK(reader); | 173 DCHECK(reader); |
122 MessageReader array_reader(NULL); | 174 MessageReader array_reader(NULL); |
123 if (!reader->PopArray(&array_reader)) | 175 if (!reader->PopArray(&array_reader)) |
124 return false; | 176 return false; |
125 | 177 |
126 while (array_reader.HasMoreData()) { | 178 while (array_reader.HasMoreData()) { |
127 MessageReader dict_entry_reader(NULL); | 179 MessageReader dict_entry_reader(NULL); |
128 if (array_reader.PopDictEntry(&dict_entry_reader)) | 180 if (array_reader.PopDictEntry(&dict_entry_reader)) |
(...skipping 27 matching lines...) Expand all Loading... |
156 void PropertySet::NotifyPropertyChanged(const std::string& name) { | 208 void PropertySet::NotifyPropertyChanged(const std::string& name) { |
157 if (!property_changed_callback_.is_null()) | 209 if (!property_changed_callback_.is_null()) |
158 property_changed_callback_.Run(name); | 210 property_changed_callback_.Run(name); |
159 } | 211 } |
160 | 212 |
161 // | 213 // |
162 // Property<Byte> specialization. | 214 // Property<Byte> specialization. |
163 // | 215 // |
164 | 216 |
165 template <> | 217 template <> |
166 Property<uint8>::Property() : value_(0), | 218 Property<uint8>::Property() : value_(0) { |
167 weak_ptr_factory_(this) { | |
168 } | 219 } |
169 | 220 |
170 template <> | 221 template <> |
171 bool Property<uint8>::PopValueFromReader(MessageReader* reader) { | 222 bool Property<uint8>::PopValueFromReader(MessageReader* reader) { |
172 return reader->PopVariantOfByte(&value_); | 223 return reader->PopVariantOfByte(&value_); |
173 } | 224 } |
174 | 225 |
175 template <> | 226 template <> |
176 void Property<uint8>::AppendToWriter(MessageWriter* writer, | 227 void Property<uint8>::AppendSetValueToWriter(MessageWriter* writer) { |
177 const uint8& value) { | 228 writer->AppendVariantOfByte(set_value_); |
178 writer->AppendVariantOfByte(value); | |
179 } | 229 } |
180 | 230 |
181 // | 231 // |
182 // Property<bool> specialization. | 232 // Property<bool> specialization. |
183 // | 233 // |
184 | 234 |
185 template <> | 235 template <> |
186 Property<bool>::Property() : value_(false), | 236 Property<bool>::Property() : value_(false) { |
187 weak_ptr_factory_(this) { | |
188 } | 237 } |
189 | 238 |
190 template <> | 239 template <> |
191 bool Property<bool>::PopValueFromReader(MessageReader* reader) { | 240 bool Property<bool>::PopValueFromReader(MessageReader* reader) { |
192 return reader->PopVariantOfBool(&value_); | 241 return reader->PopVariantOfBool(&value_); |
193 } | 242 } |
194 | 243 |
195 template <> | 244 template <> |
196 void Property<bool>::AppendToWriter(MessageWriter* writer, | 245 void Property<bool>::AppendSetValueToWriter(MessageWriter* writer) { |
197 const bool& value) { | 246 writer->AppendVariantOfBool(set_value_); |
198 writer->AppendVariantOfBool(value); | |
199 } | 247 } |
200 | 248 |
201 // | 249 // |
202 // Property<int16> specialization. | 250 // Property<int16> specialization. |
203 // | 251 // |
204 | 252 |
205 template <> | 253 template <> |
206 Property<int16>::Property() : value_(0), | 254 Property<int16>::Property() : value_(0) { |
207 weak_ptr_factory_(this) { | |
208 } | 255 } |
209 | 256 |
210 template <> | 257 template <> |
211 bool Property<int16>::PopValueFromReader(MessageReader* reader) { | 258 bool Property<int16>::PopValueFromReader(MessageReader* reader) { |
212 return reader->PopVariantOfInt16(&value_); | 259 return reader->PopVariantOfInt16(&value_); |
213 } | 260 } |
214 | 261 |
215 template <> | 262 template <> |
216 void Property<int16>::AppendToWriter(MessageWriter* writer, | 263 void Property<int16>::AppendSetValueToWriter(MessageWriter* writer) { |
217 const int16& value) { | 264 writer->AppendVariantOfInt16(set_value_); |
218 writer->AppendVariantOfInt16(value); | |
219 } | 265 } |
220 | 266 |
221 // | 267 // |
222 // Property<uint16> specialization. | 268 // Property<uint16> specialization. |
223 // | 269 // |
224 | 270 |
225 template <> | 271 template <> |
226 Property<uint16>::Property() : value_(0), | 272 Property<uint16>::Property() : value_(0) { |
227 weak_ptr_factory_(this) { | |
228 } | 273 } |
229 | 274 |
230 template <> | 275 template <> |
231 bool Property<uint16>::PopValueFromReader(MessageReader* reader) { | 276 bool Property<uint16>::PopValueFromReader(MessageReader* reader) { |
232 return reader->PopVariantOfUint16(&value_); | 277 return reader->PopVariantOfUint16(&value_); |
233 } | 278 } |
234 | 279 |
235 template <> | 280 template <> |
236 void Property<uint16>::AppendToWriter(MessageWriter* writer, | 281 void Property<uint16>::AppendSetValueToWriter(MessageWriter* writer) { |
237 const uint16& value) { | 282 writer->AppendVariantOfUint16(set_value_); |
238 writer->AppendVariantOfUint16(value); | |
239 } | 283 } |
240 | 284 |
241 // | 285 // |
242 // Property<int32> specialization. | 286 // Property<int32> specialization. |
243 // | 287 // |
244 | 288 |
245 template <> | 289 template <> |
246 Property<int32>::Property() : value_(0), | 290 Property<int32>::Property() : value_(0) { |
247 weak_ptr_factory_(this) { | |
248 } | 291 } |
249 | 292 |
250 template <> | 293 template <> |
251 bool Property<int32>::PopValueFromReader(MessageReader* reader) { | 294 bool Property<int32>::PopValueFromReader(MessageReader* reader) { |
252 return reader->PopVariantOfInt32(&value_); | 295 return reader->PopVariantOfInt32(&value_); |
253 } | 296 } |
254 | 297 |
255 template <> | 298 template <> |
256 void Property<int32>::AppendToWriter(MessageWriter* writer, | 299 void Property<int32>::AppendSetValueToWriter(MessageWriter* writer) { |
257 const int32& value) { | 300 writer->AppendVariantOfInt32(set_value_); |
258 writer->AppendVariantOfInt32(value); | |
259 } | 301 } |
260 | 302 |
261 // | 303 // |
262 // Property<uint32> specialization. | 304 // Property<uint32> specialization. |
263 // | 305 // |
264 | 306 |
265 template <> | 307 template <> |
266 Property<uint32>::Property() : value_(0), | 308 Property<uint32>::Property() : value_(0) { |
267 weak_ptr_factory_(this) { | |
268 } | 309 } |
269 | 310 |
270 template <> | 311 template <> |
271 bool Property<uint32>::PopValueFromReader(MessageReader* reader) { | 312 bool Property<uint32>::PopValueFromReader(MessageReader* reader) { |
272 return reader->PopVariantOfUint32(&value_); | 313 return reader->PopVariantOfUint32(&value_); |
273 } | 314 } |
274 | 315 |
275 template <> | 316 template <> |
276 void Property<uint32>::AppendToWriter(MessageWriter* writer, | 317 void Property<uint32>::AppendSetValueToWriter(MessageWriter* writer) { |
277 const uint32& value) { | 318 writer->AppendVariantOfUint32(set_value_); |
278 writer->AppendVariantOfUint32(value); | |
279 } | 319 } |
280 | 320 |
281 // | 321 // |
282 // Property<int64> specialization. | 322 // Property<int64> specialization. |
283 // | 323 // |
284 | 324 |
285 template <> | 325 template <> |
286 Property<int64>::Property() : value_(0), | 326 Property<int64>::Property() : value_(0) { |
287 weak_ptr_factory_(this) { | |
288 } | 327 } |
289 | 328 |
290 template <> | 329 template <> |
291 bool Property<int64>::PopValueFromReader(MessageReader* reader) { | 330 bool Property<int64>::PopValueFromReader(MessageReader* reader) { |
292 return reader->PopVariantOfInt64(&value_); | 331 return reader->PopVariantOfInt64(&value_); |
293 } | 332 } |
294 | 333 |
295 template <> | 334 template <> |
296 void Property<int64>::AppendToWriter(MessageWriter* writer, | 335 void Property<int64>::AppendSetValueToWriter(MessageWriter* writer) { |
297 const int64& value) { | 336 writer->AppendVariantOfInt64(set_value_); |
298 writer->AppendVariantOfInt64(value); | |
299 } | 337 } |
300 | 338 |
301 // | 339 // |
302 // Property<uint64> specialization. | 340 // Property<uint64> specialization. |
303 // | 341 // |
304 | 342 |
305 template <> | 343 template <> |
306 Property<uint64>::Property() : value_(0), | 344 Property<uint64>::Property() : value_(0) { |
307 weak_ptr_factory_(this) { | |
308 } | 345 } |
309 | 346 |
310 template <> | 347 template <> |
311 bool Property<uint64>::PopValueFromReader(MessageReader* reader) { | 348 bool Property<uint64>::PopValueFromReader(MessageReader* reader) { |
312 return reader->PopVariantOfUint64(&value_); | 349 return reader->PopVariantOfUint64(&value_); |
313 } | 350 } |
314 | 351 |
315 template <> | 352 template <> |
316 void Property<uint64>::AppendToWriter(MessageWriter* writer, | 353 void Property<uint64>::AppendSetValueToWriter(MessageWriter* writer) { |
317 const uint64& value) { | 354 writer->AppendVariantOfUint64(set_value_); |
318 writer->AppendVariantOfUint64(value); | |
319 } | 355 } |
320 | 356 |
321 // | 357 // |
322 // Property<double> specialization. | 358 // Property<double> specialization. |
323 // | 359 // |
324 | 360 |
325 template <> | 361 template <> |
326 Property<double>::Property() : value_(0.0), | 362 Property<double>::Property() : value_(0.0) { |
327 weak_ptr_factory_(this) { | |
328 } | 363 } |
329 | 364 |
330 template <> | 365 template <> |
331 bool Property<double>::PopValueFromReader(MessageReader* reader) { | 366 bool Property<double>::PopValueFromReader(MessageReader* reader) { |
332 return reader->PopVariantOfDouble(&value_); | 367 return reader->PopVariantOfDouble(&value_); |
333 } | 368 } |
334 | 369 |
335 template <> | 370 template <> |
336 void Property<double>::AppendToWriter(MessageWriter* writer, | 371 void Property<double>::AppendSetValueToWriter(MessageWriter* writer) { |
337 const double& value) { | 372 writer->AppendVariantOfDouble(set_value_); |
338 writer->AppendVariantOfDouble(value); | |
339 } | 373 } |
340 | 374 |
341 // | 375 // |
342 // Property<std::string> specialization. | 376 // Property<std::string> specialization. |
343 // | 377 // |
344 | 378 |
345 template <> | 379 template <> |
346 bool Property<std::string>::PopValueFromReader(MessageReader* reader) { | 380 bool Property<std::string>::PopValueFromReader(MessageReader* reader) { |
347 return reader->PopVariantOfString(&value_); | 381 return reader->PopVariantOfString(&value_); |
348 } | 382 } |
349 | 383 |
350 template <> | 384 template <> |
351 void Property<std::string>::AppendToWriter(MessageWriter* writer, | 385 void Property<std::string>::AppendSetValueToWriter(MessageWriter* writer) { |
352 const std::string& value) { | 386 writer->AppendVariantOfString(set_value_); |
353 writer->AppendVariantOfString(value); | |
354 } | 387 } |
355 | 388 |
356 // | 389 // |
357 // Property<ObjectPath> specialization. | 390 // Property<ObjectPath> specialization. |
358 // | 391 // |
359 | 392 |
360 template <> | 393 template <> |
361 bool Property<ObjectPath>::PopValueFromReader(MessageReader* reader) { | 394 bool Property<ObjectPath>::PopValueFromReader(MessageReader* reader) { |
362 return reader->PopVariantOfObjectPath(&value_); | 395 return reader->PopVariantOfObjectPath(&value_); |
363 } | 396 } |
364 | 397 |
365 template <> | 398 template <> |
366 void Property<ObjectPath>::AppendToWriter(MessageWriter* writer, | 399 void Property<ObjectPath>::AppendSetValueToWriter(MessageWriter* writer) { |
367 const ObjectPath& value) { | 400 writer->AppendVariantOfObjectPath(set_value_); |
368 writer->AppendVariantOfObjectPath(value); | |
369 } | 401 } |
370 | 402 |
371 // | 403 // |
372 // Property<std::vector<std::string> > specialization. | 404 // Property<std::vector<std::string> > specialization. |
373 // | 405 // |
374 | 406 |
375 template <> | 407 template <> |
376 bool Property<std::vector<std::string> >::PopValueFromReader( | 408 bool Property<std::vector<std::string> >::PopValueFromReader( |
377 MessageReader* reader) { | 409 MessageReader* reader) { |
378 MessageReader variant_reader(NULL); | 410 MessageReader variant_reader(NULL); |
379 if (!reader->PopVariant(&variant_reader)) | 411 if (!reader->PopVariant(&variant_reader)) |
380 return false; | 412 return false; |
381 | 413 |
382 value_.clear(); | 414 value_.clear(); |
383 return variant_reader.PopArrayOfStrings(&value_); | 415 return variant_reader.PopArrayOfStrings(&value_); |
384 } | 416 } |
385 | 417 |
386 template <> | 418 template <> |
387 void Property<std::vector<std::string> >::AppendToWriter( | 419 void Property<std::vector<std::string> >::AppendSetValueToWriter( |
388 MessageWriter* writer, | 420 MessageWriter* writer) { |
389 const std::vector<std::string>& value) { | |
390 MessageWriter variant_writer(NULL); | 421 MessageWriter variant_writer(NULL); |
391 writer->OpenVariant("as", &variant_writer); | 422 writer->OpenVariant("as", &variant_writer); |
392 variant_writer.AppendArrayOfStrings(value); | 423 variant_writer.AppendArrayOfStrings(set_value_); |
393 writer->CloseContainer(&variant_writer); | 424 writer->CloseContainer(&variant_writer); |
394 } | 425 } |
395 | 426 |
396 // | 427 // |
397 // Property<std::vector<ObjectPath> > specialization. | 428 // Property<std::vector<ObjectPath> > specialization. |
398 // | 429 // |
399 | 430 |
400 template <> | 431 template <> |
401 bool Property<std::vector<ObjectPath> >::PopValueFromReader( | 432 bool Property<std::vector<ObjectPath> >::PopValueFromReader( |
402 MessageReader* reader) { | 433 MessageReader* reader) { |
403 MessageReader variant_reader(NULL); | 434 MessageReader variant_reader(NULL); |
404 if (!reader->PopVariant(&variant_reader)) | 435 if (!reader->PopVariant(&variant_reader)) |
405 return false; | 436 return false; |
406 | 437 |
407 value_.clear(); | 438 value_.clear(); |
408 return variant_reader.PopArrayOfObjectPaths(&value_); | 439 return variant_reader.PopArrayOfObjectPaths(&value_); |
409 } | 440 } |
410 | 441 |
411 template <> | 442 template <> |
412 void Property<std::vector<ObjectPath> >::AppendToWriter( | 443 void Property<std::vector<ObjectPath> >::AppendSetValueToWriter( |
413 MessageWriter* writer, | 444 MessageWriter* writer) { |
414 const std::vector<ObjectPath>& value) { | |
415 MessageWriter variant_writer(NULL); | 445 MessageWriter variant_writer(NULL); |
416 writer->OpenVariant("ao", &variant_writer); | 446 writer->OpenVariant("ao", &variant_writer); |
417 variant_writer.AppendArrayOfObjectPaths(value); | 447 variant_writer.AppendArrayOfObjectPaths(set_value_); |
418 writer->CloseContainer(&variant_writer); | 448 writer->CloseContainer(&variant_writer); |
419 } | 449 } |
420 | 450 |
421 } // namespace dbus | 451 } // namespace dbus |
OLD | NEW |