1 files changed, 3 insertions, 3 deletions
diff --git a/Swiften/Disco/FeatureOracle.cpp b/Swiften/Disco/FeatureOracle.cpp
index 2baf87c..63f7a4e 100644
--- a/Swiften/Disco/FeatureOracle.cpp
+++ b/Swiften/Disco/FeatureOracle.cpp
@@ -1,32 +1,32 @@
 /*
- * Copyright (c) 2015-2016 Isode Limited.
+ * Copyright (c) 2015-2017 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #include <Swiften/Disco/FeatureOracle.h>
 
 #include <algorithm>
 #include <iterator>
 #include <unordered_set>
 #include <vector>
 
 #include <Swiften/Base/Log.h>
 #include <Swiften/Disco/EntityCapsProvider.h>
 #include <Swiften/Elements/Idle.h>
 #include <Swiften/Elements/Presence.h>
 #include <Swiften/FileTransfer/FileTransferManager.h>
 #include <Swiften/JID/JID.h>
 #include <Swiften/Presence/PresenceOracle.h>
 
 namespace Swift {
 
 FeatureOracle::FeatureOracle(EntityCapsProvider* capsProvider, PresenceOracle* presenceOracle) : capsProvider_(capsProvider), presenceOracle_(presenceOracle) {
 }
 
 Tristate FeatureOracle::isFileTransferSupported(const JID& jid) {
     Tristate fileTransferSupported = No;
 
     auto isYesOrMaybe = [](Tristate tristate) { return tristate == Yes || tristate == Maybe; };
     auto isYes = [](Tristate tristate) { return tristate == Yes; };
 
@@ -127,75 +127,75 @@ class PresenceFeatureAvailablityComparator {
 JID FeatureOracle::getMostAvailableClientForFileTrasfer(const JID& bareJID) {
     JID fullJID;
     assert(bareJID.isBare());
 
     std::vector<Presence::ref> allPresences =  presenceOracle_->getAllPresence(bareJID);
     std::sort(allPresences.begin(), allPresences.end(), PresenceFeatureAvailablityComparator());
 
     for (const auto& presence : allPresences) {
         if (presence->isAvailable()) {
             if (isFileTransferSupported(presence->getFrom()) == Yes) {
                 fullJID = presence->getFrom();
                 break;
             }
         }
     }
 
     SWIFT_LOG_ASSERT(!fullJID.isBare(), error);
     return fullJID;
 }
 
 std::unordered_map<std::string, Tristate> FeatureOracle::getFeaturesForJID(const JID& jid) {
     std::unordered_map<std::string, Tristate> supportedFeatures;
     if (jid.isBare()) {
         // Calculate the union of disco features of all most available results and return that.
         std::vector<DiscoInfo::ref> onlineDiscoInfos;
         std::unordered_set<std::string> features;
 
         // Collect relevant disco info results and the set of features.
         for (auto&& presence : presenceOracle_->getAllPresence(jid)) {
             if (presence->getType() == Presence::Available) {
-                DiscoInfo::ref presenceDiscoInfo = capsProvider_->getCaps(presence->getFrom());
+                DiscoInfo::ref presenceDiscoInfo = capsProvider_->getCapsCached(presence->getFrom());
                 if (presenceDiscoInfo) {
                     onlineDiscoInfos.push_back(presenceDiscoInfo);
                     features.insert(presenceDiscoInfo->getFeatures().begin(), presenceDiscoInfo->getFeatures().end());
                 }
             }
         }
 
         // Calculate supportedFeaturesMap.
         for (auto&& feature : features) {
             Tristate supported = Yes;
             for (auto&& discoInfo : onlineDiscoInfos) {
                 if (!discoInfo->hasFeature(feature)) {
                     supported = Maybe;
                     break;
                 }
             }
             supportedFeatures[feature] = supported;
         }
     }
     else {
         // Return the disco result of the full JID.
-        auto discoInfo = capsProvider_->getCaps(jid);
+        auto discoInfo = capsProvider_->getCapsCached(jid);
         if (discoInfo) {
             for (auto&& feature : discoInfo->getFeatures()) {
                 supportedFeatures[feature] = Yes;
             }
         }
     }
 
     return supportedFeatures;
 }
 
 Tristate FeatureOracle::isFeatureSupported(const std::unordered_map<std::string, Tristate>& supportedFeatures, const std::string& feature) {
     Tristate supported = No;
     auto lookupResult = supportedFeatures.find(feature);
     if (lookupResult != supportedFeatures.end()) {
         supported = lookupResult->second;
     }
     return supported;
 }
 
 }