widevine-partner/android
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove dependencies from frameworks C++ containers.

Browse Source 
Replace AString, KeyedVector, List, String8 and Vector
with stl containers. Remove corresponding frameworks
libraries.

Test: Play Movies & TV (streaming and pinning)
Test: Netflix
Test: unit tests

bug: 34677927
Change-Id: I125f45054987d69bbca59c1ffdcbe8add38c3c13
This commit is contained in:
Edwin Wong
2017-03-31 18:34:01 -07:00
parent 82a0ed59fe
commit d9e7070de7
13 changed files with 452 additions and 336 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
libwvdrmengine/mediadrm/test/Android.mk
View File

@@ -34,9 +34,7 @@ LOCAL_SHARED_LIBRARIES := \
libcutils \
libdl \
liblog \
libmedia \
libprotobuf-cpp-lite \
libstagefright_foundation \
libutils \
LOCAL_C_INCLUDES += \
@@ -102,9 +100,7 @@ LOCAL_SHARED_LIBRARIES := \
libhidlbase \
libhidlmemory \
liblog \
libmedia \
libprotobuf-cpp-lite \
libstagefright_foundation \
libutils \
LOCAL_C_INCLUDES += \

290
libwvdrmengine/mediadrm/test/WVDrmPlugin_test.cpp
View File

