diff --git a/drm/aidl/vts/Android.bp b/drm/aidl/vts/Android.bp
index 5b41830..190f60d 100644
--- a/drm/aidl/vts/Android.bp
+++ b/drm/aidl/vts/Android.bp
@@ -49,6 +49,8 @@
         "android.hardware.drm@1.0-helper",
         "android.hardware.drm-V1-ndk",
         "android.hardware.common-V2-ndk",
+        "libaidlcommonsupport",
+        "libgmock_ndk",
         "libdrmvtshelper",
         "libvtsclearkey",
     ],
diff --git a/drm/aidl/vts/drm_hal_common.cpp b/drm/aidl/vts/drm_hal_common.cpp
index 751c25b..9b315f4 100644
--- a/drm/aidl/vts/drm_hal_common.cpp
+++ b/drm/aidl/vts/drm_hal_common.cpp
@@ -22,9 +22,11 @@
 #include <sys/mman.h>
 #include <random>
 
+#include <aidlcommonsupport/NativeHandle.h>
 #include <android/binder_manager.h>
 #include <android/binder_process.h>
 #include <android/sharedmem.h>
+#include <cutils/native_handle.h>
 
 #include "drm_hal_clearkey_module.h"
 #include "drm_hal_common.h"
@@ -39,8 +41,7 @@
 
 using std::vector;
 using ::aidl::android::hardware::common::Ashmem;
-using ::aidl::android::hardware::drm::BufferType;
-using ::aidl::android::hardware::drm::DecryptResult;
+using ::aidl::android::hardware::drm::DecryptArgs;
 using ::aidl::android::hardware::drm::DestinationBuffer;
 using ::aidl::android::hardware::drm::EventType;
 using ::aidl::android::hardware::drm::ICryptoPlugin;
@@ -72,7 +73,6 @@
 }
 
 const char* kDrmIface = "android.hardware.drm.IDrmFactory";
-const char* kCryptoIface = "android.hardware.drm.ICryptoFactory";
 
 std::string HalFullName(const std::string& iface, const std::string& basename) {
     return iface + '/' + basename;
@@ -184,7 +184,6 @@
           test_info->name(), GetParamService().c_str());
 
     auto svc = GetParamService();
-    const string cryptoInstance = HalFullName(kCryptoIface, svc);
     const string drmInstance = HalFullName(kDrmIface, svc);
 
     if (drmInstance.find("IDrmFactory") != std::string::npos) {
@@ -192,12 +191,6 @@
                 ::ndk::SpAIBinder(AServiceManager_waitForService(drmInstance.c_str())));
         ASSERT_NE(drmFactory, nullptr);
         drmPlugin = createDrmPlugin();
-    }
-
-    if (cryptoInstance.find("ICryptoFactory") != std::string::npos) {
-        cryptoFactory = ICryptoFactory::fromBinder(
-                ::ndk::SpAIBinder(AServiceManager_waitForService(cryptoInstance.c_str())));
-        ASSERT_NE(cryptoFactory, nullptr);
         cryptoPlugin = createCryptoPlugin();
     }
 
@@ -211,14 +204,12 @@
     contentConfigurations = vendorModule->getContentConfigurations();
 
     // If drm scheme not installed skip subsequent tests
-    bool result = false;
-    drmFactory->isCryptoSchemeSupported({getUUID()}, "cenc", SecurityLevel::SW_SECURE_CRYPTO,
-                                        &result);
+    bool result = isCryptoSchemeSupported(getAidlUUID(), SecurityLevel::SW_SECURE_CRYPTO, "cenc");
     if (!result) {
         if (GetParamUUID() == std::array<uint8_t, 16>()) {
             GTEST_SKIP() << "vendor module drm scheme not supported";
         } else {
-            FAIL() << "param scheme must not supported";
+            FAIL() << "param scheme must be supported";
         }
     }
 
@@ -234,18 +225,18 @@
     }
     std::string packageName("aidl.android.hardware.drm.test");
     std::shared_ptr<::aidl::android::hardware::drm::IDrmPlugin> result;
