1 files changed, 28 insertions, 54 deletions

diff --git a/src/components/dbus/src/dbus_message.cc b/src/components/dbus/src/dbus_message.cc
index 702e44f801..b8a55896ce 100644
--- a/src/components/dbus/src/dbus_message.cc
+++ b/src/components/dbus/src/dbus_message.cc
@@ -38,12 +38,10 @@
 
 namespace dbus {
 
-MessageRefKeeper::MessageRefKeeper()
-  : raw_message_(NULL) {
-}
+MessageRefKeeper::MessageRefKeeper() : raw_message_(NULL) {}
 
 MessageRefKeeper::MessageRefKeeper(DBusMessage* message)
-  : raw_message_(message) {
+    : raw_message_(message) {
   assert(raw_message_);
   dbus_message_ref(raw_message_);
 }
@@ -55,7 +53,7 @@ MessageRefKeeper::~MessageRefKeeper() {
 }
 
 MessageRefKeeper::MessageRefKeeper(const MessageRefKeeper& other)
-  : raw_message_(other.raw_message_) {
+    : raw_message_(other.raw_message_) {
   assert(raw_message_);
   dbus_message_ref(raw_message_);
 }
@@ -79,13 +77,9 @@ void MessageRefKeeper::swap(MessageRefKeeper& other) {
   std::swap(raw_message_, other.raw_message_);
 }
 
+MessageRef::MessageRef(DBusMessage* message) : raw_message_ref_(message) {}
 
-MessageRef::MessageRef(DBusMessage* message)
-  : raw_message_ref_(message) {
-}
-
-MessageRef::~MessageRef(){
-}
+MessageRef::~MessageRef() {}
 
 std::string MessageRef::GetInterface() const {
   return dbus_message_get_interface(raw_message_ref_.get());
@@ -97,11 +91,9 @@ std::string MessageRef::GetMember() const {
 
 // Message writer
 MessageReader::MessageReader(const MessageRef& message)
-  : parent_reader_(NULL),
-    failed_(false) {
+    : parent_reader_(NULL), failed_(false) {
   dbus_bool_t success =
-      dbus_message_iter_init(message.raw_message_ref_.get(),
-                             &iterator_);
+      dbus_message_iter_init(message.raw_message_ref_.get(), &iterator_);
   if (!success) {
     MarkFailed();
   }
@@ -109,8 +101,7 @@ MessageReader::MessageReader(const MessageRef& message)
 
 MessageReader::MessageReader(MessageReader* reader,
                              DataType container_data_type)
-  : parent_reader_(reader),
-    failed_(reader->has_failed()) {
+    : parent_reader_(reader), failed_(reader->has_failed()) {
   assert(parent_reader_);
   if (!failed_) {
     if (reader->NextValueType() != container_data_type) {
@@ -122,12 +113,10 @@ MessageReader::MessageReader(MessageReader* reader,
   }
 }
 
-
 bool MessageReader::NextIsDictEntry() const {
   return NextValueType() == DBUS_TYPE_DICT_ENTRY;
 }
 
-
 MessageReader MessageReader::TakeArrayReader() {
   return MessageReader(this, DBUS_TYPE_ARRAY);
 }
@@ -156,8 +145,7 @@ void MessageReader::MarkFailed() {
   }
 }
 
-void MessageReader::ReadNextValue(MessageReader::DataType type,
-                                  void* value) {
+void MessageReader::ReadNextValue(MessageReader::DataType type, void* value) {
   assert(value);
   if (NextValueType() != type) {
     MarkFailed();
@@ -169,28 +157,21 @@ void MessageReader::ReadNextValue(MessageReader::DataType type,
 
 // DbusMessageWriter
 MessageWriter::MessageWriter(const MessageRef& message)
-  : has_opened_subcontainer_(false),
-    parent_writer_(NULL) {
-  dbus_message_iter_init_append(message.raw_message_ref_.get(),
-                                &iterator_);
-}
-
-MessageWriter::MessageWriter(
-    MessageWriter* parent,
-    ContainerType container_type,
-    const char* array_signature)
-  : has_opened_subcontainer_(false),
-    parent_writer_(parent) {
+    : has_opened_subcontainer_(false), parent_writer_(NULL) {
+  dbus_message_iter_init_append(message.raw_message_ref_.get(), &iterator_);
+}
+
+MessageWriter::MessageWriter(MessageWriter* parent,
+                             ContainerType container_type,
+                             const char* array_signature)
+    : has_opened_subcontainer_(false), parent_writer_(parent) {
   assert(parent_writer_);
   // Only array writers require array_signature
-  assert((container_type == kArray && array_signature != NULL)
-         || (container_type != kArray && array_signature == NULL));
+  assert((container_type == kArray && array_signature != NULL) ||
+         (container_type != kArray && array_signature == NULL));
   assert(!parent_writer_->has_opened_subcontainer_);
-  bool enough_memory =
-      dbus_message_iter_open_container(&parent_writer_->iterator_,
-                                       container_type,
-                                       array_signature,
-                                       &iterator_);
+  bool enough_memory = dbus_message_iter_open_container(
+      &parent_writer_->iterator_, container_type, array_signature, &iterator_);
   assert(enough_memory);
   parent_writer_->has_opened_subcontainer_ = true;
 }
@@ -202,8 +183,8 @@ MessageWriter::~MessageWriter() {
   }
 }
 
-void MessageWriter::WriteAndCheck(
-    MessageWriter::DataType value_type, const void* value) {
+void MessageWriter::WriteAndCheck(MessageWriter::DataType value_type,
+                                  const void* value) {
   assert(!has_opened_subcontainer_);
   dbus_bool_t enough_memory =
       dbus_message_iter_append_basic(&iterator_, value_type, value);
@@ -214,8 +195,7 @@ void MessageWriter::CloseWriter() {
   assert(parent_writer_);
   assert(parent_writer_->has_opened_subcontainer_);
   dbus_bool_t enough_memory =
-      dbus_message_iter_close_container(&parent_writer_->iterator_,
-                                        &iterator_);
+      dbus_message_iter_close_container(&parent_writer_->iterator_, &iterator_);
   assert(enough_memory);
   parent_writer_->has_opened_subcontainer_ = false;
 }
@@ -226,18 +206,12 @@ MessageRef MethodCall(const char* bus_name,
                       const char* path,
                       const char* interface,
                       const char* method) {
-  return MessageRef(dbus_message_new_method_call(
-                      bus_name,
-                      path,
-                      interface,
-                      method));
+  return MessageRef(
+      dbus_message_new_method_call(bus_name, path, interface, method));
 }
 
-MessageRef Signal(const char* path,
-                  const char* interface,
-                  const char* name) {
+MessageRef Signal(const char* path, const char* interface, const char* name) {
   return MessageRef(dbus_message_new_signal(path, interface, name));
 }
 
-
-} // namespace dbus
+}  // namespace dbus