diff --git a/drm/1.0/default/CryptoFactory.cpp b/drm/1.0/default/CryptoFactory.cpp
index 13cad67..e46233d 100644
--- a/drm/1.0/default/CryptoFactory.cpp
+++ b/drm/1.0/default/CryptoFactory.cpp
@@ -15,11 +15,10 @@
  */
 #define LOG_TAG "android.hardware.drm@1.0-impl"
 
-#include <utils/Log.h>
-
 #include "CryptoFactory.h"
 #include "CryptoPlugin.h"
 #include "TypeConvert.h"
+#include <utils/Log.h>
 
 namespace android {
 namespace hardware {
@@ -27,63 +26,45 @@
 namespace V1_0 {
 namespace implementation {
 
-CryptoFactory::CryptoFactory() :
-    trebleLoader("/vendor/lib/hw", "createCryptoFactory"),
-    legacyLoader("/vendor/lib/mediadrm", "createCryptoFactory") {
-}
-
-// Methods from ::android::hardware::drm::V1_0::ICryptoFactory follow.
-Return<bool> CryptoFactory::isCryptoSchemeSupported(
-        const hidl_array<uint8_t, 16>& uuid) {
-    return isCryptoSchemeSupported(trebleLoader, uuid) ||
-            isCryptoSchemeSupported(legacyLoader, uuid);
-}
-
-Return<void> CryptoFactory::createPlugin(const hidl_array<uint8_t, 16>& uuid,
-        const hidl_vec<uint8_t>& initData, createPlugin_cb _hidl_cb) {
-    sp<ICryptoPlugin> plugin = createTreblePlugin(uuid, initData);
-    if (plugin == nullptr) {
-        plugin = createLegacyPlugin(uuid, initData);
+    CryptoFactory::CryptoFactory() :
+        loader("/vendor/lib/mediadrm", "createCryptoFactory") {
     }
-    _hidl_cb(plugin != nullptr ? Status::OK : Status::ERROR_DRM_CANNOT_HANDLE, plugin);
-    return Void();
-}
 
-sp<ICryptoPlugin> CryptoFactory::createTreblePlugin(const hidl_array<uint8_t, 16>& uuid,
-        const hidl_vec<uint8_t>& initData) {
-    sp<ICryptoPlugin> plugin;
-    for (size_t i = 0; i < trebleLoader.factoryCount(); i++) {
-        Return<void> hResult = trebleLoader.getFactory(i)->createPlugin(uuid, initData,
-                [&](Status status, const sp<ICryptoPlugin>& hPlugin) {
-                    if (status == Status::OK) {
-                        plugin = hPlugin;
-                    }
+    // Methods from ::android::hardware::drm::V1_0::ICryptoFactory follow.
+    Return<bool> CryptoFactory::isCryptoSchemeSupported(
+            const hidl_array<uint8_t, 16>& uuid) {
+        for (size_t i = 0; i < loader.factoryCount(); i++) {
+            if (loader.getFactory(i)->isCryptoSchemeSupported(uuid.data())) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    Return<void> CryptoFactory::createPlugin(const hidl_array<uint8_t, 16>& uuid,
+            const hidl_vec<uint8_t>& initData, createPlugin_cb _hidl_cb) {
+        for (size_t i = 0; i < loader.factoryCount(); i++) {
+            if (loader.getFactory(i)->isCryptoSchemeSupported(uuid.data())) {
+                android::CryptoPlugin *legacyPlugin = NULL;
+                status_t status = loader.getFactory(i)->createPlugin(uuid.data(),
+                        initData.data(), initData.size(), &legacyPlugin);
+                CryptoPlugin *newPlugin = NULL;
+                if (legacyPlugin == NULL) {
+                    ALOGE("Crypto legacy HAL: failed to create crypto plugin");
+                } else {
+                    newPlugin = new CryptoPlugin(legacyPlugin);
                 }
-            );
-        if (plugin != nullptr) {
-            return plugin;
+                _hidl_cb(toStatus(status), newPlugin);
+                return Void();
+            }
         }
+        _hidl_cb(Status::ERROR_DRM_CANNOT_HANDLE, NULL);
+        return Void();
     }
-    return nullptr;
-}
 
-sp<ICryptoPlugin> CryptoFactory::createLegacyPlugin(const hidl_array<uint8_t, 16>& uuid,
-        const hidl_vec<uint8_t>& initData) {
-    android::CryptoPlugin *legacyPlugin = nullptr;
-    for (size_t i = 0; i < legacyLoader.factoryCount(); i++) {
-        legacyLoader.getFactory(i)->createPlugin(uuid.data(),
-                initData.data(), initData.size(), &legacyPlugin);
-        if (legacyPlugin) {
-            return new CryptoPlugin(legacyPlugin);
-        }
+    ICryptoFactory* HIDL_FETCH_ICryptoFactory(const char* /* name */) {
+        return new CryptoFactory();
     }
-    return nullptr;
-}
-
-
-ICryptoFactory* HIDL_FETCH_ICryptoFactory(const char* /* name */) {
-    return new CryptoFactory();
-}
 
 }  // namespace implementation
 }  // namespace V1_0
diff --git a/drm/1.0/default/CryptoFactory.h b/drm/1.0/default/CryptoFactory.h
index d774406..412b557 100644
--- a/drm/1.0/default/CryptoFactory.h
+++ b/drm/1.0/default/CryptoFactory.h
@@ -41,7 +41,8 @@
     CryptoFactory();
     virtual ~CryptoFactory() {}
 
-    // Methods from ::android::hardware::drmn::V1_0::ICryptoFactory follow.
+    // Methods from ::android::hardware::drm::V1_0::ICryptoFactory follow.
+
     Return<bool> isCryptoSchemeSupported(const hidl_array<uint8_t, 16>& uuid)
             override;
 
@@ -50,27 +51,7 @@
             override;
 
 private:
-    template <typename L> Return<bool> isCryptoSchemeSupported(
-            const L& loader, const hidl_array<uint8_t, 16>& uuid) {
-        for (size_t i = 0; i < loader.factoryCount(); i++) {
-           if (loader.getFactory(i)->isCryptoSchemeSupported(uuid.data())) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    sp<ICryptoPlugin> createTreblePlugin(const hidl_array<uint8_t, 16>& uuid,
-                    const hidl_vec<uint8_t>& initData);
-
-    sp<ICryptoPlugin> createLegacyPlugin(const hidl_array<uint8_t, 16>& uuid,
-                    const hidl_vec<uint8_t>& initData);
-
-    typedef android::PluginLoader<ICryptoFactory> PluginLoader;
-    PluginLoader trebleLoader;
-
-    typedef android::PluginLoader<android::CryptoFactory> LegacyLoader;
-    LegacyLoader legacyLoader;
+    android::PluginLoader<android::CryptoFactory> loader;
 
     CryptoFactory(const CryptoFactory &) = delete;
     void operator=(const CryptoFactory &) = delete;
diff --git a/drm/1.0/default/DrmFactory.cpp b/drm/1.0/default/DrmFactory.cpp
index c98c1da..92f54f1 100644
--- a/drm/1.0/default/DrmFactory.cpp
+++ b/drm/1.0/default/DrmFactory.cpp
@@ -15,11 +15,10 @@
  */
 #define LOG_TAG "android.hardware.drm@1.0-impl"
 
-#include <utils/Log.h>
-
 #include "DrmFactory.h"
 #include "DrmPlugin.h"
 #include "TypeConvert.h"
+#include <utils/Log.h>
 
 namespace android {
 namespace hardware {
@@ -27,66 +26,56 @@
 namespace V1_0 {
 namespace implementation {
 
-DrmFactory::DrmFactory() :
-    trebleLoader("/vendor/lib/hw", "createDrmFactory"),
-    legacyLoader("/vendor/lib/mediadrm", "createDrmFactory") {
-}
+    DrmFactory::DrmFactory() :
+        loader("/vendor/lib/mediadrm", "createDrmFactory") {
+    }
 
-// Methods from ::android::hardware::drm::V1_0::IDrmFactory follow.
-Return<bool> DrmFactory::isCryptoSchemeSupported(
-        const hidl_array<uint8_t, 16>& uuid) {
-    return isCryptoSchemeSupported(trebleLoader, uuid) ||
-            isCryptoSchemeSupported(legacyLoader, uuid);
-}
+    // Methods from ::android::hardware::drm::V1_0::IDrmFactory follow.
+    Return<bool> DrmFactory::isCryptoSchemeSupported (
+            const hidl_array<uint8_t, 16>& uuid) {
+        for (size_t i = 0; i < loader.factoryCount(); i++) {
+            if (loader.getFactory(i)->isCryptoSchemeSupported(uuid.data())) {
+                return true;
+            }
+        }
+        return false;
+    }
 
-Return<bool> DrmFactory::isContentTypeSupported (
-        const hidl_string& mimeType) {
-    return isContentTypeSupported<PluginLoader, hidl_string>(trebleLoader, mimeType) ||
-            isContentTypeSupported<LegacyLoader, String8>(legacyLoader, mimeType);
-}
+    Return<bool> DrmFactory::isContentTypeSupported (
+            const hidl_string& mimeType) {
+        for (size_t i = 0; i < loader.factoryCount(); i++) {
+            if (loader.getFactory(i)->isContentTypeSupported(String8(mimeType.c_str()))) {
+                return true;
+            }
+        }
+        return false;
+    }
 
     Return<void> DrmFactory::createPlugin(const hidl_array<uint8_t, 16>& uuid,
             const hidl_string& appPackageName, createPlugin_cb _hidl_cb) {
-        sp<IDrmPlugin> plugin = createTreblePlugin(uuid, appPackageName);
-    if (plugin == nullptr) {
-        plugin = createLegacyPlugin(uuid);
-    }
-    _hidl_cb(plugin != nullptr ? Status::OK : Status::ERROR_DRM_CANNOT_HANDLE, plugin);
-    return Void();
-}
 
-sp<IDrmPlugin> DrmFactory::createTreblePlugin(const hidl_array<uint8_t, 16>& uuid,
-        const hidl_string& appPackageName) {
-    sp<IDrmPlugin> plugin;
-    for (size_t i = 0; i < trebleLoader.factoryCount(); i++) {
-        Return<void> hResult = trebleLoader.getFactory(i)->createPlugin(uuid,
-                appPackageName, [&](Status status, const sp<IDrmPlugin>& hPlugin) {
-                    if (status == Status::OK) {
-                        plugin = hPlugin;
-                    }
+        for (size_t i = 0; i < loader.factoryCount(); i++) {
+            if (loader.getFactory(i)->isCryptoSchemeSupported(uuid.data())) {
+                android::DrmPlugin *legacyPlugin = NULL;
+                status_t status = loader.getFactory(i)->createDrmPlugin(
+                        uuid.data(), &legacyPlugin);
+                DrmPlugin *newPlugin = NULL;
+                if (legacyPlugin == NULL) {
+                    ALOGE("Drm legacy HAL: failed to create drm plugin");
+                } else {
+                    newPlugin = new DrmPlugin(legacyPlugin);
                 }
-            );
-        if (plugin != nullptr) {
-            return plugin;
+                _hidl_cb(toStatus(status), newPlugin);
+                return Void();
+            }
         }
+        _hidl_cb(Status::ERROR_DRM_CANNOT_HANDLE, NULL);
+        return Void();
     }
-    return nullptr;
-}
 
-sp<IDrmPlugin> DrmFactory::createLegacyPlugin(const hidl_array<uint8_t, 16>& uuid) {
-    android::DrmPlugin *legacyPlugin = nullptr;
-    for (size_t i = 0; i < legacyLoader.factoryCount(); i++) {
-        legacyLoader.getFactory(i)->createDrmPlugin(uuid.data(), &legacyPlugin);
-        if (legacyPlugin) {
-            return new DrmPlugin(legacyPlugin);
-        }
+    IDrmFactory* HIDL_FETCH_IDrmFactory(const char* /* name */) {
+        return new DrmFactory();
     }
-    return nullptr;
-}
-
-IDrmFactory* HIDL_FETCH_IDrmFactory(const char* /* name */) {
-    return new DrmFactory();
-}
 
 }  // namespace implementation
 }  // namespace V1_0
diff --git a/drm/1.0/default/DrmFactory.h b/drm/1.0/default/DrmFactory.h
index 2e71624..a008844 100644
--- a/drm/1.0/default/DrmFactory.h
+++ b/drm/1.0/default/DrmFactory.h
@@ -42,45 +42,18 @@
     virtual ~DrmFactory() {}
 
     // Methods from ::android::hardware::drm::V1_0::IDrmFactory follow.
+
     Return<bool> isCryptoSchemeSupported(const hidl_array<uint8_t, 16>& uuid)
             override;
 
-    Return<bool> isContentTypeSupported(const hidl_string& mimeType)
+    Return<bool> isContentTypeSupported(const hidl_string &mimeType)
             override;
 
     Return<void> createPlugin(const hidl_array<uint8_t, 16>& uuid,
             const hidl_string& appPackageName, createPlugin_cb _hidl_cb) override;
 
 private:
-    template <typename L> Return<bool> isCryptoSchemeSupported(
-            const L& loader, const hidl_array<uint8_t, 16>& uuid) {
-        for (size_t i = 0; i < loader.factoryCount(); i++) {
-            if (loader.getFactory(i)->isCryptoSchemeSupported(uuid.data())) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    template <typename L, typename S> Return<bool> isContentTypeSupported(
-            const L& loader, const hidl_string& mimeType) {
-        for (size_t i = 0; i < loader.factoryCount(); i++) {
-            if (loader.getFactory(i)->isContentTypeSupported(S(mimeType))) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    sp<IDrmPlugin> createTreblePlugin(const hidl_array<uint8_t, 16>& uuid,
-        const hidl_string& appPackageName);
-    sp<IDrmPlugin> createLegacyPlugin(const hidl_array<uint8_t, 16>& uuid);
-
-    typedef android::PluginLoader<IDrmFactory> PluginLoader;
-    PluginLoader trebleLoader;
-
-    typedef android::PluginLoader<android::DrmFactory> LegacyLoader;
-    LegacyLoader legacyLoader;
+    android::PluginLoader<android::DrmFactory> loader;
 
     DrmFactory(const DrmFactory &) = delete;
     void operator=(const DrmFactory &) = delete;