Merge lp:~mardy/online-accounts-api/style into lp:online-accounts-api

[Alberto Mardegan]

Style changes

- change whitespaces
- use camelcase for variable names
- prefix "m_" for class members
- sort #includes alphabetically
- use Qt keywords and classes when available

[lp:~mardy/online-accounts-api/style]

6. By Alberto Mardegan on 2015-02-10

Remove mutable

7. By Alberto Mardegan on 2015-02-11

Review updates

8. By Alberto Mardegan on 2015-02-11

From the dbus branch

=== modified file 'src/daemon/aacontext.cpp'
--- src/daemon/aacontext.cpp	2015-02-10 08:12:59 +0000
+++ src/daemon/aacontext.cpp	2015-02-11 12:59:36 +0000
@@ -1,47 +1,53 @@
 #include "aacontext.h"
-#include <stdexcept>
-#include <sys/apparmor.h>
-#include <QDebug>
+
 #include <QDBusConnection>
 #include <QDBusMessage>
-
-const int max_cache_size = 50;
-
-AppArmorContext::AppArmorContext() {
-}
-
-AppArmorContext::~AppArmorContext() {
-}
-
-QString AppArmorContext::getPeerSecurityContext(const QDBusConnection &bus, const QDBusMessage &message) {
+#include <QDebug>
+#include <sys/apparmor.h>
+
+const int maxCacheSize = 50;
+
+AppArmorContext::AppArmorContext()
+{
+}
+
+AppArmorContext::~AppArmorContext()
+{
+}
+
+QString AppArmorContext::getPeerSecurityContext(const QDBusConnection &bus,
+                                                const QDBusMessage &message)
+{
     if (!aa_is_enabled()) {
         return "unconfined";
     }
 
     QString peer_address = message.service();
-    try {
-        return contexts.at(peer_address);
-    } catch (const std::out_of_range &e) {
+    QString &context = m_contexts[peer_address];
+    /* If the peer_address was now known, it's now been added as an empty
+     * QString. */
+    if (!context.isEmpty()) {
+        return context;
     }
 
-    QDBusMessage msg = QDBusMessage::createMethodCall(
-        "org.freedesktop.DBus", "/org/freedesktop/DBus",
-        "org.freedesktop.DBus", "GetConnectionAppArmorSecurityContext");
+    QDBusMessage msg =
+        QDBusMessage::createMethodCall("org.freedesktop.DBus",
+                                       "/org/freedesktop/DBus",
+                                       "org.freedesktop.DBus",
+                                       "GetConnectionAppArmorSecurityContext");
     msg << peer_address;
     QDBusMessage reply = bus.call(msg, QDBus::Block);
 
-    QString context;
     if (reply.type() == QDBusMessage::ReplyMessage) {
         context = reply.arguments().value(0).value<QString>();
     } else {
-        qWarning() << "Could not determine AppArmor context: "
-                   << reply.errorName() << ": " << reply.errorMessage();
+        qWarning() << "Could not determine AppArmor context: " <<
+            reply.errorName() << ": " << reply.errorMessage();
     }
 
     // If the context cache has hit the maximum size, clear it
-    if (contexts.size() >= max_cache_size) {
-        contexts.clear();
+    if (m_contexts.size() >= maxCacheSize) {
+        m_contexts.clear();
     }
-    contexts[peer_address] = context;
     return context;
 }

=== modified file 'src/daemon/aacontext.h'
--- src/daemon/aacontext.h	2015-02-09 05:18:22 +0000
+++ src/daemon/aacontext.h	2015-02-11 12:59:36 +0000
@@ -1,9 +1,9 @@
 #ifndef AACONTEXT_H
 #define AACONTEXT_H
 
-#include <map>
 #include <QDBusConnection>
 #include <QDBusMessage>
+#include <QHash>
 #include <QString>
 
 class AppArmorContext {
@@ -14,7 +14,7 @@
     QString getPeerSecurityContext(const QDBusConnection &bus, const QDBusMessage &message);
 
 private:
-    std::map<QString,QString> contexts;
+    QHash<QString,QString> m_contexts;
 };
 
 #endif

=== modified file 'src/daemon/main.cpp'
--- src/daemon/main.cpp	2015-02-10 06:24:38 +0000
+++ src/daemon/main.cpp	2015-02-11 12:59:36 +0000
@@ -1,7 +1,8 @@
 #include "manager.h"
 #include "manageradaptor.h"
 
-int main(int argc, char **argv) {
+int main(int argc, char **argv)
+{
     QCoreApplication app(argc, argv);
 
     qDBusRegisterMetaType<AccountInfo>();

=== modified file 'src/daemon/manager.cpp'
--- src/daemon/manager.cpp	2015-02-10 06:24:38 +0000
+++ src/daemon/manager.cpp	2015-02-11 12:59:36 +0000
@@ -1,40 +1,50 @@
 #include "manager.h"
+
+#include <QDBusMessage>
 #include <QDebug>
-#include <QDBusMessage>
 #include "aacontext.h"
 
-using namespace std;
-
 static const char FORBIDDEN_ERROR[] = "com.ubuntu.OnlineAccounts.Error.Forbidden";
 
-QDBusArgument &operator<<(QDBusArgument &argument, const AccountInfo &info) {
-    argument.beginStructure();
-    argument << info.account_id << info.details;
-    argument.endStructure();
-    return argument;
-}
-
-const QDBusArgument &operator>>(const QDBusArgument &argument, AccountInfo &info) {
-    argument.beginStructure();
-    argument >> info.account_id >> info.details;
-    argument.endStructure();
-    return argument;
-}
-
-
-struct Manager::Private {
-    AppArmorContext apparmor;
+QDBusArgument &operator<<(QDBusArgument &argument, const AccountInfo &info)
+{
+    argument.beginStructure();
+    argument << info.accountId << info.details;
+    argument.endStructure();
+    return argument;
+}
+
+const QDBusArgument &operator>>(const QDBusArgument &argument,
+                                AccountInfo &info)
+{
+    argument.beginStructure();
+    argument >> info.accountId >> info.details;
+    argument.endStructure();
+    return argument;
+}
+
+class ManagerPrivate {
+public:
+    AppArmorContext m_apparmor;
 };
 
-Manager::Manager(QObject *parent)
-    : QObject(parent), p(new Private) {
-}
-
-Manager::~Manager() {
-}
-
-bool Manager::canAccess(const QString &service_id) {
-    QString context = p->apparmor.getPeerSecurityContext(connection(), message());
+Manager::Manager(QObject *parent):
+    QObject(parent),
+    d_ptr(new ManagerPrivate)
+{
+}
+
+Manager::~Manager()
+{
+    delete d_ptr;
+}
+
+bool Manager::canAccess(const QString &serviceId)
+{
+    Q_D(Manager);
+
+    QString context = d->m_apparmor.getPeerSecurityContext(connection(),
+                                                           message());
     // Could not determine peer's AppArmor context, so deny access
     if (context.isEmpty()) {
         return false;
@@ -55,24 +65,27 @@
     // Do the same on the service ID: we are only dealing with
     // confined apps at this point, so only $pkgname prefixed
     // services are accessible.
-    pos = service_id.indexOf('_');
+    pos = serviceId.indexOf('_');
     if (pos < 0) {
         return false;
     }
-    return service_id.left(pos) == pkgname;
+    return serviceId.left(pos) == pkgname;
 }
 
-bool Manager::checkAccess(const QString &service_id) {
-    bool has_access = canAccess(service_id);
-    if (!has_access) {
-        sendErrorReply(FORBIDDEN_ERROR, QString("Access to service ID %1 forbidden").arg(service_id));
+bool Manager::checkAccess(const QString &serviceId)
+{
+    bool hasAccess = canAccess(serviceId);
+    if (!hasAccess) {
+        sendErrorReply(FORBIDDEN_ERROR,
+                       QString("Access to service ID %1 forbidden").arg(serviceId));
     }
-    return has_access;
+    return hasAccess;
 }
 
-QList<AccountInfo> Manager::GetAccounts(const QStringList &service_ids) {
-    for (const auto &service_id : service_ids) {
-        if (!checkAccess(service_id)) {
+QList<AccountInfo> Manager::GetAccounts(const QStringList &serviceIds)
+{
+    Q_FOREACH(const QString &serviceId, serviceIds) {
+        if (!checkAccess(serviceId)) {
             return QList<AccountInfo>();
         }
     }
@@ -80,24 +93,36 @@
     return QList<AccountInfo>({AccountInfo(0, QVariantMap())});
 }
 
-AccountInfo Manager::GetAccountInfo(const QString &service_id, uint account_id) {
-    if (!checkAccess(service_id)) {
+AccountInfo Manager::GetAccountInfo(const QString &serviceId, uint accountId)
+{
+    Q_UNUSED(accountId);
+
+    if (!checkAccess(serviceId)) {
         return AccountInfo();
     }
 
-    return AccountInfo(account_id, QVariantMap());
+    return AccountInfo(accountId, QVariantMap());
 }
 
-QVariantMap Manager::Authenticate(const QString &service_id, uint account_id, bool interactive, bool invalidate) {
-    if (!checkAccess(service_id)) {
+QVariantMap Manager::Authenticate(const QString &serviceId, uint accountId,
+                                  bool interactive, bool invalidate)
+{
+    Q_UNUSED(accountId);
+    Q_UNUSED(interactive);
+    Q_UNUSED(invalidate);
+
+    if (!checkAccess(serviceId)) {
         return QVariantMap();
     }
 
     return QVariantMap();
 }
 
-AccountInfo Manager::Register(const QString &service_id, QVariantMap &credentials) {
-    if (!checkAccess(service_id)) {
+AccountInfo Manager::Register(const QString &serviceId, QVariantMap &credentials)
+{
+    Q_UNUSED(credentials);
+
+    if (!checkAccess(serviceId)) {
         return AccountInfo();
     }
 

=== modified file 'src/daemon/manager.h'
--- src/daemon/manager.h	2015-02-10 06:24:38 +0000
+++ src/daemon/manager.h	2015-02-11 12:59:36 +0000
@@ -1,50 +1,53 @@
-
 #ifndef MANAGER_H
 #define MANAGER_H
 
-#include <memory>
+#include <QDBusArgument>
+#include <QDBusContext>
 #include <QList>
 #include <QObject>
 #include <QVariantMap>
-#include <QDBusArgument>
-#include <QDBusContext>
 
 struct AccountInfo {
-    uint account_id = 0;
+    uint accountId;
     QVariantMap details;
 
-    AccountInfo() {}
-    AccountInfo(uint account_id, const QVariantMap &details)
-        : account_id(account_id), details(details) {}
-
+    AccountInfo(): accountId(0) {}
+    AccountInfo(uint accountId, const QVariantMap &details):
+        accountId(accountId), details(details) {}
 };
 Q_DECLARE_METATYPE(AccountInfo)
 
 QDBusArgument &operator<<(QDBusArgument &argument, const AccountInfo &info);
-const QDBusArgument &operator>>(const QDBusArgument &argument, AccountInfo &info);
+const QDBusArgument &operator>>(const QDBusArgument &argument,
+                                AccountInfo &info);
 
-class Manager : public QObject, protected QDBusContext {
+class ManagerPrivate;
+class Manager: public QObject, protected QDBusContext
+{
     Q_OBJECT
-    struct Private;
+
 public:
-    explicit Manager(QObject *parent=nullptr);
+    explicit Manager(QObject *parent = 0);
     ~Manager();
 
 public Q_SLOTS:
-    QList<AccountInfo> GetAccounts(const QStringList &service_ids);
-    AccountInfo GetAccountInfo(const QString &service_id, uint account_id);
-    QVariantMap Authenticate(const QString &service_id, uint account_id, bool interactive, bool invalidate);
-    AccountInfo Register(const QString &service_id, QVariantMap &credentials);
+    QList<AccountInfo> GetAccounts(const QStringList &serviceIds);
+    AccountInfo GetAccountInfo(const QString &serviceId, uint accountId);
+    QVariantMap Authenticate(const QString &serviceId, uint accountId,
+                             bool interactive, bool invalidate);
+    AccountInfo Register(const QString &serviceId, QVariantMap &credentials);
 
 Q_SIGNALS:
-    void AccountChanged(const QString &service_id, uint account_id, bool enabled);
-    void CredentialsChanged(const QString &service_id, uint account_id);
+    void AccountChanged(const QString &serviceId, uint accountId, bool enabled);
+    void CredentialsChanged(const QString &serviceId, uint accountId);
 
 private:
-    bool canAccess(const QString &service_id);
-    bool checkAccess(const QString &service_id);
+    bool canAccess(const QString &serviceId);
+    bool checkAccess(const QString &serviceId);
     QString getPeerSecurityContext();
-    std::unique_ptr<Private> p;
+
+    Q_DECLARE_PRIVATE(Manager)
+    ManagerPrivate *d_ptr;
 };
 
 #endif