Make perf work in adb_profile_chrome when JSON converter isn't present
[chromium-blink-merge.git] / dbus / property.cc
blob774719f8bf81fc280426d9ac245117daf4814ee3
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.
5 #include "dbus/property.h"
7 #include "base/basictypes.h"
8 #include "base/bind.h"
9 #include "base/logging.h"
11 #include "dbus/message.h"
12 #include "dbus/object_path.h"
13 #include "dbus/object_proxy.h"
15 namespace dbus {
18 // PropertyBase implementation.
21 void PropertyBase::Init(PropertySet* property_set, const std::string& name) {
22 DCHECK(!property_set_);
23 property_set_ = property_set;
24 name_ = name;
29 // PropertySet implementation.
32 PropertySet::PropertySet(
33 ObjectProxy* object_proxy,
34 const std::string& interface,
35 const PropertyChangedCallback& property_changed_callback)
36 : object_proxy_(object_proxy),
37 interface_(interface),
38 property_changed_callback_(property_changed_callback),
39 weak_ptr_factory_(this) {}
41 PropertySet::~PropertySet() {
44 void PropertySet::RegisterProperty(const std::string& name,
45 PropertyBase* property) {
46 property->Init(this, name);
47 properties_map_[name] = property;
50 void PropertySet::ConnectSignals() {
51 DCHECK(object_proxy_);
52 object_proxy_->ConnectToSignal(
53 kPropertiesInterface,
54 kPropertiesChanged,
55 base::Bind(&PropertySet::ChangedReceived,
56 weak_ptr_factory_.GetWeakPtr()),
57 base::Bind(&PropertySet::ChangedConnected,
58 weak_ptr_factory_.GetWeakPtr()));
62 void PropertySet::ChangedReceived(Signal* signal) {
63 DCHECK(signal);
64 MessageReader reader(signal);
66 std::string interface;
67 if (!reader.PopString(&interface)) {
68 LOG(WARNING) << "Property changed signal has wrong parameters: "
69 << "expected interface name: " << signal->ToString();
70 return;
73 if (interface != this->interface())
74 return;
76 if (!UpdatePropertiesFromReader(&reader)) {
77 LOG(WARNING) << "Property changed signal has wrong parameters: "
78 << "expected dictionary: " << signal->ToString();
81 // TODO(keybuk): dbus properties api has invalidated properties array
82 // on the end, we don't handle this right now because I don't know of
83 // any service that sends it - or what they expect us to do with it.
84 // Add later when we need it.
87 void PropertySet::ChangedConnected(const std::string& interface_name,
88 const std::string& signal_name,
89 bool success) {
90 LOG_IF(WARNING, !success) << "Failed to connect to " << signal_name
91 << "signal.";
95 void PropertySet::Get(PropertyBase* property, GetCallback callback) {
96 MethodCall method_call(kPropertiesInterface, kPropertiesGet);
97 MessageWriter writer(&method_call);
98 writer.AppendString(interface());
99 writer.AppendString(property->name());
101 DCHECK(object_proxy_);
102 object_proxy_->CallMethod(&method_call,
103 ObjectProxy::TIMEOUT_USE_DEFAULT,
104 base::Bind(&PropertySet::OnGet,
105 GetWeakPtr(),
106 property,
107 callback));
110 void PropertySet::OnGet(PropertyBase* property, GetCallback callback,
111 Response* response) {
112 if (!response) {
113 LOG(WARNING) << property->name() << ": Get: failed.";
114 return;
117 MessageReader reader(response);
118 if (property->PopValueFromReader(&reader))
119 NotifyPropertyChanged(property->name());
121 if (!callback.is_null())
122 callback.Run(response);
125 void PropertySet::GetAll() {
126 MethodCall method_call(kPropertiesInterface, kPropertiesGetAll);
127 MessageWriter writer(&method_call);
128 writer.AppendString(interface());
130 DCHECK(object_proxy_);
131 object_proxy_->CallMethod(&method_call,
132 ObjectProxy::TIMEOUT_USE_DEFAULT,
133 base::Bind(&PropertySet::OnGetAll,
134 weak_ptr_factory_.GetWeakPtr()));
137 void PropertySet::OnGetAll(Response* response) {
138 if (!response) {
139 LOG(WARNING) << "GetAll request failed.";
140 return;
143 MessageReader reader(response);
144 if (!UpdatePropertiesFromReader(&reader)) {
145 LOG(WARNING) << "GetAll response has wrong parameters: "
146 << "expected dictionary: " << response->ToString();
150 void PropertySet::Set(PropertyBase* property, SetCallback callback) {
151 MethodCall method_call(kPropertiesInterface, kPropertiesSet);
152 MessageWriter writer(&method_call);
153 writer.AppendString(interface());
154 writer.AppendString(property->name());
155 property->AppendSetValueToWriter(&writer);
157 DCHECK(object_proxy_);
158 object_proxy_->CallMethod(&method_call,
159 ObjectProxy::TIMEOUT_USE_DEFAULT,
160 base::Bind(&PropertySet::OnSet,
161 GetWeakPtr(),
162 property,
163 callback));
166 void PropertySet::OnSet(PropertyBase* property, SetCallback callback,
167 Response* response) {
168 LOG_IF(WARNING, !response) << property->name() << ": Set: failed.";
169 if (!callback.is_null())
170 callback.Run(response);
173 bool PropertySet::UpdatePropertiesFromReader(MessageReader* reader) {
174 DCHECK(reader);
175 MessageReader array_reader(NULL);
176 if (!reader->PopArray(&array_reader))
177 return false;
179 while (array_reader.HasMoreData()) {
180 MessageReader dict_entry_reader(NULL);
181 if (array_reader.PopDictEntry(&dict_entry_reader))
182 UpdatePropertyFromReader(&dict_entry_reader);
185 return true;
188 bool PropertySet::UpdatePropertyFromReader(MessageReader* reader) {
189 DCHECK(reader);
191 std::string name;
192 if (!reader->PopString(&name))
193 return false;
195 PropertiesMap::iterator it = properties_map_.find(name);
196 if (it == properties_map_.end())
197 return false;
199 PropertyBase* property = it->second;
200 if (property->PopValueFromReader(reader)) {
201 NotifyPropertyChanged(name);
202 return true;
203 } else {
204 return false;
209 void PropertySet::NotifyPropertyChanged(const std::string& name) {
210 if (!property_changed_callback_.is_null())
211 property_changed_callback_.Run(name);
215 // Property<Byte> specialization.
218 template <>
219 Property<uint8>::Property() : value_(0) {
222 template <>
223 bool Property<uint8>::PopValueFromReader(MessageReader* reader) {
224 return reader->PopVariantOfByte(&value_);
227 template <>
228 void Property<uint8>::AppendSetValueToWriter(MessageWriter* writer) {
229 writer->AppendVariantOfByte(set_value_);
233 // Property<bool> specialization.
236 template <>
237 Property<bool>::Property() : value_(false) {
240 template <>
241 bool Property<bool>::PopValueFromReader(MessageReader* reader) {
242 return reader->PopVariantOfBool(&value_);
245 template <>
246 void Property<bool>::AppendSetValueToWriter(MessageWriter* writer) {
247 writer->AppendVariantOfBool(set_value_);
251 // Property<int16> specialization.
254 template <>
255 Property<int16>::Property() : value_(0) {
258 template <>
259 bool Property<int16>::PopValueFromReader(MessageReader* reader) {
260 return reader->PopVariantOfInt16(&value_);
263 template <>
264 void Property<int16>::AppendSetValueToWriter(MessageWriter* writer) {
265 writer->AppendVariantOfInt16(set_value_);
269 // Property<uint16> specialization.
272 template <>
273 Property<uint16>::Property() : value_(0) {
276 template <>
277 bool Property<uint16>::PopValueFromReader(MessageReader* reader) {
278 return reader->PopVariantOfUint16(&value_);
281 template <>
282 void Property<uint16>::AppendSetValueToWriter(MessageWriter* writer) {
283 writer->AppendVariantOfUint16(set_value_);
287 // Property<int32> specialization.
290 template <>
291 Property<int32>::Property() : value_(0) {
294 template <>
295 bool Property<int32>::PopValueFromReader(MessageReader* reader) {
296 return reader->PopVariantOfInt32(&value_);
299 template <>
300 void Property<int32>::AppendSetValueToWriter(MessageWriter* writer) {
301 writer->AppendVariantOfInt32(set_value_);
305 // Property<uint32> specialization.
308 template <>
309 Property<uint32>::Property() : value_(0) {
312 template <>
313 bool Property<uint32>::PopValueFromReader(MessageReader* reader) {
314 return reader->PopVariantOfUint32(&value_);
317 template <>
318 void Property<uint32>::AppendSetValueToWriter(MessageWriter* writer) {
319 writer->AppendVariantOfUint32(set_value_);
323 // Property<int64> specialization.
326 template <>
327 Property<int64>::Property() : value_(0), set_value_(0) {
330 template <>
331 bool Property<int64>::PopValueFromReader(MessageReader* reader) {
332 return reader->PopVariantOfInt64(&value_);
335 template <>
336 void Property<int64>::AppendSetValueToWriter(MessageWriter* writer) {
337 writer->AppendVariantOfInt64(set_value_);
341 // Property<uint64> specialization.
344 template <>
345 Property<uint64>::Property() : value_(0) {
348 template <>
349 bool Property<uint64>::PopValueFromReader(MessageReader* reader) {
350 return reader->PopVariantOfUint64(&value_);
353 template <>
354 void Property<uint64>::AppendSetValueToWriter(MessageWriter* writer) {
355 writer->AppendVariantOfUint64(set_value_);
359 // Property<double> specialization.
362 template <>
363 Property<double>::Property() : value_(0.0) {
366 template <>
367 bool Property<double>::PopValueFromReader(MessageReader* reader) {
368 return reader->PopVariantOfDouble(&value_);
371 template <>
372 void Property<double>::AppendSetValueToWriter(MessageWriter* writer) {
373 writer->AppendVariantOfDouble(set_value_);
377 // Property<std::string> specialization.
380 template <>
381 bool Property<std::string>::PopValueFromReader(MessageReader* reader) {
382 return reader->PopVariantOfString(&value_);
385 template <>
386 void Property<std::string>::AppendSetValueToWriter(MessageWriter* writer) {
387 writer->AppendVariantOfString(set_value_);
391 // Property<ObjectPath> specialization.
394 template <>
395 bool Property<ObjectPath>::PopValueFromReader(MessageReader* reader) {
396 return reader->PopVariantOfObjectPath(&value_);
399 template <>
400 void Property<ObjectPath>::AppendSetValueToWriter(MessageWriter* writer) {
401 writer->AppendVariantOfObjectPath(set_value_);
405 // Property<std::vector<std::string> > specialization.
408 template <>
409 bool Property<std::vector<std::string> >::PopValueFromReader(
410 MessageReader* reader) {
411 MessageReader variant_reader(NULL);
412 if (!reader->PopVariant(&variant_reader))
413 return false;
415 value_.clear();
416 return variant_reader.PopArrayOfStrings(&value_);
419 template <>
420 void Property<std::vector<std::string> >::AppendSetValueToWriter(
421 MessageWriter* writer) {
422 MessageWriter variant_writer(NULL);
423 writer->OpenVariant("as", &variant_writer);
424 variant_writer.AppendArrayOfStrings(set_value_);
425 writer->CloseContainer(&variant_writer);
429 // Property<std::vector<ObjectPath> > specialization.
432 template <>
433 bool Property<std::vector<ObjectPath> >::PopValueFromReader(
434 MessageReader* reader) {
435 MessageReader variant_reader(NULL);
436 if (!reader->PopVariant(&variant_reader))
437 return false;
439 value_.clear();
440 return variant_reader.PopArrayOfObjectPaths(&value_);
443 template <>
444 void Property<std::vector<ObjectPath> >::AppendSetValueToWriter(
445 MessageWriter* writer) {
446 MessageWriter variant_writer(NULL);
447 writer->OpenVariant("ao", &variant_writer);
448 variant_writer.AppendArrayOfObjectPaths(set_value_);
449 writer->CloseContainer(&variant_writer);
453 // Property<std::vector<uint8> > specialization.
456 template <>
457 bool Property<std::vector<uint8> >::PopValueFromReader(MessageReader* reader) {
458 MessageReader variant_reader(NULL);
459 if (!reader->PopVariant(&variant_reader))
460 return false;
462 value_.clear();
463 const uint8* bytes = NULL;
464 size_t length = 0;
465 if (!variant_reader.PopArrayOfBytes(&bytes, &length))
466 return false;
467 value_.assign(bytes, bytes + length);
468 return true;
471 template <>
472 void Property<std::vector<uint8> >::AppendSetValueToWriter(
473 MessageWriter* writer) {
474 MessageWriter variant_writer(NULL);
475 writer->OpenVariant("ay", &variant_writer);
476 variant_writer.AppendArrayOfBytes(set_value_.data(), set_value_.size());
477 writer->CloseContainer(&variant_writer);
480 } // namespace dbus