chromeos-dbus-bindings: Add support for STRUCT and typed async methods

The async method handlers in libchromeos have been changed to use
strongly typed response objects. This change mainly changes the
adapter generator to produce the correct signatures for the async
adapter methods.

In the attempt to support existing XML files from shill and
modemmanager I implemented some features that are required there:

1. Allow nested <node> elements (which are still ignored but at
   least parsing of XML files doesn't fail.
2. Add support for <tp:docstring> element to extract comments
   from interface/method/signal/property definitions and add
   then to adaptor/proxy code which should help user to make
   sense of method intentions.
3. Added support for STRUCT D-Bus types (...). Now using
   std::tuple<> to represent D-Bus structures.
4. a{sv} are converted to chromeos::VariantDictionary instead of
   std::map<std::string, chromeos::Any> which is shorter and
   being very popular type in D-Bus, makes a few generated
   function signatures neater.
5. Added support for "org.freedesktop.DBus.GLib.Async" annotation
   to be an alias for "org.chromium.DBus.Method.Kind"="async".
6. Fixed chromeos::string_utils::Split() to eliminate empty
   strings if they were created by trimming all-whitespace
   elements of the split array.

BUG=None
TEST=FEATURES=test emerge-link chromeos-dbus-bindings

Change-Id: I73cf13819128ca5fca9e9188d162d120b737cf1f
Reviewed-on: https://chromium-review.googlesource.com/229430
Reviewed-by: Paul Stewart <pstew@chromium.org>
Commit-Queue: Alex Vakulenko <avakulenko@chromium.org>
Tested-by: Alex Vakulenko <avakulenko@chromium.org>

1 files changed, 57 insertions, 2 deletions

diff --git a/chromeos-dbus-bindings/dbus_signature.cc b/chromeos-dbus-bindings/dbus_signature.cc
index 922ad16..a6e59d4 100644
--- a/chromeos-dbus-bindings/dbus_signature.cc
+++ b/chromeos-dbus-bindings/dbus_signature.cc
@@ -6,6 +6,7 @@
 
 #include <base/logging.h>
 #include <base/strings/stringprintf.h>
+#include <chromeos/strings/string_utils.h>
 #include <dbus/dbus-protocol.h>
 
 using base::StringPrintf;
@@ -30,6 +31,9 @@ const char DbusSignature::kUnsigned16Typename[] = "uint16_t";
 const char DbusSignature::kUnsigned32Typename[] = "uint32_t";
 const char DbusSignature::kUnsigned64Typename[] = "uint64_t";
 const char DbusSignature::kVariantTypename[] = "chromeos::Any";
+const char DbusSignature::kVariantDictTypename[] =
+    "chromeos::VariantDictionary";
+const char DbusSignature::kTupleTypename[] = "std::tuple";
 
 DbusSignature::DbusSignature()
     : object_path_typename_(kDefaultObjectPathTypename) {}
@@ -61,6 +65,12 @@ bool DbusSignature::GetTypenameForSignature(
   string::const_iterator cur = signature;
   int signature_value = *cur++;
   switch (signature_value) {
+    case DBUS_STRUCT_BEGIN_CHAR:
+      if (!GetStructTypenameForSignature(cur, end, &cur, output)) {
+        return false;
+      }
+      break;
+
     case DBUS_TYPE_ARRAY:
       if (!GetArrayTypenameForSignature(cur, end, &cur, output)) {
         return false;
@@ -168,8 +178,13 @@ bool DbusSignature::GetArrayTypenameForSignature(
                  << " where only 2 children is valid.";
       return false;
     }
-    *output = StringPrintf("%s<%s,%s>", kDictTypename,
-                           children[0].c_str(), children[1].c_str());
+    string dict_signature{signature, cur};
+    if (dict_signature == "{sv}") {
+      *output = kVariantDictTypename;
+    } else {
+      *output = StringPrintf("%s<%s, %s>", kDictTypename,
+                             children[0].c_str(), children[1].c_str());
+    }
   } else {
     string child;
     if (!GetTypenameForSignature(cur, end, &cur, &child)) {
@@ -187,4 +202,44 @@ bool DbusSignature::GetArrayTypenameForSignature(
   return true;
 }
 
+bool DbusSignature::GetStructTypenameForSignature(
+    string::const_iterator signature,
+    string::const_iterator end,
+    string::const_iterator* next,
+    string* output) {
+  string::const_iterator cur = signature;
+  if (cur == end) {
+    LOG(ERROR) << "At end of string while reading struct parameter";
+    return false;
+  }
+
+  vector<string> children;
+  while (cur != end && *cur != DBUS_STRUCT_END_CHAR) {
+    children.emplace_back();
+    if (!GetTypenameForSignature(cur, end, &cur, &children.back())) {
+      LOG(ERROR) << "Unable to decode child elements starting at "
+                 << string(cur, end);
+      return false;
+    }
+  }
+  if (cur == end) {
+    LOG(ERROR) << "At end of string while processing struct "
+               << "starting at " << string(signature, end);
+    return false;
+  }
+
+  DCHECK_EQ(DBUS_STRUCT_END_CHAR, *cur);
+  ++cur;
+
+  *output = StringPrintf(
+      "%s<%s>", kTupleTypename,
+      chromeos::string_utils::Join(", ", children).c_str());
+
+  if (next) {
+    *next = cur;
+  }
+
+  return true;
+}
+
 }  // namespace chromeos_dbus_bindings