-    auto ret = drmFactory->createPlugin({getUUID()}, packageName, &result);
+    auto ret = drmFactory->createDrmPlugin(getAidlUUID(), packageName, &result);
     EXPECT_OK(ret) << "createDrmPlugin remote call failed";
     return result;
 }
 
 std::shared_ptr<::aidl::android::hardware::drm::ICryptoPlugin> DrmHalTest::createCryptoPlugin() {
-    if (cryptoFactory == nullptr) {
+    if (drmFactory == nullptr) {
         return nullptr;
     }
     vector<uint8_t> initVec;
     std::shared_ptr<::aidl::android::hardware::drm::ICryptoPlugin> result;
-    auto ret = cryptoFactory->createPlugin({getUUID()}, initVec, &result);
+    auto ret = drmFactory->createCryptoPlugin(getAidlUUID(), initVec, &result);
     EXPECT_OK(ret) << "createCryptoPlugin remote call failed";
     return result;
 }
@@ -270,6 +261,26 @@
     return vendorModule->getUUID();
 }
 
+bool DrmHalTest::isCryptoSchemeSupported(Uuid uuid, SecurityLevel level, std::string mime) {
+    CryptoSchemes schemes{};
+    auto ret = drmFactory->getSupportedCryptoSchemes(&schemes);
+    EXPECT_OK(ret);
+    if (!ret.isOk() || !std::count(schemes.uuids.begin(), schemes.uuids.end(), uuid)) {
+        return false;
+    }
+    if (level > schemes.maxLevel || level < schemes.minLevel) {
+        if (level != SecurityLevel::DEFAULT && level != SecurityLevel::UNKNOWN) {
+            return false;
+        }
+    }
+    if (!mime.empty()) {
+        if (!std::count(schemes.mimeTypes.begin(), schemes.mimeTypes.end(), mime)) {
+            return false;
+        }
+    }
+    return true;
+}
+
 void DrmHalTest::provision() {
     std::string certificateType;
     std::string certificateAuthority;
@@ -410,38 +421,43 @@
 
 /**
  * getDecryptMemory allocates memory for decryption, then sets it
- * as a shared buffer base in the crypto hal.  A parcelable Ashmem
- * is returned.
+ * as a shared buffer base in the crypto hal. An output SharedBuffer
+ * is updated via reference.
  *
  * @param size the size of the memory segment to allocate
  * @param the index of the memory segment which will be used
  * to refer to it for decryption.
  */
-Ashmem DrmHalTest::getDecryptMemory(size_t size, size_t index) {
+void DrmHalTest::getDecryptMemory(size_t size, size_t index, SharedBuffer& out) {
+    out.bufferId = static_cast<int32_t>(index);
+    out.offset = 0;
+    out.size = static_cast<int64_t>(size);
+
     int fd = ASharedMemory_create("drmVtsSharedMemory", size);
     EXPECT_GE(fd, 0);
     EXPECT_EQ(size, ASharedMemory_getSize(fd));
+    auto handle = native_handle_create(1, 0);
+    handle->data[0] = fd;
+    out.handle = ::android::makeToAidl(handle);
 
-    Ashmem ashmem;
-    ashmem.fd = ::ndk::ScopedFileDescriptor(fd);
-    ashmem.size = size;
-    EXPECT_OK(cryptoPlugin->setSharedBufferBase(ashmem, index));
-    return ashmem;
+    EXPECT_OK(cryptoPlugin->setSharedBufferBase(out));
+    native_handle_delete(handle);
 }
 
-void DrmHalTest::fillRandom(const Ashmem& ashmem) {
+uint8_t* DrmHalTest::fillRandom(const ::aidl::android::hardware::drm::SharedBuffer& buf) {
     std::random_device rd;
     std::mt19937 rand(rd());
 
-    ::ndk::ScopedFileDescriptor fd = ashmem.fd.dup();
-    size_t size = ashmem.size;
+    auto fd = buf.handle.fds[0].get();
+    size_t size = buf.size;
     uint8_t* base = static_cast<uint8_t*>(
-            mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd.get(), 0));
+            mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0));
     EXPECT_NE(MAP_FAILED, base);
     for (size_t i = 0; i < size / sizeof(uint32_t); i++) {
         auto p = static_cast<uint32_t*>(static_cast<void*>(base));
         p[i] = rand();
     }
+    return base;
 }
 
 uint32_t DrmHalTest::decrypt(Mode mode, bool isSecure, const std::array<uint8_t, 16>& keyId,
@@ -453,6 +469,7 @@
     uint8_t localIv[AES_BLOCK_SIZE];
     memcpy(localIv, iv, AES_BLOCK_SIZE);
     vector<uint8_t> ivVec(localIv, localIv + AES_BLOCK_SIZE);
+    vector<uint8_t> keyIdVec(keyId.begin(), keyId.end());
 
     int64_t totalSize = 0;
     for (size_t i = 0; i < subSamples.size(); i++) {
@@ -463,32 +480,39 @@
     // The first totalSize bytes of shared memory is the encrypted
     // input, the second totalSize bytes (if exists) is the decrypted output.
     size_t factor = expectedStatus == Status::ERROR_DRM_FRAME_TOO_LARGE ? 1 : 2;
-    Ashmem sharedMemory = getDecryptMemory(totalSize * factor, kSegmentIndex);
+    SharedBuffer sourceBuffer;
+    getDecryptMemory(totalSize * factor, kSegmentIndex, sourceBuffer);
+    auto base = fillRandom(sourceBuffer);
 
-    const SharedBuffer sourceBuffer = {.bufferId = kSegmentIndex, .offset = 0, .size = totalSize};
-    fillRandom(sharedMemory);
+    SharedBuffer sourceRange;
+    sourceRange.bufferId = kSegmentIndex;
+    sourceRange.offset = 0;
+    sourceRange.size = totalSize;
 
-    const DestinationBuffer destBuffer = {
-            .type = BufferType::SHARED_MEMORY,
-            .nonsecureMemory = {.bufferId = kSegmentIndex, .offset = totalSize, .size = totalSize},
-            .secureMemory = {.fds = {}, .ints = {}}};
-    const uint64_t offset = 0;
-    uint32_t bytesWritten = 0;
-    vector<uint8_t> keyIdVec(keyId.begin(), keyId.end());
-    DecryptResult result;
-    auto ret = cryptoPlugin->decrypt(isSecure, keyIdVec, ivVec, mode, pattern, subSamples,
-                                     sourceBuffer, offset, destBuffer, &result);
+    SharedBuffer destRange;
+    destRange.bufferId = kSegmentIndex;
+    destRange.offset = totalSize;
+    destRange.size = totalSize;
+
+    DecryptArgs args;
+    args.secure = isSecure;
+    args.keyId = keyIdVec;
+    args.iv = ivVec;
+    args.mode = mode;
+    args.pattern = pattern;
+    args.subSamples = subSamples;
+    args.source = std::move(sourceRange);
+    args.offset = 0;
+    args.destination = std::move(destRange);
+
+    int32_t bytesWritten = 0;
+    auto ret = cryptoPlugin->decrypt(args, &bytesWritten);
     EXPECT_TXN(ret);
-    EXPECT_EQ(expectedStatus, DrmErr(ret)) << "Unexpected decrypt status " << result.detailedError;
-    bytesWritten = result.bytesWritten;
+    EXPECT_EQ(expectedStatus, DrmErr(ret)) << "Unexpected decrypt status " << ret.getMessage();
 
     if (bytesWritten != totalSize) {
         return bytesWritten;
     }
-    ::ndk::ScopedFileDescriptor fd = sharedMemory.fd.dup();
-    uint8_t* base = static_cast<uint8_t*>(
-            mmap(nullptr, totalSize, PROT_READ | PROT_WRITE, MAP_SHARED, fd.get(), 0));
-    EXPECT_NE(MAP_FAILED, base);
 
     // generate reference vector
     vector<uint8_t> reference(totalSize);
@@ -513,6 +537,7 @@
     EXPECT_EQ(0, memcmp(static_cast<void*>(&reference[0]), static_cast<void*>(base + totalSize),
                         totalSize))
             << "decrypt data mismatch";
+    munmap(base, totalSize * factor);
     return totalSize;
 }
 
diff --git a/drm/aidl/vts/drm_hal_test.cpp b/drm/aidl/vts/drm_hal_test.cpp
index 3ac9f5c..266ea39 100644
--- a/drm/aidl/vts/drm_hal_test.cpp
+++ b/drm/aidl/vts/drm_hal_test.cpp
@@ -66,11 +66,8 @@
  * Ensure drm factory supports module UUID Scheme
  */
 TEST_P(DrmHalTest, VendorUuidSupported) {
-    bool result = false;
-    auto ret =
-            drmFactory->isCryptoSchemeSupported(getAidlUUID(), kVideoMp4, kSwSecureCrypto, &result);
-    ALOGI("kVideoMp4 = %s res %d", kVideoMp4, static_cast<bool>(result));
-    EXPECT_OK(ret);
+    bool result = isCryptoSchemeSupported(getAidlUUID(), kSwSecureCrypto, kVideoMp4);
+    ALOGI("kVideoMp4 = %s res %d", kVideoMp4, result);
     EXPECT_TRUE(result);
 }
 
@@ -80,10 +77,7 @@
 TEST_P(DrmHalTest, InvalidPluginNotSupported) {
     const vector<uint8_t> kInvalidUUID = {0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80,
                                           0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80};
-    bool result = false;
-    auto ret = drmFactory->isCryptoSchemeSupported(toAidlUuid(kInvalidUUID), kVideoMp4,
-                                                   kSwSecureCrypto, &result);
-    EXPECT_OK(ret);
+    auto result = isCryptoSchemeSupported(toAidlUuid(kInvalidUUID), kSwSecureCrypto, kVideoMp4);
     EXPECT_FALSE(result);
 }
 
@@ -93,10 +87,7 @@
 TEST_P(DrmHalTest, EmptyPluginUUIDNotSupported) {
     vector<uint8_t> emptyUUID(16);
     memset(emptyUUID.data(), 0, 16);
-    bool result = false;
-    auto ret = drmFactory->isCryptoSchemeSupported(toAidlUuid(emptyUUID), kVideoMp4,
-                                                   kSwSecureCrypto, &result);
-    EXPECT_OK(ret);
+    auto result = isCryptoSchemeSupported(toAidlUuid(emptyUUID), kSwSecureCrypto, kVideoMp4);
     EXPECT_FALSE(result);
 }
 
@@ -104,10 +95,7 @@
  * Ensure drm factory doesn't support an invalid mime type
  */
 TEST_P(DrmHalTest, BadMimeNotSupported) {
-    bool result = false;
-    auto ret =
-            drmFactory->isCryptoSchemeSupported(getAidlUUID(), kBadMime, kSwSecureCrypto, &result);
-    EXPECT_OK(ret);
+    auto result = isCryptoSchemeSupported(getAidlUUID(), kSwSecureCrypto, kBadMime);
     EXPECT_FALSE(result);
 }
 
@@ -380,9 +368,7 @@
  * Ensure clearkey drm factory doesn't support security level higher than supported
  */
 TEST_P(DrmHalClearkeyTest, BadLevelNotSupported) {
-    bool result = false;
-    auto ret = drmFactory->isCryptoSchemeSupported(getAidlUUID(), kVideoMp4, kHwSecureAll, &result);
-    EXPECT_OK(ret);
+    auto result = isCryptoSchemeSupported(getAidlUUID(), kHwSecureAll, kVideoMp4);
     EXPECT_FALSE(result);
 }
 
@@ -461,7 +447,7 @@
     const vector<KeyStatus> keyStatusList = {
             {{0xa, 0xb, 0xc}, KeyStatusType::USABLE},
             {{0xd, 0xe, 0xf}, KeyStatusType::EXPIRED},
-            {{0x0, 0x1, 0x2}, KeyStatusType::USABLEINFUTURE},
+            {{0x0, 0x1, 0x2}, KeyStatusType::USABLE_IN_FUTURE},
     };
     EXPECT_EQ(sessionId, args.sessionId);
     EXPECT_EQ(keyStatusList, args.keyStatusList);
diff --git a/drm/aidl/vts/drm_hal_test_main.cpp b/drm/aidl/vts/drm_hal_test_main.cpp
index dc0f6d7..833a51a 100644
--- a/drm/aidl/vts/drm_hal_test_main.cpp
+++ b/drm/aidl/vts/drm_hal_test_main.cpp
@@ -42,21 +42,15 @@
 using drm_vts::PrintParamInstanceToString;
 
 static const std::vector<DrmHalTestParam> getAllInstances() {
-    using ::aidl::android::hardware::drm::ICryptoFactory;
     using ::aidl::android::hardware::drm::IDrmFactory;
 
     std::vector<std::string> drmInstances =
             android::getAidlHalInstanceNames(IDrmFactory::descriptor);
-    std::vector<std::string> cryptoInstances =
-            android::getAidlHalInstanceNames(ICryptoFactory::descriptor);
 
     std::set<std::string> allInstances;
     for (auto svc : drmInstances) {
         allInstances.insert(HalBaseName(svc));
     }
-    for (auto svc : cryptoInstances) {
-        allInstances.insert(HalBaseName(svc));
-    }
 
     std::vector<DrmHalTestParam> allInstanceUuidCombos;
     auto noUUID = [](std::string s) { return DrmHalTestParam(s); };
diff --git a/drm/aidl/vts/include/drm_hal_common.h b/drm/aidl/vts/include/drm_hal_common.h
index 4aac48b..2c7e514 100644
--- a/drm/aidl/vts/include/drm_hal_common.h
+++ b/drm/aidl/vts/include/drm_hal_common.h
@@ -18,14 +18,17 @@
 
 #include <aidl/android/hardware/common/Ashmem.h>
 #include <aidl/android/hardware/drm/BnDrmPluginListener.h>
-#include <aidl/android/hardware/drm/ICryptoFactory.h>
 #include <aidl/android/hardware/drm/ICryptoPlugin.h>
 #include <aidl/android/hardware/drm/IDrmFactory.h>
 #include <aidl/android/hardware/drm/IDrmPlugin.h>
 #include <aidl/android/hardware/drm/IDrmPluginListener.h>
 #include <aidl/android/hardware/drm/Status.h>
+#include <android/binder_auto_utils.h>
+
+#include <gmock/gmock.h>
 
 #include <array>
+#include <algorithm>
 #include <chrono>
 #include <future>
 #include <iostream>
@@ -35,8 +38,6 @@
 #include <utility>
 #include <vector>
 
-#include <android/binder_auto_utils.h>
-
 #include "VtsHalHidlTargetCallbackBase.h"
 #include "drm_hal_vendor_module_api.h"
 #include "drm_vts_helper.h"
@@ -80,11 +81,14 @@
     std::array<uint8_t, 16> GetParamUUID() { return GetParam().scheme_; }
     std::string GetParamService() { return GetParam().instance_; }
     ::aidl::android::hardware::drm::Uuid toAidlUuid(const std::vector<uint8_t>& in_uuid) {
-        ::aidl::android::hardware::drm::Uuid uuid;
-        uuid.uuid = in_uuid;
-        return uuid;
+        std::array<uint8_t, 16> a;
+        std::copy_n(in_uuid.begin(), a.size(), a.begin());
+        return {a};
     }
 
+    bool isCryptoSchemeSupported(::aidl::android::hardware::drm::Uuid uuid,
+                                 ::aidl::android::hardware::drm::SecurityLevel level,
+                                 std::string mime);
     void provision();
     SessionId openSession(::aidl::android::hardware::drm::SecurityLevel level,
                           ::aidl::android::hardware::drm::Status* err);
@@ -106,8 +110,8 @@
 
     KeyedVector toAidlKeyedVector(const std::map<std::string, std::string>& params);
     std::array<uint8_t, 16> toStdArray(const std::vector<uint8_t>& vec);
-    void fillRandom(const ::aidl::android::hardware::common::Ashmem& ashmem);
-    ::aidl::android::hardware::common::Ashmem getDecryptMemory(size_t size, size_t index);
+    uint8_t* fillRandom(const ::aidl::android::hardware::drm::SharedBuffer& buf);
+    void getDecryptMemory(size_t size, size_t index, SharedBuffer& buf);
 
     uint32_t decrypt(::aidl::android::hardware::drm::Mode mode, bool isSecure,
                      const std::array<uint8_t, 16>& keyId, uint8_t* iv,
@@ -123,7 +127,6 @@
                          const std::vector<uint8_t>& key);
 
     std::shared_ptr<::aidl::android::hardware::drm::IDrmFactory> drmFactory;
-    std::shared_ptr<::aidl::android::hardware::drm::ICryptoFactory> cryptoFactory;
     std::shared_ptr<::aidl::android::hardware::drm::IDrmPlugin> drmPlugin;
     std::shared_ptr<::aidl::android::hardware::drm::ICryptoPlugin> cryptoPlugin;
 
@@ -139,16 +142,13 @@
   public:
     virtual void SetUp() override {
         DrmHalTest::SetUp();
-        const std::vector<uint8_t> kClearKeyUUID = {0xE2, 0x71, 0x9D, 0x58, 0xA9, 0x85, 0xB3, 0xC9,
-                                                    0x78, 0x1A, 0xB0, 0x30, 0xAF, 0x78, 0xD3, 0x0E};
+        auto kClearKeyUUID = toAidlUuid({0xE2, 0x71, 0x9D, 0x58, 0xA9, 0x85, 0xB3, 0xC9,
+                                         0x78, 0x1A, 0xB0, 0x30, 0xAF, 0x78, 0xD3, 0x0E});
         static const std::string kMimeType = "video/mp4";
         static constexpr ::aidl::android::hardware::drm::SecurityLevel kSecurityLevel =
                 ::aidl::android::hardware::drm::SecurityLevel::SW_SECURE_CRYPTO;
 
-        bool drmClearkey = false;
-        auto ret = drmFactory->isCryptoSchemeSupported(toAidlUuid(kClearKeyUUID), kMimeType,
-                                                       kSecurityLevel, &drmClearkey);
-        if (!drmClearkey) {
+        if (!isCryptoSchemeSupported(kClearKeyUUID, kSecurityLevel, kMimeType)) {
             GTEST_SKIP() << "ClearKey not supported by " << GetParamService();
         }
     }