@@ -3,26 +3,22 @@
//
//#define LOG_NDEBUG 0
#define LOG_TAG "WVDrmPluginTest"
#include <utils/KeyedVector.h>
#include "utils/List.h"
#include <utils/Log.h>
#include <utils/String8.h>
#include <android/hardware/drm/1.0/types.h>
#include <android/hardware/drm/1.0/IDrmPlugin.h>
#include <android/hardware/drm/1.0/IDrmPluginListener.h>
#include <stdio.h>
#include <string.h>
#include <ostream>
#include <string>
#include <list>
#include "cdm_client_property_set.h"
#include "cutils/properties.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include "media/stagefright/foundation/ABase.h"
#include "media/stagefright/foundation/AString.h"
#include "media/stagefright/MediaErrors.h"
#include "wv_cdm_constants.h"
#include "wv_cdm_types.h"
@@ -43,9 +39,6 @@ using ::android::hardware::drm::V1_0::KeyStatusType;
using ::android::hardware::drm::V1_0::Status;
using ::android::hardware::drm::V1_0::widevine::toHidlVec;
using ::android::hardware::hidl_vec;
using ::android::List;
using ::android::KeyedVector;
using ::android::String8;
using ::testing::_;
using ::testing::AllOf;
@@ -116,9 +109,9 @@ using wvcdm::SESSION_ID_PREFIX;
using wvcdm::WvCdmEventListener;
namespace {
const String8 kEmptyString;
const String8 kOrigin("widevine.com");
const String8 kAppId("com.unittest.mock.app.id");
const std::string kEmptyString;
const std::string kOrigin("widevine.com");
const std::string kAppId("com.unittest.mock.app.id");
const uint8_t* const kUnprovisionResponse =
reinterpret_cast<const uint8_t*>("unprovision");
const size_t kUnprovisionResponseSize = 11;
@@ -245,7 +238,7 @@ class WVDrmPluginTest : public Test {
protected:
static const uint32_t kSessionIdSize = 16;
uint8_t sessionIdRaw[kSessionIdSize];
Vector<uint8_t> sessionId;
std::vector<uint8_t> sessionId;
CdmSessionId cdmSessionId;
virtual void SetUp() {
@@ -255,7 +248,7 @@ class WVDrmPluginTest : public Test {
fclose(fp);
memcpy(sessionIdRaw, SESSION_ID_PREFIX, sizeof(SESSION_ID_PREFIX) - 1);
sessionId.appendArray(sessionIdRaw, kSessionIdSize);
sessionId.assign(sessionIdRaw, sessionIdRaw + kSessionIdSize);
cdmSessionId.assign(sessionId.begin(), sessionId.end());
// Set default return values for gMock
@@ -267,13 +260,14 @@ class WVDrmPluginTest : public Test {
struct OriginTestVariant {
// For a test that does not expect any follow-up queries
OriginTestVariant(const std::string& nameValue, const String8& originValue,
OriginTestVariant(const std::string& nameValue,
const std::string& originValue,
const std::string& expectedOriginValue)
: name(nameValue), origin(originValue),
expectedOrigin(expectedOriginValue) {}
const std::string name;
const String8 origin;
const std::string origin;
const std::string expectedOrigin;
};
@@ -311,7 +305,7 @@ TEST_F(WVDrmPluginTest, OpensSessions) {
plugin.openSession([&](Status status, hidl_vec<uint8_t> hSessionId) {
ASSERT_EQ(Status::OK, status);
sessionId.clear();
sessionId.appendArray(hSessionId.data(), hSessionId.size());
sessionId.assign(hSessionId.data(), hSessionId.data() + hSessionId.size());
});
EXPECT_THAT(sessionId, ElementsAreArray(sessionIdRaw, kSessionIdSize));
@@ -372,12 +366,12 @@ TEST_F(WVDrmPluginTest, DISABLED_GeneratesKeyRequests) {
memcpy(keySetIdRaw, KEY_SET_ID_PREFIX, sizeof(KEY_SET_ID_PREFIX) - 1);
CdmKeySetId cdmKeySetId(reinterpret_cast<char*>(keySetIdRaw), kKeySetIdSize);
Vector<uint8_t> keySetId;
keySetId.appendArray(keySetIdRaw, kKeySetIdSize);
std::vector<uint8_t> keySetId;
keySetId.assign(keySetIdRaw, keySetIdRaw + kKeySetIdSize);
CdmInitData cdmInitData(reinterpret_cast<char*>(initDataRaw), kInitDataSize);
Vector<uint8_t> initData;
initData.appendArray(initDataRaw, kInitDataSize);
std::vector<uint8_t> initData;
initData.assign(initDataRaw, initDataRaw + kInitDataSize);
static const uint8_t psshPrefix[] = {
0, 0, 0, 32 + kInitDataSize, // Total size
@@ -393,25 +387,29 @@ TEST_F(WVDrmPluginTest, DISABLED_GeneratesKeyRequests) {
memcpy(psshBoxRaw, psshPrefix, kPsshPrefixSize);
memcpy(psshBoxRaw + kPsshPrefixSize, initDataRaw, kInitDataSize);
CdmInitData cdmPsshBox(reinterpret_cast<char*>(psshBoxRaw), kPsshBoxSize);
Vector<uint8_t> psshBox;
psshBox.appendArray(psshBoxRaw, kPsshBoxSize);
std::vector<uint8_t> psshBox;
psshBox.assign(psshBoxRaw, psshBoxRaw + kPsshBoxSize);
CdmKeyMessage cdmRequest(requestRaw, requestRaw + kRequestSize);
KeyedVector<String8, String8> parameters;
std::map<std::string, std::string> parameters;
CdmAppParameterMap cdmParameters;
parameters.add(String8("paddingScheme"), String8("BUBBLE WRAP"));
parameters.insert(
std::pair<std::string, std::string>("paddingScheme", "BUBBLE WRAP"));
cdmParameters["paddingScheme"] = "BUBBLE WRAP";
parameters.add(String8("favorite-particle"), String8("tetraquark"));
parameters.insert(
std::pair<std::string, std::string>("favorite-particle", "tetraquark"));
cdmParameters["favorite-particle"] = "tetraquark";
parameters.add(String8("answer"), String8("6 * 9"));
parameters.insert(
std::pair<std::string, std::string>("answer", "6 * 9"));
cdmParameters["answer"] = "6 * 9";
Vector<KeyValue> optionalParameters;
std::vector<KeyValue> optionalParameters;
KeyValue keyValue;
for (size_t i = 0; i < parameters.size(); ++i) {
keyValue.key = parameters.keyAt(i);
keyValue.value = parameters.valueAt(i);
for (std::map<std::string, std::string>::iterator itr = parameters.begin();
itr != parameters.end(); ++itr) {
keyValue.key = itr->first;
keyValue.value = itr->second;
optionalParameters.push_back(keyValue);
}
@@ -421,7 +419,7 @@ TEST_F(WVDrmPluginTest, DISABLED_GeneratesKeyRequests) {
struct TestSet {
const char* mimeType;
const Vector<uint8_t>& initDataIn;
const std::vector<uint8_t>& initDataIn;
const CdmInitData& initDataOut;
};
@@ -490,8 +488,8 @@ TEST_F(WVDrmPluginTest, DISABLED_GeneratesKeyRequests) {
WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto);
for (size_t i = 0; i < testSetCount; ++i)
{
const String8 mimeType(testSets[i].mimeType);
const Vector<uint8_t>& initData = testSets[i].initDataIn;
const std::string mimeType(testSets[i].mimeType);
const std::vector<uint8_t>& initData = testSets[i].initDataIn;
plugin.getKeyRequest(
toHidlVec(sessionId), toHidlVec(initData),
@@ -551,14 +549,14 @@ TEST_F(WVDrmPluginTest, AddsKeys) {
fread(keySetIdRaw, sizeof(uint8_t), kKeySetIdSize, fp);
fclose(fp);
Vector<uint8_t> response;
response.appendArray(responseRaw, kResponseSize);
std::vector<uint8_t> response;
response.assign(responseRaw, responseRaw + kResponseSize);
memcpy(keySetIdRaw, KEY_SET_ID_PREFIX, sizeof(KEY_SET_ID_PREFIX) - 1);
CdmKeySetId cdmKeySetId(reinterpret_cast<char *>(keySetIdRaw), kKeySetIdSize);
Vector<uint8_t> keySetId;
Vector<uint8_t> emptyKeySetId;
std::vector<uint8_t> keySetId;
std::vector<uint8_t> emptyKeySetId;
EXPECT_CALL(*cdm, AddKey(cdmSessionId,
ElementsAreArray(responseRaw, kResponseSize), _))
@@ -577,7 +575,7 @@ TEST_F(WVDrmPluginTest, AddsKeys) {
ASSERT_EQ(Status::OK, status);
std::vector<uint8_t> id(hKeySetId);
keySetId.appendArray(id.data(), id.size());
keySetId.assign(id.data(), id.data() + id.size());
ASSERT_THAT(keySetId, ElementsAreArray(keySetIdRaw, kKeySetIdSize));
});
@@ -639,7 +637,7 @@ TEST_F(WVDrmPluginTest, HandlesPrivacyCertCaseOfAddKey) {
plugin.openSession([&](Status status, hidl_vec<uint8_t> hSessionId) {
ASSERT_EQ(Status::OK, status);
sessionId.clear();
sessionId.appendArray(hSessionId.data(), hSessionId.size());
sessionId.assign(hSessionId.data(), hSessionId.data() + hSessionId.size());
});
ASSERT_THAT(propertySet, NotNull());
@@ -650,9 +648,9 @@ TEST_F(WVDrmPluginTest, HandlesPrivacyCertCaseOfAddKey) {
ASSERT_EQ(Status::OK, status);
EXPECT_TRUE(propertySet->use_privacy_mode());
Vector<uint8_t> response;
response.appendArray(responseRaw, kResponseSize);
Vector<uint8_t> keySetId;
std::vector<uint8_t> response;
response.assign(responseRaw, responseRaw + kResponseSize);
std::vector<uint8_t> keySetId;
plugin.provideKeyResponse(
toHidlVec(sessionId), toHidlVec(response),
@@ -691,8 +689,8 @@ TEST_F(WVDrmPluginTest, RestoresKeys) {
fread(keySetIdRaw, sizeof(uint8_t), kKeySetIdSize, fp);
fclose(fp);
Vector<uint8_t> keySetId;
keySetId.appendArray(keySetIdRaw, kKeySetIdSize);
std::vector<uint8_t> keySetId;
keySetId.assign(keySetIdRaw, keySetIdRaw + kKeySetIdSize);
EXPECT_CALL(*cdm, RestoreKey(cdmSessionId,
ElementsAreArray(keySetIdRaw, kKeySetIdSize)))
@@ -711,14 +709,17 @@ TEST_F(WVDrmPluginTest, QueriesKeyStatus) {
.WillOnce(DoAll(SetArgPointee<2>(kDeviceId),
testing::Return(wvcdm::NO_ERROR)));
KeyedVector<String8, String8> expectedLicenseStatus;
std::map<std::string, std::string> expectedLicenseStatus;
CdmQueryMap cdmLicenseStatus;
expectedLicenseStatus.add(String8("areTheKeysAllRight"), String8("yes"));
expectedLicenseStatus.insert(
std::pair<std::string, std::string>("areTheKeysAllRight", "yes"));
cdmLicenseStatus["areTheKeysAllRight"] = "yes";
expectedLicenseStatus.add(String8("isGMockAwesome"), String8("ohhhhhhYeah"));
expectedLicenseStatus.insert(
std::pair<std::string, std::string>("isGMockAwesome", "ohhhhhhYeah"));
cdmLicenseStatus["isGMockAwesome"] = "ohhhhhhYeah";
expectedLicenseStatus.add(String8("answer"), String8("42"));
expectedLicenseStatus.insert(
std::pair<std::string, std::string>("answer", "42"));
cdmLicenseStatus["answer"] = "42";
EXPECT_CALL(*cdm, QueryKeyStatus(cdmSessionId, _))
@@ -732,11 +733,13 @@ TEST_F(WVDrmPluginTest, QueriesKeyStatus) {
ASSERT_EQ(expectedLicenseStatus.size(), hLicenseStatus.size());
KeyValue keyValuePair;
for (size_t i = 0; i < expectedLicenseStatus.size(); ++i) {
const String8& key = expectedLicenseStatus.keyAt(i);
keyValuePair = hLicenseStatus[i];
EXPECT_EQ(expectedLicenseStatus.valueFor(key),
String8(keyValuePair.value.c_str()));
size_t i = 0;
for (std::map<std::string, std::string>::iterator itr =
expectedLicenseStatus.begin();
itr != expectedLicenseStatus.end(); ++itr) {
const std::string& key = itr->first;
keyValuePair.value = hLicenseStatus[i++].value;
EXPECT_EQ(itr->second.c_str(), std::string(keyValuePair.value.c_str()));
}
});
}
@@ -791,8 +794,8 @@ TEST_F(WVDrmPluginTest, HandlesProvisioningResponses) {
fread(responseRaw, sizeof(uint8_t), kResponseSize, fp);
fclose(fp);
Vector<uint8_t> response;
response.appendArray(responseRaw, kResponseSize);
std::vector<uint8_t> response;
response.assign(responseRaw, responseRaw + kResponseSize);
EXPECT_CALL(*cdm, HandleProvisioningResponse(HasOrigin(EMPTY_ORIGIN),
ElementsAreArray(responseRaw,
@@ -800,8 +803,8 @@ TEST_F(WVDrmPluginTest, HandlesProvisioningResponses) {
_, _))
.Times(1);
Vector<uint8_t> cert;
Vector<uint8_t> key;
std::vector<uint8_t> cert;
std::vector<uint8_t> key;
WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto);
plugin.provideProvisionResponse(
@@ -866,14 +869,15 @@ TEST_F(WVDrmPluginTest, UnprovisionsOrigin) {
.WillOnce(DoAll(SetArgPointee<2>(kDeviceId),
testing::Return(wvcdm::NO_ERROR)));
Vector<uint8_t> cert;
Vector<uint8_t> key;
Vector<uint8_t> specialResponse;
specialResponse.appendArray(kUnprovisionResponse, kUnprovisionResponseSize);
std::vector<uint8_t> cert;
std::vector<uint8_t> key;
std::vector<uint8_t> specialResponse;
specialResponse.assign(
kUnprovisionResponse, kUnprovisionResponse + kUnprovisionResponseSize);
EXPECT_CALL(*cdm, Unprovision(kSecurityLevelL1, HasOrigin(kOrigin.string())))
EXPECT_CALL(*cdm, Unprovision(kSecurityLevelL1, HasOrigin(kOrigin.c_str())))
.Times(1);
EXPECT_CALL(*cdm, Unprovision(kSecurityLevelL3, HasOrigin(kOrigin.string())))
EXPECT_CALL(*cdm, Unprovision(kSecurityLevelL3, HasOrigin(kOrigin.c_str())))
.Times(1);
WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto);
@@ -908,10 +912,11 @@ TEST_F(WVDrmPluginTest, WillNotUnprovisionWithoutOrigin) {
.WillOnce(DoAll(SetArgPointee<2>(kDeviceId),
testing::Return(wvcdm::NO_ERROR)));
Vector<uint8_t> cert;
Vector<uint8_t> key;
Vector<uint8_t> specialResponse;
specialResponse.appendArray(kUnprovisionResponse, kUnprovisionResponseSize);
std::vector<uint8_t> cert;
std::vector<uint8_t> key;
std::vector<uint8_t> specialResponse;
specialResponse.assign(
kUnprovisionResponse, kUnprovisionResponse + kUnprovisionResponseSize);
EXPECT_CALL(*cdm, Unprovision(_, _))
.Times(0);
@@ -934,18 +939,19 @@ TEST_F(WVDrmPluginTest, MuxesOriginUnprovisioningErrors) {
.WillOnce(DoAll(SetArgPointee<2>(kDeviceId),
testing::Return(wvcdm::NO_ERROR)));
Vector<uint8_t> cert;
Vector<uint8_t> key;
Vector<uint8_t> specialResponse;
specialResponse.appendArray(kUnprovisionResponse, kUnprovisionResponseSize);
std::vector<uint8_t> cert;
std::vector<uint8_t> key;
std::vector<uint8_t> specialResponse;
specialResponse.assign(
kUnprovisionResponse, kUnprovisionResponse + kUnprovisionResponseSize);
// Tests that both Unprovisions are called even if one fails. Also tests that
// no matter which fails, the function always propagates the error.
EXPECT_CALL(*cdm, Unprovision(kSecurityLevelL1, HasOrigin(kOrigin.string())))
EXPECT_CALL(*cdm, Unprovision(kSecurityLevelL1, HasOrigin(kOrigin.c_str())))
.WillOnce(testing::Return(wvcdm::UNKNOWN_ERROR))
.WillOnce(testing::Return(wvcdm::NO_ERROR))
.WillOnce(testing::Return(wvcdm::UNKNOWN_ERROR));
EXPECT_CALL(*cdm, Unprovision(kSecurityLevelL3, HasOrigin(kOrigin.string())))
EXPECT_CALL(*cdm, Unprovision(kSecurityLevelL3, HasOrigin(kOrigin.c_str())))
.WillOnce(testing::Return(wvcdm::NO_ERROR))
.WillOnce(testing::Return(wvcdm::UNKNOWN_ERROR))
.WillOnce(testing::Return(wvcdm::UNKNOWN_ERROR));
@@ -1005,7 +1011,7 @@ TEST_F(WVDrmPluginTest, GetsSecureStops) {
.WillOnce(DoAll(SetArgPointee<1>(cdmStops),
testing::Return(wvcdm::NO_ERROR)));
List<std::vector<uint8_t> > stops;
std::list<std::vector<uint8_t> > stops;
WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto);
Status status = plugin.setPropertyString(hidl_string("appId"),
@@ -1024,7 +1030,7 @@ TEST_F(WVDrmPluginTest, GetsSecureStops) {
}
});
List<std::vector<uint8_t> >::iterator iter = stops.begin();
std::list<std::vector<uint8_t> >::iterator iter = stops.begin();
uint32_t rawIter = 0;
while (rawIter < kStopCount && iter != stops.end()) {
EXPECT_THAT(*iter, ElementsAreArray(stopsRaw[rawIter], kStopSize));
@@ -1072,8 +1078,8 @@ TEST_F(WVDrmPluginTest, ReleasesSecureStop) {
fread(messageRaw, sizeof(uint8_t), kMessageSize, fp);
fclose(fp);
Vector<uint8_t> message;
message.appendArray(messageRaw, kMessageSize);
std::vector<uint8_t> message;
message.assign(messageRaw, messageRaw + kMessageSize);
EXPECT_CALL(*cdm, ReleaseUsageInfo(ElementsAreArray(messageRaw,
kMessageSize)))
@@ -1131,8 +1137,8 @@ TEST_F(WVDrmPluginTest, ReturnsExpectedPropertyValues) {
testing::Return(wvcdm::NO_ERROR)));
WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto);
String8 stringResult;
Vector<uint8_t> vectorResult;
std::string stringResult;
std::vector<uint8_t> vectorResult;
plugin.getPropertyString(
hidl_string("vendor"), [&](Status status, hidl_string stringResult) {
@@ -1219,8 +1225,8 @@ TEST_F(WVDrmPluginTest, DoesNotGetUnknownProperties) {
testing::Return(wvcdm::NO_ERROR)));
WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto);
String8 stringResult;
Vector<uint8_t> vectorResult;
std::string stringResult;
std::vector<uint8_t> vectorResult;
plugin.getPropertyString(
hidl_string("unknownProperty"),
@@ -1252,8 +1258,8 @@ TEST_F(WVDrmPluginTest, DoesNotSetUnknownProperties) {
fclose(fp);
WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto);
Vector<uint8_t> value;
value.appendArray(valueRaw, kValueSize);
std::vector<uint8_t> value;
value.assign(valueRaw, valueRaw + kValueSize);
Status status = plugin.setPropertyString(hidl_string("unknownProperty"),
hidl_string("ignored"));
@@ -1272,10 +1278,10 @@ TEST_F(WVDrmPluginTest, FailsGenericMethodsWithoutAnAlgorithmSet) {
.WillOnce(DoAll(SetArgPointee<2>(kDeviceId),
testing::Return(wvcdm::NO_ERROR)));
Vector<uint8_t> keyId;
Vector<uint8_t> input;
Vector<uint8_t> iv;
Vector<uint8_t> output;
std::vector<uint8_t> keyId;
std::vector<uint8_t> input;
std::vector<uint8_t> iv;
std::vector<uint8_t> output;
bool match;
// Provide expected behavior to support session creation
@@ -1296,7 +1302,7 @@ TEST_F(WVDrmPluginTest, FailsGenericMethodsWithoutAnAlgorithmSet) {
plugin.openSession([&](Status status, hidl_vec<uint8_t> hSessionId) {
ASSERT_EQ(Status::OK, status);
sessionId.clear();
sessionId.appendArray(hSessionId.data(), hSessionId.size());
sessionId.assign(hSessionId.data(), hSessionId.data() + hSessionId.size());
});
// Note that we do not set the algorithms. This should cause these methods
@@ -1353,13 +1359,13 @@ TEST_F(WVDrmPluginTest, CallsGenericEncrypt) {
fread(ivRaw, sizeof(uint8_t), KEY_IV_SIZE, fp);
fclose(fp);
Vector<uint8_t> keyId;
keyId.appendArray(keyIdRaw, KEY_ID_SIZE);
Vector<uint8_t> input;
input.appendArray(inputRaw, kDataSize);
Vector<uint8_t> iv;
iv.appendArray(ivRaw, KEY_IV_SIZE);
Vector<uint8_t> output;
std::vector<uint8_t> keyId;
keyId.assign(keyIdRaw, keyIdRaw + KEY_ID_SIZE);
std::vector<uint8_t> input;
input.assign(inputRaw, inputRaw + kDataSize);
std::vector<uint8_t> iv;
iv.assign(ivRaw, ivRaw + KEY_IV_SIZE);
std::vector<uint8_t> output;
{
InSequence calls;
@@ -1392,7 +1398,7 @@ TEST_F(WVDrmPluginTest, CallsGenericEncrypt) {
plugin.openSession([&](Status status, hidl_vec<uint8_t> hSessionId) {
ASSERT_EQ(Status::OK, status);
sessionId.clear();
sessionId.appendArray(hSessionId.data(), hSessionId.size());
sessionId.assign(hSessionId.data(), hSessionId.data() + hSessionId.size());
});
Status status = plugin.setCipherAlgorithm(toHidlVec(sessionId),
@@ -1424,13 +1430,13 @@ TEST_F(WVDrmPluginTest, CallsGenericDecrypt) {
fread(ivRaw, sizeof(uint8_t), KEY_IV_SIZE, fp);
fclose(fp);
Vector<uint8_t> keyId;
keyId.appendArray(keyIdRaw, KEY_ID_SIZE);
Vector<uint8_t> input;
input.appendArray(inputRaw, kDataSize);
Vector<uint8_t> iv;
iv.appendArray(ivRaw, KEY_IV_SIZE);
Vector<uint8_t> output;
std::vector<uint8_t> keyId;
keyId.assign(keyIdRaw, keyIdRaw + KEY_ID_SIZE);
std::vector<uint8_t> input;
input.assign(inputRaw, inputRaw + kDataSize);
std::vector<uint8_t> iv;
iv.assign(ivRaw, ivRaw + KEY_IV_SIZE);
std::vector<uint8_t> output;
{
InSequence calls;
@@ -1463,7 +1469,7 @@ TEST_F(WVDrmPluginTest, CallsGenericDecrypt) {
plugin.openSession([&](Status status, hidl_vec<uint8_t> hSessionId) {
ASSERT_EQ(Status::OK, status);
sessionId.clear();
sessionId.appendArray(hSessionId.data(), hSessionId.size());
sessionId.assign(hSessionId.data(), hSessionId.data() + hSessionId.size());
});
Status status = plugin.setCipherAlgorithm(toHidlVec(sessionId),
@@ -1493,11 +1499,11 @@ TEST_F(WVDrmPluginTest, CallsGenericSign) {
fread(messageRaw, sizeof(uint8_t), kDataSize, fp);
fclose(fp);
Vector<uint8_t> keyId;
keyId.appendArray(keyIdRaw, KEY_ID_SIZE);
Vector<uint8_t> message;
message.appendArray(messageRaw, kDataSize);
Vector<uint8_t> signature;
std::vector<uint8_t> keyId;
keyId.assign(keyIdRaw, keyIdRaw + KEY_ID_SIZE);
std::vector<uint8_t> message;
message.assign(messageRaw, messageRaw + kDataSize);
std::vector<uint8_t> signature;
{
InSequence calls;
@@ -1536,7 +1542,7 @@ TEST_F(WVDrmPluginTest, CallsGenericSign) {
plugin.openSession([&](Status status, hidl_vec<uint8_t> hSessionId) {
ASSERT_EQ(Status::OK, status);
sessionId.clear();
sessionId.appendArray(hSessionId.data(), hSessionId.size());
sessionId.assign(hSessionId.data(), hSessionId.data() + hSessionId.size());
});
Status status = plugin.setMacAlgorithm(toHidlVec(sessionId),
@@ -1570,12 +1576,12 @@ TEST_F(WVDrmPluginTest, CallsGenericVerify) {
fread(signatureRaw, sizeof(uint8_t), kSignatureSize, fp);
fclose(fp);
Vector<uint8_t> keyId;
keyId.appendArray(keyIdRaw, KEY_ID_SIZE);
Vector<uint8_t> message;
message.appendArray(messageRaw, kDataSize);
Vector<uint8_t> signature;
signature.appendArray(signatureRaw, kSignatureSize);
std::vector<uint8_t> keyId;
keyId.assign(keyIdRaw, keyIdRaw + KEY_ID_SIZE);
std::vector<uint8_t> message;
message.assign(messageRaw, messageRaw + kDataSize);
std::vector<uint8_t> signature;
signature.assign(signatureRaw, signatureRaw + kSignatureSize);
bool match;
{
@@ -1620,7 +1626,7 @@ TEST_F(WVDrmPluginTest, CallsGenericVerify) {
plugin.openSession([&](Status status, hidl_vec<uint8_t> hSessionId) {
ASSERT_EQ(Status::OK, status);
sessionId.clear();
sessionId.appendArray(hSessionId.data(), hSessionId.size());
sessionId.assign(hSessionId.data(), hSessionId.data() + hSessionId.size());
});
Status status = plugin.setMacAlgorithm(toHidlVec(sessionId),
@@ -1738,11 +1744,11 @@ TEST_F(WVDrmPluginTest, DISABLED_MarshalsEvents) {
hidl_vec<uint8_t> hSessionId;
hSessionId.setToExternal(sessionIdRaw, kSessionIdSize);
Vector<uint8_t> keyId;
Vector<KeyStatus> keyStatusList;
std::vector<uint8_t> keyId;
std::vector<KeyStatus> keyStatusList;
KeyStatus keyStatus;
keyId.appendArray(reinterpret_cast<const uint8_t*>(kKeyId1.data()), kKeyId1.size());
keyId.assign(kKeyId1.begin(), kKeyId1.end());
keyStatus.keyId = toHidlVec(keyId);
keyStatus.type = KeyStatusType::EXPIRED;
keyStatusList.push_back(keyStatus);
@@ -1765,16 +1771,16 @@ TEST_F(WVDrmPluginTest, DISABLED_MarshalsEvents) {
keyStatusList.clear();
keyId.clear();
keyId.appendArray(reinterpret_cast<const uint8_t*>(kKeyId1.data()), kKeyId1.size());
keyId.assign(kKeyId1.begin(), kKeyId1.end());
keyStatus.type = KeyStatusType::USABLE;
keyStatusList.push_back(keyStatus);
keyId.appendArray(reinterpret_cast<const uint8_t*>(kKeyId2.data()), kKeyId2.size());
keyId.assign(kKeyId2.begin(), kKeyId2.end());
keyStatus.type = KeyStatusType::OUTPUTNOTALLOWED;
keyStatusList.push_back(keyStatus);
keyId.appendArray(reinterpret_cast<const uint8_t*>(kKeyId3.data()), kKeyId3.size());
keyId.assign(kKeyId3.begin(), kKeyId3.end());
keyStatus.type = KeyStatusType::INTERNALERROR;
keyStatusList.push_back(keyStatus);
keyId.appendArray(reinterpret_cast<const uint8_t*>(kKeyId4.data()), kKeyId4.size());
keyId.assign(kKeyId4.begin(), kKeyId4.end());
keyStatus.type = KeyStatusType::STATUSPENDING;
keyStatusList.push_back(keyStatus);
@@ -1928,7 +1934,7 @@ TEST_F(WVDrmPluginTest, CanSetAppId) {
ASSERT_THAT(propertySet, NotNull());
// Verify application id is set correctly.
EXPECT_STREQ(kAppId, propertySet->app_id().c_str());
EXPECT_STREQ(kAppId.c_str(), propertySet->app_id().c_str());
// Test setting application id while session is opened, this should fail.
status = plugin.setPropertyString(hidl_string("appId"),
@@ -1965,7 +1971,7 @@ TEST_P(WVDrmPluginOriginTest, CanSetOrigin) {
// Set the properties & run the test
WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto);
if (!params.origin.isEmpty()) {
if (!params.origin.empty()) {
ASSERT_EQ(Status::OK,
plugin.setPropertyString(hidl_string("origin"),
hidl_string(params.origin)));
@@ -1983,7 +1989,7 @@ TEST_P(WVDrmPluginOriginTest, CanSetOrigin) {
INSTANTIATE_TEST_CASE_P(OriginTests, WVDrmPluginOriginTest, Values(
OriginTestVariant("No Origin", kEmptyString, EMPTY_ORIGIN),
OriginTestVariant("With an Origin", kOrigin, kOrigin.string())));
OriginTestVariant("With an Origin", kOrigin, kOrigin.c_str())));
TEST_F(WVDrmPluginTest, CanSetSecurityLevel) {
android::sp<StrictMock<MockCDM>> cdm = new StrictMock<MockCDM>();
@@ -2028,7 +2034,7 @@ TEST_F(WVDrmPluginTest, CanSetSecurityLevel) {
plugin.openSession([&](Status status, hidl_vec<uint8_t> hSessionId) {
ASSERT_EQ(Status::OK, status);
sessionId.clear();
sessionId.appendArray(hSessionId.data(), hSessionId.size());
sessionId.assign(hSessionId.data(), hSessionId.data() + hSessionId.size());
});
ASSERT_THAT(propertySet, NotNull());
EXPECT_STREQ("L3", propertySet->security_level().c_str());
@@ -2043,7 +2049,7 @@ TEST_F(WVDrmPluginTest, CanSetSecurityLevel) {
plugin.openSession([&](Status status, hidl_vec<uint8_t> hSessionId) {
ASSERT_EQ(Status::OK, status);
sessionId.clear();
sessionId.appendArray(hSessionId.data(), hSessionId.size());
sessionId.assign(hSessionId.data(), hSessionId.data() + hSessionId.size());
});
ASSERT_THAT(propertySet, NotNull());
EXPECT_STREQ("L3", propertySet->security_level().c_str());
@@ -2058,7 +2064,7 @@ TEST_F(WVDrmPluginTest, CanSetSecurityLevel) {
plugin.openSession([&](Status status, hidl_vec<uint8_t> hSessionId) {
ASSERT_EQ(Status::OK, status);
sessionId.clear();
sessionId.appendArray(hSessionId.data(), hSessionId.size());
sessionId.assign(hSessionId.data(), hSessionId.data() + hSessionId.size());
});
ASSERT_THAT(propertySet, NotNull());
EXPECT_STREQ("", propertySet->security_level().c_str());
@@ -2073,7 +2079,7 @@ TEST_F(WVDrmPluginTest, CanSetSecurityLevel) {
plugin.openSession([&](Status status, hidl_vec<uint8_t> hSessionId) {
ASSERT_EQ(Status::OK, status);
sessionId.clear();
sessionId.appendArray(hSessionId.data(), hSessionId.size());
sessionId.assign(hSessionId.data(), hSessionId.data() + hSessionId.size());
});
ASSERT_THAT(propertySet, NotNull());
EXPECT_STREQ("L3", propertySet->security_level().c_str());
@@ -2087,7 +2093,7 @@ TEST_F(WVDrmPluginTest, CanSetSecurityLevel) {
plugin.openSession([&](Status status, hidl_vec<uint8_t> hSessionId) {
ASSERT_EQ(Status::OK, status);
sessionId.clear();
sessionId.appendArray(hSessionId.data(), hSessionId.size());
sessionId.assign(hSessionId.data(), hSessionId.data() + hSessionId.size());
});
ASSERT_THAT(propertySet, NotNull());
EXPECT_STREQ("", propertySet->security_level().c_str());
@@ -2102,7 +2108,7 @@ TEST_F(WVDrmPluginTest, CanSetSecurityLevel) {
plugin.openSession([&](Status status, hidl_vec<uint8_t> hSessionId) {
ASSERT_EQ(Status::OK, status);
sessionId.clear();
sessionId.appendArray(hSessionId.data(), hSessionId.size());
sessionId.assign(hSessionId.data(), hSessionId.data() + hSessionId.size());
});
ASSERT_THAT(propertySet, NotNull());
EXPECT_STREQ("", propertySet->security_level().c_str());
@@ -2150,7 +2156,7 @@ TEST_F(WVDrmPluginTest, CanSetPrivacyMode) {
plugin.openSession([&](Status status, hidl_vec<uint8_t> hSessionId) {
ASSERT_EQ(Status::OK, status);
sessionId.clear();
sessionId.appendArray(hSessionId.data(), hSessionId.size());
sessionId.assign(hSessionId.data(), hSessionId.data() + hSessionId.size());
});
ASSERT_THAT(propertySet, NotNull());
@@ -2189,11 +2195,11 @@ TEST_F(WVDrmPluginTest, CanSetServiceCertificate) {
fread(privacyCertRaw, sizeof(uint8_t), kPrivacyCertSize, fp);
fclose(fp);
Vector<uint8_t> privacyCert;
privacyCert.appendArray(privacyCertRaw, kPrivacyCertSize);
std::vector<uint8_t> privacyCert;
privacyCert.assign(privacyCertRaw, privacyCertRaw + kPrivacyCertSize);
std::string strPrivacyCert(reinterpret_cast<char*>(privacyCertRaw),
kPrivacyCertSize);
Vector<uint8_t> emptyVector;
std::vector<uint8_t> emptyVector;
// Provide expected mock behavior
{
@@ -2224,7 +2230,7 @@ TEST_F(WVDrmPluginTest, CanSetServiceCertificate) {
plugin.openSession([&](Status status, hidl_vec<uint8_t> hSessionId) {
ASSERT_EQ(Status::OK, status);
sessionId.clear();
sessionId.appendArray(hSessionId.data(), hSessionId.size());
sessionId.assign(hSessionId.data(), hSessionId.data() + hSessionId.size());
});
ASSERT_THAT(propertySet, NotNull());
@@ -2286,7 +2292,7 @@ TEST_F(WVDrmPluginTest, CanSetSessionSharing) {
plugin.openSession([&](Status status, hidl_vec<uint8_t> hSessionId) {
ASSERT_EQ(Status::OK, status);
sessionId.clear();
sessionId.appendArray(hSessionId.data(), hSessionId.size());
sessionId.assign(hSessionId.data(), hSessionId.data() + hSessionId.size());
});
ASSERT_THAT(propertySet, NotNull());
EXPECT_TRUE(propertySet->is_session_sharing_enabled());
@@ -2301,7 +2307,7 @@ TEST_F(WVDrmPluginTest, CanSetSessionSharing) {
plugin.openSession([&](Status status, hidl_vec<uint8_t> hSessionId) {
ASSERT_EQ(Status::OK, status);
sessionId.clear();
sessionId.appendArray(hSessionId.data(), hSessionId.size());
sessionId.assign(hSessionId.data(), hSessionId.data() + hSessionId.size());
});
ASSERT_THAT(propertySet, NotNull());
EXPECT_FALSE(propertySet->is_session_sharing_enabled());
@@ -2317,7 +2323,7 @@ TEST_F(WVDrmPluginTest, CanSetSessionSharing) {
plugin.openSession([&](Status status, hidl_vec<uint8_t> hSessionId) {
ASSERT_EQ(Status::OK, status);
sessionId.clear();
sessionId.appendArray(hSessionId.data(), hSessionId.size());
sessionId.assign(hSessionId.data(), hSessionId.data() + hSessionId.size());
});
status = plugin.setPropertyString(hidl_string("sessionSharing"),
hidl_string("enable"));
@@ -2363,7 +2369,7 @@ TEST_F(WVDrmPluginTest, AllowsStoringOfSessionSharingId) {
plugin.openSession([&](Status status, hidl_vec<uint8_t> hSessionId) {
ASSERT_EQ(Status::OK, status);
sessionId.clear();
sessionId.appendArray(hSessionId.data(), hSessionId.size());
sessionId.assign(hSessionId.data(), hSessionId.data() + hSessionId.size());
});
ASSERT_THAT(propertySet, NotNull());