dbus: move logic from Property<> to PropertySet

dbus/property.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "dbus/property.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/logging.h"
 
@@ skipping 73 matching lines @@
 }
 
 void PropertySet::ChangedConnected(const std::string& interface_name,
                                    const std::string& signal_name,
                                    bool success) {
   LOG_IF(WARNING, !success) << "Failed to connect to " << signal_name
                             << "signal.";
 }
 
 
+void PropertySet::Get(PropertyBase* property, GetCallback callback) {
+  MethodCall method_call(kPropertiesInterface, kPropertiesGet);
+  MessageWriter writer(&method_call);
+  writer.AppendString(interface());
+  writer.AppendString(property->name());
+
+  DCHECK(object_proxy_);
+  object_proxy_->CallMethod(&method_call,
+                            ObjectProxy::TIMEOUT_USE_DEFAULT,
+                            base::Bind(&PropertySet::OnGet,
+                                       GetWeakPtr(),
+                                       property,
+                                       callback));
+}
+
+void PropertySet::OnGet(PropertyBase* property, GetCallback callback,
+                        Response* response) {
+  if (!response) {
+    LOG(WARNING) << property->name() << ": Get: failed.";
+    return;
+  }
+
+  MessageReader reader(response);
+  if (property->PopValueFromReader(&reader))
+    NotifyPropertyChanged(property->name());
+
+  if (!callback.is_null())
+    callback.Run(response);
+}
+
 void PropertySet::GetAll() {
   MethodCall method_call(kPropertiesInterface, kPropertiesGetAll);
   MessageWriter writer(&method_call);
   writer.AppendString(interface());
 
   DCHECK(object_proxy_);
   object_proxy_->CallMethod(&method_call,
                             ObjectProxy::TIMEOUT_USE_DEFAULT,
                             base::Bind(&PropertySet::OnGetAll,
                                        weak_ptr_factory_.GetWeakPtr()));
 }
 
 void PropertySet::OnGetAll(Response* response) {
   if (!response) {
     LOG(WARNING) << "GetAll request failed.";
     return;
   }
 
   MessageReader reader(response);
   if (!UpdatePropertiesFromReader(&reader)) {
     LOG(WARNING) << "GetAll response has wrong parameters: "
                  << "expected dictionary: " << response->ToString();
   }
 }
 
