Removed fulfilling of purely internal promises in ServiceRegistry.

Relevant code parts in DBusServiceRegistry.cpp were tagged with "fulfill
all open promises on object path resolution". Removed as it seemed to be
unnecessary and required error handling to be enabled, which may well
not be the case in context of the HMI.

Change-Id: Icddad61f50cbd8fccaeab0c6782b4966bd7b2505

3 files changed, 17 insertions, 70 deletions

diff --git a/src/CommonAPI/DBus/DBusServiceRegistry.cpp b/src/CommonAPI/DBus/DBusServiceRegistry.cpp
index 8178bca..3f9c310 100644
--- a/src/CommonAPI/DBus/DBusServiceRegistry.cpp
+++ b/src/CommonAPI/DBus/DBusServiceRegistry.cpp
@@ -18,7 +18,9 @@ namespace DBus {
 DBusServiceRegistry::DBusServiceRegistry(std::shared_ptr<DBusProxyConnection> dbusProxyConnection) :
                 dbusDaemonProxy_(std::make_shared<CommonAPI::DBus::DBusDaemonProxy>(dbusProxyConnection)),
                 initialized_(false),
-                notificationThread_() {
+                notificationThread_(),
+                servicesToResolve(0),
+                objectPathsToResolve(0) {
 }
 
 DBusServiceRegistry::~DBusServiceRegistry() {
@@ -33,16 +35,6 @@ DBusServiceRegistry::~DBusServiceRegistry() {
     for (auto& dbusServiceListenersIterator : dbusServiceListenersMap) {
         auto& dbusServiceListenersRecord = dbusServiceListenersIterator.second;
 
-        // fulfill all open promises
-        std::promise<DBusRecordState> promiseOnResolve = std::move(dbusServiceListenersRecord.promiseOnResolve);
-
-        try {
-            std::future<DBusRecordState> futureOnResolve = promiseOnResolve.get_future();
-            if(!futureOnResolve.valid()) {
-                promiseOnResolve.set_value(DBusRecordState::NOT_AVAILABLE);
-            }
-        } catch (std::future_error& e) { }
-
         if (dbusServiceListenersRecord.uniqueBusNameState == DBusRecordState::RESOLVED) {
             onDBusServiceNotAvailable(dbusServiceListenersRecord);
         }
@@ -130,6 +122,7 @@ DBusServiceRegistry::DBusServiceSubscription DBusServiceRegistry::subscribeAvail
                 break;
             default:
                 availabilityStatus = AvailabilityStatus::UNKNOWN;
+                break;
         }
     }
 
@@ -221,12 +214,12 @@ bool DBusServiceRegistry::isServiceInstanceAlive(const std::string& dbusInterfac
 
     findCachedDbusService(dbusServiceName, &dbusUniqueNameRecord);
 
-    if(dbusUniqueNameRecord != NULL) {
+    if (dbusUniqueNameRecord != NULL) {
         uniqueName = dbusUniqueNameRecord->uniqueName;
         uniqueNameFound = true;
     }
 
-    if(!uniqueNameFound) {
+    if (!uniqueNameFound) {
         DBusServiceListenersRecord dbusServiceListenersRecord;
         dbusServiceListenersRecord.uniqueBusNameState = DBusRecordState::RESOLVING;
 
@@ -234,7 +227,8 @@ bool DBusServiceRegistry::isServiceInstanceAlive(const std::string& dbusInterfac
         std::unordered_map<std::string, DBusServiceListenersRecord>::value_type value(dbusServiceName, std::move(dbusServiceListenersRecord));
         auto insertedDbusServiceListenerRecord = dbusServiceListenersMap.insert(std::move(value));
 
-        if(insertedDbusServiceListenerRecord.second) { // if dbusServiceListenerRecord was inserted, start resolving
+        // start resolving only if dbusServiceListenerRecord was inserted, i.e. it is a new service that appeared
+        if (insertedDbusServiceListenerRecord.second) {
             resolveDBusServiceName(dbusServiceName, dbusServiceListenersMap[dbusServiceName]);
         }
 
@@ -276,13 +270,12 @@ bool DBusServiceRegistry::isServiceInstanceAlive(const std::string& dbusInterfac
 
     assert(dbusUniqueNameRecord != NULL);
 
-    auto* dbusObjectPathsCache = &(dbusUniqueNameRecord->dbusObjectPathsCache);
-    auto dbusObjectPathCacheIterator = dbusObjectPathsCache->find(dbusObjectPath);
+    auto& dbusObjectPathsCache = dbusUniqueNameRecord->dbusObjectPathsCache;
+    auto dbusObjectPathCacheIterator = dbusObjectPathsCache.find(dbusObjectPath);
 
     DBusObjectPathCache* dbusObjectPathCache = NULL;
 
-
-    if(dbusObjectPathCacheIterator != dbusObjectPathsCache->end()) {
+    if(dbusObjectPathCacheIterator != dbusObjectPathsCache.end()) {
         dbusObjectPathCache = &(dbusObjectPathCacheIterator->second);
     }
     else {
@@ -291,11 +284,10 @@ bool DBusServiceRegistry::isServiceInstanceAlive(const std::string& dbusInterfac
         newDbusObjectPathCache.state = DBusRecordState::RESOLVING;
 
         dbusServicesMutex_.lock();
-        //std::unordered_map<std::string, DBusObjectPathCache>::value_type value(dbusObjectPath, std::move(newDbusObjectPathCache));
-        //auto dbusObjectPathCacheInserted = dbusObjectPathsCache->insert(std::move({dbusObjectPath, std::move(newDbusObjectPathCache)}));
-                        dbusObjectPathsCache->insert(std::make_pair(dbusObjectPath, std::move(newDbusObjectPathCache)));
 
-        dbusObjectPathCacheIterator = dbusObjectPathsCache->find(dbusObjectPath);
+        dbusObjectPathsCache.insert(std::make_pair(dbusObjectPath, std::move(newDbusObjectPathCache)));
+
+        dbusObjectPathCacheIterator = dbusObjectPathsCache.find(dbusObjectPath);
 
         dbusObjectPathCache = &(dbusObjectPathCacheIterator->second);
 
@@ -959,32 +951,13 @@ void DBusServiceRegistry::onDBusServiceNotAvailable(DBusServiceListenersRecord&
 
     const DBusUniqueNamesMapIterator dbusUniqueNameRecordIterator = dbusUniqueNamesMap_.find(dbusServiceListenersRecord.uniqueBusName);
 
-    // fulfill all open promises on object path resolution
     if (dbusUniqueNameRecordIterator != dbusUniqueNamesMap_.end()) {
-        DBusUniqueNameRecord& dbusUniqueNameRecord = dbusUniqueNameRecordIterator->second;
-        for (auto dbusObjectPathsCacheIterator = dbusUniqueNameRecord.dbusObjectPathsCache.begin();
-                        dbusObjectPathsCacheIterator != dbusUniqueNameRecord.dbusObjectPathsCache.end();
-                        dbusObjectPathsCacheIterator++) {
-
-            auto& dbusObjectPathsCache = dbusObjectPathsCacheIterator->second;
-
-            std::promise<DBusRecordState> promiseOnResolve = std::move(dbusObjectPathsCache.promiseOnResolve);
-
-            try {
-                std::future<DBusRecordState> futureOnResolve = promiseOnResolve.get_future();
-                if(!futureOnResolve.valid()) {
-                    promiseOnResolve.set_value(DBusRecordState::NOT_AVAILABLE);
-                }
-            } catch (std::future_error& e) { }
-        }
-
         removeUniqueName(dbusUniqueNameRecordIterator);
     }
 
     dbusServiceListenersRecord.uniqueBusName.clear();
     dbusServiceListenersRecord.uniqueBusNameState = DBusRecordState::NOT_AVAILABLE;
 
-
     for (auto dbusObjectPathListenersIterator = dbusServiceListenersRecord.dbusObjectPathListenersMap.begin();
                     dbusObjectPathListenersIterator != dbusServiceListenersRecord.dbusObjectPathListenersMap.end(); ) {
         auto& dbusInterfaceNameListenersMap = dbusObjectPathListenersIterator->second;
diff --git a/src/CommonAPI/DBus/DBusServiceRegistry.h b/src/CommonAPI/DBus/DBusServiceRegistry.h
index 6fdbc3c..4c90091 100644
--- a/src/CommonAPI/DBus/DBusServiceRegistry.h
+++ b/src/CommonAPI/DBus/DBusServiceRegistry.h
@@ -106,8 +106,6 @@ class DBusServiceRegistry: public std::enable_shared_from_this<DBusServiceRegist
 
     virtual SubscriptionStatus onSignalDBusMessage(const DBusMessage&);
 
-//    std::vector<std::string> getManagedObjects(const std::string& connectionName, const std::string& objectpath);
-
  private:
     struct DBusInterfaceNameListenersRecord {
         DBusInterfaceNameListenersRecord(): state(DBusRecordState::UNKNOWN) {
@@ -127,7 +125,6 @@ class DBusServiceRegistry: public std::enable_shared_from_this<DBusServiceRegist
 
     struct DBusServiceListenersRecord {
         DBusServiceListenersRecord(): uniqueBusNameState(DBusRecordState::UNKNOWN),
-                        //futureOnResolve(),
                         mutexOnResolve() {
         }
 
@@ -138,14 +135,7 @@ class DBusServiceRegistry: public std::enable_shared_from_this<DBusServiceRegist
             futureOnResolve(std::move(other.futureOnResolve)),
             mutexOnResolve(std::move(other.mutexOnResolve)),
             dbusObjectPathListenersMap(std::move(other.dbusObjectPathListenersMap))
-        {
-            /*other.uniqueBusName = NULL;
-            other.promiseOnResolve = NULL;
-            other.futureOnResolve = NULL;
-            other.mutexOnResolve = NULL;
-            other.dbusObjectPathListenersMap = NULL;
-            other.dbusServiceListenersMap = NULL;*/
-        }
+        {}
 
         ~DBusServiceListenersRecord() {};
 
@@ -157,13 +147,6 @@ class DBusServiceRegistry: public std::enable_shared_from_this<DBusServiceRegist
         std::unique_lock<std::mutex>* mutexOnResolve;
 
         std::unordered_map<std::string, DBusInterfaceNameListenersMap> dbusObjectPathListenersMap;
-
-        /* per manager records: anser commonapi queries and update after dbus GetManagedObjects */
-//        typedef std::unordered_set<std::string> DBusObjectPathsSet;
-//        typedef std::pair<DBusObjectPathsSet, DBusManagedInterfaceListenerList> DBusManagedInterfaceRecord;
-//        typedef std::unordered_map<std::string, DBusManagedInterfaceRecord> DBusManagedInterfacesMap;
-//        typedef std::pair<DBusRecordState, DBusManagedInterfacesMap> DBusObjectManagerRecord;
-//        std::unordered_map<std::string, DBusObjectManagerRecord> dbusObjectManagersMap;
     };
 
     std::unordered_map<std::string, DBusServiceListenersRecord> dbusServiceListenersMap;
@@ -201,17 +184,12 @@ class DBusServiceRegistry: public std::enable_shared_from_this<DBusServiceRegist
             objectPathsState(other.objectPathsState),
             ownedBusNames(std::move(other.ownedBusNames)),
             dbusObjectPathsCache(std::move(other.dbusObjectPathsCache))
-        {
-            /*other.uniqueName = NULL;
-            other.ownedBusNames = NULL;
-            other.dbusObjectPathsCache = NULL;*/
-        }
+        {}
+
         std::string uniqueName;
         DBusRecordState objectPathsState;
         std::unordered_set<std::string> ownedBusNames;
         std::unordered_map<std::string, DBusObjectPathCache> dbusObjectPathsCache;
-
-        // TODO managed objects
     };
 
     std::unordered_map<std::string, DBusUniqueNameRecord> dbusUniqueNamesMap_;
diff --git a/src/test/DBusManagedTest.cpp b/src/test/DBusManagedTest.cpp
index 0b01016..867e0fd 100644
--- a/src/test/DBusManagedTest.cpp
+++ b/src/test/DBusManagedTest.cpp
@@ -679,10 +679,6 @@ TEST_F(DBusManagedTestExtended, RegisterLeafsWithDistinctInterfacesOnSameRootUnm
     runtime_->getServicePublisher()->unregisterService(branchAddress);
 }
 
-//XXX: Needs tests for invalid instances for the children.
-//XXX: Also later on need auto generated instance ID test and
-//XXX: If stub cannot manage, ensure the objectManager interface does not appear on dbus
-//XXX: Tests if configuration file is present
 #ifndef WIN32
 int main(int argc, char** argv) {
     ::testing::InitGoogleTest(&argc, argv);