Return<void> CryptoPlugin::setSharedBufferBase(const hidl_memory& base,
uint32_t bufferId) {
- mSharedBufferMap[bufferId] = mapMemory(base);
+ sp<IMemory> hidlMemory = mapMemory(base);
+ ALOGE_IF(hidlMemory == nullptr, "mapMemory returns nullptr");
+
+ // allow mapMemory to return nullptr
+ mSharedBufferMap[bufferId] = hidlMemory;
return Void();
}
AString detailMessage;
sp<IMemory> sourceBase = mSharedBufferMap[source.bufferId];
+ if (sourceBase == nullptr) {
+ _hidl_cb(Status::ERROR_DRM_CANNOT_HANDLE, 0, "source is a nullptr");
+ return Void();
+ }
if (source.offset + offset + source.size > sourceBase->getSize()) {
_hidl_cb(Status::ERROR_DRM_CANNOT_HANDLE, 0, "invalid buffer size");
if (destination.type == BufferType::SHARED_MEMORY) {
const SharedBuffer& destBuffer = destination.nonsecureMemory;
sp<IMemory> destBase = mSharedBufferMap[destBuffer.bufferId];
+ if (destBase == nullptr) {
+ _hidl_cb(Status::ERROR_DRM_CANNOT_HANDLE, 0, "destination is a nullptr");
+ return Void();
+ }
+
if (destBuffer.offset + destBuffer.size > destBase->getSize()) {
_hidl_cb(Status::ERROR_DRM_CANNOT_HANDLE, 0, "invalid buffer size");
return Void();
drmFactory =
::testing::VtsHalHidlTargetTestBase::getService<IDrmFactory>();
- ASSERT_NE(drmFactory, nullptr);
+ ASSERT_NE(nullptr, drmFactory.get());
cryptoFactory =
::testing::VtsHalHidlTargetTestBase::getService<ICryptoFactory>();
- ASSERT_NE(cryptoFactory, nullptr);
+ ASSERT_NE(nullptr, cryptoFactory.get());
}
virtual void TearDown() override {}
kClearKeyUUID, packageName,
[&](Status status, const sp<IDrmPlugin>& plugin) {
EXPECT_EQ(Status::OK, status);
- EXPECT_NE(plugin, nullptr);
+ EXPECT_NE(nullptr, plugin.get());
});
EXPECT_OK(res);
}
kClearKeyUUID, initVec,
[&](Status status, const sp<ICryptoPlugin>& plugin) {
EXPECT_EQ(Status::OK, status);
- EXPECT_NE(plugin, nullptr);
+ EXPECT_NE(nullptr, plugin.get());
});
EXPECT_OK(res);
}
kInvalidUUID, packageName,
[&](Status status, const sp<IDrmPlugin>& plugin) {
EXPECT_EQ(Status::ERROR_DRM_CANNOT_HANDLE, status);
- EXPECT_EQ(plugin, nullptr);
+ EXPECT_EQ(nullptr, plugin.get());
});
EXPECT_OK(res);
}
kInvalidUUID, initVec,
[&](Status status, const sp<ICryptoPlugin>& plugin) {
EXPECT_EQ(Status::ERROR_DRM_CANNOT_HANDLE, status);
- EXPECT_EQ(plugin, nullptr);
+ EXPECT_EQ(nullptr, plugin.get());
});
EXPECT_OK(res);
}
// Create factories
DrmHalClearkeyFactoryTest::SetUp();
- ASSERT_NE(drmFactory, nullptr);
+ ASSERT_NE(nullptr, drmFactory.get());
hidl_string packageName("android.hardware.drm.test");
auto res = drmFactory->createPlugin(
kClearKeyUUID, packageName,
[this](Status status, const sp<IDrmPlugin>& plugin) {
EXPECT_EQ(Status::OK, status);
- ASSERT_NE(plugin, nullptr);
+ ASSERT_NE(nullptr, plugin.get());
drmPlugin = plugin;
});
ASSERT_OK(res);
kClearKeyUUID, initVec,
[this](Status status, const sp<ICryptoPlugin>& plugin) {
EXPECT_EQ(Status::OK, status);
- ASSERT_NE(plugin, nullptr);
+ ASSERT_NE(nullptr, plugin.get());
cryptoPlugin = plugin;
});
ASSERT_OK(res);
sp<IMemory> DrmHalClearkeyPluginTest::getDecryptMemory(size_t size,
size_t index) {
sp<IAllocator> ashmemAllocator = IAllocator::getService("ashmem");
- EXPECT_NE(ashmemAllocator, nullptr);
+ EXPECT_NE(nullptr, ashmemAllocator.get());
hidl_memory hidlMemory;
auto res = ashmemAllocator->allocate(
EXPECT_OK(res);
sp<IMemory> mappedMemory = mapMemory(hidlMemory);
+ EXPECT_NE(nullptr, mappedMemory.get());
EXPECT_OK(cryptoPlugin->setSharedBufferBase(hidlMemory, index));
return mappedMemory;
}
test_info->test_case_name(), test_info->name(),
GetParam().c_str());
- ASSERT_NE(vendorModule, nullptr);
+ ASSERT_NE(nullptr, vendorModule.get());
// First try the binderized service name provided by the vendor module.
// If that fails, which it can on non-binderized devices, try the default
if (drmFactory == nullptr) {
drmFactory = VtsTestBase::getService<IDrmFactory>();
}
- ASSERT_NE(drmFactory, nullptr);
+ ASSERT_NE(nullptr, drmFactory.get());
// Do the same for the crypto factory
cryptoFactory = VtsTestBase::getService<ICryptoFactory>(name);
if (cryptoFactory == nullptr) {
cryptoFactory = VtsTestBase::getService<ICryptoFactory>();
}
- ASSERT_NE(cryptoFactory, nullptr);
+ ASSERT_NE(nullptr, cryptoFactory.get());
// If drm scheme not installed skip subsequent tests
if (!drmFactory->isCryptoSchemeSupported(getVendorUUID())) {
getVendorUUID(), packageName,
[&](Status status, const sp<IDrmPlugin>& plugin) {
EXPECT_EQ(Status::OK, status);
- EXPECT_NE(plugin, nullptr);
+ EXPECT_NE(nullptr, plugin.get());
});
EXPECT_OK(res);
}
getVendorUUID(), initVec,
[&](Status status, const sp<ICryptoPlugin>& plugin) {
EXPECT_EQ(Status::OK, status);
- EXPECT_NE(plugin, nullptr);
+ EXPECT_NE(nullptr, plugin.get());
});
EXPECT_OK(res);
}
kInvalidUUID, packageName,
[&](Status status, const sp<IDrmPlugin>& plugin) {
EXPECT_EQ(Status::ERROR_DRM_CANNOT_HANDLE, status);
- EXPECT_EQ(plugin, nullptr);
+ EXPECT_EQ(nullptr, plugin.get());
});
EXPECT_OK(res);
}
kInvalidUUID, initVec,
[&](Status status, const sp<ICryptoPlugin>& plugin) {
EXPECT_EQ(Status::ERROR_DRM_CANNOT_HANDLE, status);
- EXPECT_EQ(plugin, nullptr);
+ EXPECT_EQ(nullptr, plugin.get());
});
EXPECT_OK(res);
}
getVendorUUID(), packageName,
[this](Status status, const sp<IDrmPlugin>& plugin) {
EXPECT_EQ(Status::OK, status);
- ASSERT_NE(plugin, nullptr);
+ ASSERT_NE(nullptr, plugin.get());
drmPlugin = plugin;
});
ASSERT_OK(res);
getVendorUUID(), initVec,
[this](Status status, const sp<ICryptoPlugin>& plugin) {
EXPECT_EQ(Status::OK, status);
- ASSERT_NE(plugin, nullptr);
+ ASSERT_NE(nullptr, plugin.get());
cryptoPlugin = plugin;
});
ASSERT_OK(res);
sp<IMemory> DrmHalVendorPluginTest::getDecryptMemory(size_t size,
size_t index) {
sp<IAllocator> ashmemAllocator = IAllocator::getService("ashmem");
- EXPECT_NE(ashmemAllocator, nullptr);
+ EXPECT_NE(nullptr, ashmemAllocator.get());
hidl_memory hidlMemory;
auto res = ashmemAllocator->allocate(
EXPECT_OK(res);
sp<IMemory> mappedMemory = mapMemory(hidlMemory);
- EXPECT_NE(mappedMemory, nullptr);
+ EXPECT_NE(nullptr, mappedMemory.get());
res = cryptoPlugin->setSharedBufferBase(hidlMemory, index);
EXPECT_OK(res);
return mappedMemory;