+void PropertySet::Set(PropertyBase* property, SetCallback callback) {
+  MethodCall method_call(kPropertiesInterface, kPropertiesSet);
+  MessageWriter writer(&method_call);
+  writer.AppendString(interface());
+  writer.AppendString(property->name());
+  property->AppendSetValueToWriter(&writer);
+
+  DCHECK(object_proxy_);
+  object_proxy_->CallMethod(&method_call,
+                            ObjectProxy::TIMEOUT_USE_DEFAULT,
+                            base::Bind(&PropertySet::OnSet,
+                                       GetWeakPtr(),
+                                       property,
+                                       callback));
+}
+
+void PropertySet::OnSet(PropertyBase* property, SetCallback callback,
+                        Response* response) {
+  LOG_IF(WARNING, !response) << property->name() << ": Set: failed.";
+  if (!callback.is_null())
+    callback.Run(response);
+}
 
 bool PropertySet::UpdatePropertiesFromReader(MessageReader* reader) {
   DCHECK(reader);
   MessageReader array_reader(NULL);
   if (!reader->PopArray(&array_reader))
     return false;
 
   while (array_reader.HasMoreData()) {
     MessageReader dict_entry_reader(NULL);
     if (array_reader.PopDictEntry(&dict_entry_reader))
@@ skipping 27 matching lines @@
 void PropertySet::NotifyPropertyChanged(const std::string& name) {
   if (!property_changed_callback_.is_null())
     property_changed_callback_.Run(name);
 }
 
 //
 // Property<Byte> specialization.
 //
 
 template <>
-Property<uint8>::Property() : value_(0),
-                              weak_ptr_factory_(this) {
+Property<uint8>::Property() : value_(0) {
 }
 
 template <>
 bool Property<uint8>::PopValueFromReader(MessageReader* reader) {
   return reader->PopVariantOfByte(&value_);
 }
 
 template <>
-void Property<uint8>::AppendToWriter(MessageWriter* writer,
-                                     const uint8& value) {
-  writer->AppendVariantOfByte(value);
+void Property<uint8>::AppendSetValueToWriter(MessageWriter* writer) {
+  writer->AppendVariantOfByte(set_value_);
 }
 
 //
 // Property<bool> specialization.
 //
 
 template <>
-Property<bool>::Property() : value_(false),
-                             weak_ptr_factory_(this) {
+Property<bool>::Property() : value_(false) {
 }
 
 template <>
 bool Property<bool>::PopValueFromReader(MessageReader* reader) {
   return reader->PopVariantOfBool(&value_);
 }
 
 template <>
-void Property<bool>::AppendToWriter(MessageWriter* writer,
-                                    const bool& value) {
-  writer->AppendVariantOfBool(value);
+void Property<bool>::AppendSetValueToWriter(MessageWriter* writer) {
+  writer->AppendVariantOfBool(set_value_);
 }
 
 //
 // Property<int16> specialization.
 //
 
 template <>
-Property<int16>::Property() : value_(0),
-                              weak_ptr_factory_(this) {
+Property<int16>::Property() : value_(0) {
 }
 
 template <>
 bool Property<int16>::PopValueFromReader(MessageReader* reader) {
   return reader->PopVariantOfInt16(&value_);
 }
 
 template <>
-void Property<int16>::AppendToWriter(MessageWriter* writer,
-                                     const int16& value) {
-  writer->AppendVariantOfInt16(value);
+void Property<int16>::AppendSetValueToWriter(MessageWriter* writer) {
+  writer->AppendVariantOfInt16(set_value_);
 }
 
 //
 // Property<uint16> specialization.
 //
 
 template <>
-Property<uint16>::Property() : value_(0),
-                               weak_ptr_factory_(this) {
+Property<uint16>::Property() : value_(0) {
 }
 
 template <>
 bool Property<uint16>::PopValueFromReader(MessageReader* reader) {
   return reader->PopVariantOfUint16(&value_);
 }
 
 template <>
-void Property<uint16>::AppendToWriter(MessageWriter* writer,
-                                      const uint16& value) {
-  writer->AppendVariantOfUint16(value);
+void Property<uint16>::AppendSetValueToWriter(MessageWriter* writer) {
+  writer->AppendVariantOfUint16(set_value_);
 }
 
 //
 // Property<int32> specialization.
 //
 
 template <>
-Property<int32>::Property() : value_(0),
-                              weak_ptr_factory_(this) {
+Property<int32>::Property() : value_(0) {
 }
 
 template <>
 bool Property<int32>::PopValueFromReader(MessageReader* reader) {
   return reader->PopVariantOfInt32(&value_);
 }
 
 template <>
-void Property<int32>::AppendToWriter(MessageWriter* writer,
-                                     const int32& value) {
-  writer->AppendVariantOfInt32(value);
+void Property<int32>::AppendSetValueToWriter(MessageWriter* writer) {
+  writer->AppendVariantOfInt32(set_value_);
 }
 
 //
 // Property<uint32> specialization.
 //
 
 template <>
-Property<uint32>::Property() : value_(0),
-                               weak_ptr_factory_(this) {
+Property<uint32>::Property() : value_(0) {
 }
 
 template <>
 bool Property<uint32>::PopValueFromReader(MessageReader* reader) {
   return reader->PopVariantOfUint32(&value_);
 }
 
 template <>
-void Property<uint32>::AppendToWriter(MessageWriter* writer,
-                                      const uint32& value) {
-  writer->AppendVariantOfUint32(value);
+void Property<uint32>::AppendSetValueToWriter(MessageWriter* writer) {
+  writer->AppendVariantOfUint32(set_value_);
 }
 
 //
 // Property<int64> specialization.
 //
 
 template <>
-Property<int64>::Property() : value_(0),
-                              weak_ptr_factory_(this) {
+Property<int64>::Property() : value_(0) {
 }
 
 template <>
 bool Property<int64>::PopValueFromReader(MessageReader* reader) {
   return reader->PopVariantOfInt64(&value_);
 }
 
 template <>
-void Property<int64>::AppendToWriter(MessageWriter* writer,
-                                     const int64& value) {
-  writer->AppendVariantOfInt64(value);
+void Property<int64>::AppendSetValueToWriter(MessageWriter* writer) {
+  writer->AppendVariantOfInt64(set_value_);
 }
 
 //
 // Property<uint64> specialization.
 //
 
 template <>
-Property<uint64>::Property() : value_(0),
-                               weak_ptr_factory_(this) {
+Property<uint64>::Property() : value_(0) {
 }
 
 template <>
 bool Property<uint64>::PopValueFromReader(MessageReader* reader) {
   return reader->PopVariantOfUint64(&value_);
 }
 
 template <>
-void Property<uint64>::AppendToWriter(MessageWriter* writer,
-                                      const uint64& value) {
-  writer->AppendVariantOfUint64(value);
+void Property<uint64>::AppendSetValueToWriter(MessageWriter* writer) {
+  writer->AppendVariantOfUint64(set_value_);
 }
 
 //
 // Property<double> specialization.
 //
 
 template <>
-Property<double>::Property() : value_(0.0),
-                               weak_ptr_factory_(this) {
+Property<double>::Property() : value_(0.0) {
 }
 
 template <>
 bool Property<double>::PopValueFromReader(MessageReader* reader) {
   return reader->PopVariantOfDouble(&value_);
 }
 
 template <>
-void Property<double>::AppendToWriter(MessageWriter* writer,
-                                      const double& value) {
-  writer->AppendVariantOfDouble(value);
+void Property<double>::AppendSetValueToWriter(MessageWriter* writer) {
+  writer->AppendVariantOfDouble(set_value_);
 }
 
 //
 // Property<std::string> specialization.
 //
 
 template <>
 bool Property<std::string>::PopValueFromReader(MessageReader* reader) {
   return reader->PopVariantOfString(&value_);
 }
 
 template <>
-void Property<std::string>::AppendToWriter(MessageWriter* writer,
-                                           const std::string& value) {
-  writer->AppendVariantOfString(value);
+void Property<std::string>::AppendSetValueToWriter(MessageWriter* writer) {
+  writer->AppendVariantOfString(set_value_);
 }
 
 //
 // Property<ObjectPath> specialization.
 //
 
 template <>
 bool Property<ObjectPath>::PopValueFromReader(MessageReader* reader) {
   return reader->PopVariantOfObjectPath(&value_);
 }
 
 template <>
-void Property<ObjectPath>::AppendToWriter(MessageWriter* writer,
-                                          const ObjectPath& value) {
-  writer->AppendVariantOfObjectPath(value);
+void Property<ObjectPath>::AppendSetValueToWriter(MessageWriter* writer) {
+  writer->AppendVariantOfObjectPath(set_value_);
 }
 
 //
 // Property<std::vector<std::string> > specialization.
 //
 
 template <>
 bool Property<std::vector<std::string> >::PopValueFromReader(
     MessageReader* reader) {
   MessageReader variant_reader(NULL);
   if (!reader->PopVariant(&variant_reader))
     return false;
 
   value_.clear();
   return variant_reader.PopArrayOfStrings(&value_);
 }
 
 template <>
-void Property<std::vector<std::string> >::AppendToWriter(
-    MessageWriter* writer,
-    const std::vector<std::string>& value) {
+void Property<std::vector<std::string> >::AppendSetValueToWriter(
+    MessageWriter* writer) {
   MessageWriter variant_writer(NULL);
   writer->OpenVariant("as", &variant_writer);
-  variant_writer.AppendArrayOfStrings(value);
+  variant_writer.AppendArrayOfStrings(set_value_);
   writer->CloseContainer(&variant_writer);
 }
 
 //
 // Property<std::vector<ObjectPath> > specialization.
 //
 
 template <>
 bool Property<std::vector<ObjectPath> >::PopValueFromReader(
     MessageReader* reader) {
   MessageReader variant_reader(NULL);
   if (!reader->PopVariant(&variant_reader))
     return false;
 
   value_.clear();
   return variant_reader.PopArrayOfObjectPaths(&value_);
 }
 
 template <>
-void Property<std::vector<ObjectPath> >::AppendToWriter(
-    MessageWriter* writer,
-    const std::vector<ObjectPath>& value) {
+void Property<std::vector<ObjectPath> >::AppendSetValueToWriter(
+    MessageWriter* writer) {
   MessageWriter variant_writer(NULL);
   writer->OpenVariant("ao", &variant_writer);
-  variant_writer.AppendArrayOfObjectPaths(value);
+  variant_writer.AppendArrayOfObjectPaths(set_value_);
   writer->CloseContainer(&variant_writer);
 }
 
 }  // namespace dbus